From 732d39796101f66fb61dfa65600a65f36ddaeab0 Mon Sep 17 00:00:00 2001 From: shwetha729 Date: Tue, 15 Aug 2023 16:01:13 -0400 Subject: [PATCH] Tuesday, August 15, 2023, 16:00:09 + 5 --- enter/.obsidian/plugins/digitalgarden/main.js | 18089 ++++++++++++++++ .../plugins/digitalgarden/manifest.json | 11 + .../plugins/digitalgarden/styles.css | 26 + enter/.obsidian/workspace.json | 41 +- .../Obsidian/Obsidian-net process.md | 10 + .../imgFiles/Pasted image 20230815154156.png | Bin 0 -> 165527 bytes .../Hosting/Browser talk/Netlify & Vercel.md | 6 + 7 files changed, 18175 insertions(+), 8 deletions(-) create mode 100644 enter/.obsidian/plugins/digitalgarden/main.js create mode 100644 enter/.obsidian/plugins/digitalgarden/manifest.json create mode 100644 enter/.obsidian/plugins/digitalgarden/styles.css create mode 100644 enter/Coding Tips (Classical)/Project Vault/Obsidian/Obsidian-net process.md create mode 100644 enter/Coding Tips (Classical)/Project Vault/Obsidian/imgFiles/Pasted image 20230815154156.png create mode 100644 enter/Coding Tips (Classical)/Terminal Tips/GUIs/Internet/Hosting/Browser talk/Netlify & Vercel.md diff --git a/enter/.obsidian/plugins/digitalgarden/main.js b/enter/.obsidian/plugins/digitalgarden/main.js new file mode 100644 index 0000000..9447d48 --- /dev/null +++ b/enter/.obsidian/plugins/digitalgarden/main.js @@ -0,0 +1,18089 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); +var __objRest = (source, exclude) => { + var target = {}; + for (var prop in source) + if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0) + target[prop] = source[prop]; + if (source != null && __getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(source)) { + if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop)) + target[prop] = source[prop]; + } + return target; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key of __getOwnPropNames(module2)) + if (!__hasOwnProp.call(target, key) && key !== "default") + __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable }); + } + return target; +}; +var __toModule = (module2) => { + return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2); +}; +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// node_modules/before-after-hook/lib/register.js +var require_register = __commonJS({ + "node_modules/before-after-hook/lib/register.js"(exports, module2) { + module2.exports = register; + function register(state, name, method, options) { + if (typeof method !== "function") { + throw new Error("method for before hook must be a function"); + } + if (!options) { + options = {}; + } + if (Array.isArray(name)) { + return name.reverse().reduce(function(callback, name2) { + return register.bind(null, state, name2, callback, options); + }, method)(); + } + return Promise.resolve().then(function() { + if (!state.registry[name]) { + return method(options); + } + return state.registry[name].reduce(function(method2, registered) { + return registered.hook.bind(null, method2, options); + }, method)(); + }); + } + } +}); + +// node_modules/before-after-hook/lib/add.js +var require_add = __commonJS({ + "node_modules/before-after-hook/lib/add.js"(exports, module2) { + module2.exports = addHook; + function addHook(state, kind, name, hook2) { + var orig = hook2; + if (!state.registry[name]) { + state.registry[name] = []; + } + if (kind === "before") { + hook2 = function(method, options) { + return Promise.resolve().then(orig.bind(null, options)).then(method.bind(null, options)); + }; + } + if (kind === "after") { + hook2 = function(method, options) { + var result; + return Promise.resolve().then(method.bind(null, options)).then(function(result_) { + result = result_; + return orig(result, options); + }).then(function() { + return result; + }); + }; + } + if (kind === "error") { + hook2 = function(method, options) { + return Promise.resolve().then(method.bind(null, options)).catch(function(error) { + return orig(error, options); + }); + }; + } + state.registry[name].push({ + hook: hook2, + orig + }); + } + } +}); + +// node_modules/before-after-hook/lib/remove.js +var require_remove = __commonJS({ + "node_modules/before-after-hook/lib/remove.js"(exports, module2) { + module2.exports = removeHook; + function removeHook(state, name, method) { + if (!state.registry[name]) { + return; + } + var index = state.registry[name].map(function(registered) { + return registered.orig; + }).indexOf(method); + if (index === -1) { + return; + } + state.registry[name].splice(index, 1); + } + } +}); + +// node_modules/before-after-hook/index.js +var require_before_after_hook = __commonJS({ + "node_modules/before-after-hook/index.js"(exports, module2) { + var register = require_register(); + var addHook = require_add(); + var removeHook = require_remove(); + var bind = Function.bind; + var bindable = bind.bind(bind); + function bindApi(hook2, state, name) { + var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]); + hook2.api = { remove: removeHookRef }; + hook2.remove = removeHookRef; + ["before", "error", "after", "wrap"].forEach(function(kind) { + var args = name ? [state, kind, name] : [state, kind]; + hook2[kind] = hook2.api[kind] = bindable(addHook, null).apply(null, args); + }); + } + function HookSingular() { + var singularHookName = "h"; + var singularHookState = { + registry: {} + }; + var singularHook = register.bind(null, singularHookState, singularHookName); + bindApi(singularHook, singularHookState, singularHookName); + return singularHook; + } + function HookCollection() { + var state = { + registry: {} + }; + var hook2 = register.bind(null, state); + bindApi(hook2, state); + return hook2; + } + var collectionHookDeprecationMessageDisplayed = false; + function Hook() { + if (!collectionHookDeprecationMessageDisplayed) { + console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4'); + collectionHookDeprecationMessageDisplayed = true; + } + return HookCollection(); + } + Hook.Singular = HookSingular.bind(); + Hook.Collection = HookCollection.bind(); + module2.exports = Hook; + module2.exports.Hook = Hook; + module2.exports.Singular = Hook.Singular; + module2.exports.Collection = Hook.Collection; + } +}); + +// node_modules/node-fetch/browser.js +var require_browser = __commonJS({ + "node_modules/node-fetch/browser.js"(exports, module2) { + "use strict"; + var getGlobal = function() { + if (typeof self !== "undefined") { + return self; + } + if (typeof window !== "undefined") { + return window; + } + if (typeof global2 !== "undefined") { + return global2; + } + throw new Error("unable to locate global object"); + }; + var global2 = getGlobal(); + module2.exports = exports = global2.fetch; + if (global2.fetch) { + exports.default = global2.fetch.bind(global2); + } + exports.Headers = global2.Headers; + exports.Request = global2.Request; + exports.Response = global2.Response; + } +}); + +// node_modules/wrappy/wrappy.js +var require_wrappy = __commonJS({ + "node_modules/wrappy/wrappy.js"(exports, module2) { + module2.exports = wrappy; + function wrappy(fn2, cb) { + if (fn2 && cb) + return wrappy(fn2)(cb); + if (typeof fn2 !== "function") + throw new TypeError("need wrapper function"); + Object.keys(fn2).forEach(function(k) { + wrapper[k] = fn2[k]; + }); + return wrapper; + function wrapper() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + var ret = fn2.apply(this, args); + var cb2 = args[args.length - 1]; + if (typeof ret === "function" && ret !== cb2) { + Object.keys(cb2).forEach(function(k) { + ret[k] = cb2[k]; + }); + } + return ret; + } + } + } +}); + +// node_modules/once/once.js +var require_once = __commonJS({ + "node_modules/once/once.js"(exports, module2) { + var wrappy = require_wrappy(); + module2.exports = wrappy(once2); + module2.exports.strict = wrappy(onceStrict); + once2.proto = once2(function() { + Object.defineProperty(Function.prototype, "once", { + value: function() { + return once2(this); + }, + configurable: true + }); + Object.defineProperty(Function.prototype, "onceStrict", { + value: function() { + return onceStrict(this); + }, + configurable: true + }); + }); + function once2(fn2) { + var f = function() { + if (f.called) + return f.value; + f.called = true; + return f.value = fn2.apply(this, arguments); + }; + f.called = false; + return f; + } + function onceStrict(fn2) { + var f = function() { + if (f.called) + throw new Error(f.onceError); + f.called = true; + return f.value = fn2.apply(this, arguments); + }; + var name = fn2.name || "Function wrapped with `once`"; + f.onceError = name + " shouldn't be called more than once"; + f.called = false; + return f; + } + } +}); + +// node_modules/escape-string-regexp/index.js +var require_escape_string_regexp = __commonJS({ + "node_modules/escape-string-regexp/index.js"(exports, module2) { + "use strict"; + module2.exports = (string) => { + if (typeof string !== "string") { + throw new TypeError("Expected a string"); + } + return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d"); + }; + } +}); + +// node_modules/lodash.deburr/index.js +var require_lodash = __commonJS({ + "node_modules/lodash.deburr/index.js"(exports, module2) { + var INFINITY = 1 / 0; + var symbolTag = "[object Symbol]"; + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + var rsComboMarksRange = "\\u0300-\\u036f\\ufe20-\\ufe23"; + var rsComboSymbolsRange = "\\u20d0-\\u20f0"; + var rsCombo = "[" + rsComboMarksRange + rsComboSymbolsRange + "]"; + var reComboMark = RegExp(rsCombo, "g"); + var deburredLetters = { + "\xC0": "A", + "\xC1": "A", + "\xC2": "A", + "\xC3": "A", + "\xC4": "A", + "\xC5": "A", + "\xE0": "a", + "\xE1": "a", + "\xE2": "a", + "\xE3": "a", + "\xE4": "a", + "\xE5": "a", + "\xC7": "C", + "\xE7": "c", + "\xD0": "D", + "\xF0": "d", + "\xC8": "E", + "\xC9": "E", + "\xCA": "E", + "\xCB": "E", + "\xE8": "e", + "\xE9": "e", + "\xEA": "e", + "\xEB": "e", + "\xCC": "I", + "\xCD": "I", + "\xCE": "I", + "\xCF": "I", + "\xEC": "i", + "\xED": "i", + "\xEE": "i", + "\xEF": "i", + "\xD1": "N", + "\xF1": "n", + "\xD2": "O", + "\xD3": "O", + "\xD4": "O", + "\xD5": "O", + "\xD6": "O", + "\xD8": "O", + "\xF2": "o", + "\xF3": "o", + "\xF4": "o", + "\xF5": "o", + "\xF6": "o", + "\xF8": "o", + "\xD9": "U", + "\xDA": "U", + "\xDB": "U", + "\xDC": "U", + "\xF9": "u", + "\xFA": "u", + "\xFB": "u", + "\xFC": "u", + "\xDD": "Y", + "\xFD": "y", + "\xFF": "y", + "\xC6": "Ae", + "\xE6": "ae", + "\xDE": "Th", + "\xFE": "th", + "\xDF": "ss", + "\u0100": "A", + "\u0102": "A", + "\u0104": "A", + "\u0101": "a", + "\u0103": "a", + "\u0105": "a", + "\u0106": "C", + "\u0108": "C", + "\u010A": "C", + "\u010C": "C", + "\u0107": "c", + "\u0109": "c", + "\u010B": "c", + "\u010D": "c", + "\u010E": "D", + "\u0110": "D", + "\u010F": "d", + "\u0111": "d", + "\u0112": "E", + "\u0114": "E", + "\u0116": "E", + "\u0118": "E", + "\u011A": "E", + "\u0113": "e", + "\u0115": "e", + "\u0117": "e", + "\u0119": "e", + "\u011B": "e", + "\u011C": "G", + "\u011E": "G", + "\u0120": "G", + "\u0122": "G", + "\u011D": "g", + "\u011F": "g", + "\u0121": "g", + "\u0123": "g", + "\u0124": "H", + "\u0126": "H", + "\u0125": "h", + "\u0127": "h", + "\u0128": "I", + "\u012A": "I", + "\u012C": "I", + "\u012E": "I", + "\u0130": "I", + "\u0129": "i", + "\u012B": "i", + "\u012D": "i", + "\u012F": "i", + "\u0131": "i", + "\u0134": "J", + "\u0135": "j", + "\u0136": "K", + "\u0137": "k", + "\u0138": "k", + "\u0139": "L", + "\u013B": "L", + "\u013D": "L", + "\u013F": "L", + "\u0141": "L", + "\u013A": "l", + "\u013C": "l", + "\u013E": "l", + "\u0140": "l", + "\u0142": "l", + "\u0143": "N", + "\u0145": "N", + "\u0147": "N", + "\u014A": "N", + "\u0144": "n", + "\u0146": "n", + "\u0148": "n", + "\u014B": "n", + "\u014C": "O", + "\u014E": "O", + "\u0150": "O", + "\u014D": "o", + "\u014F": "o", + "\u0151": "o", + "\u0154": "R", + "\u0156": "R", + "\u0158": "R", + "\u0155": "r", + "\u0157": "r", + "\u0159": "r", + "\u015A": "S", + "\u015C": "S", + "\u015E": "S", + "\u0160": "S", + "\u015B": "s", + "\u015D": "s", + "\u015F": "s", + "\u0161": "s", + "\u0162": "T", + "\u0164": "T", + "\u0166": "T", + "\u0163": "t", + "\u0165": "t", + "\u0167": "t", + "\u0168": "U", + "\u016A": "U", + "\u016C": "U", + "\u016E": "U", + "\u0170": "U", + "\u0172": "U", + "\u0169": "u", + "\u016B": "u", + "\u016D": "u", + "\u016F": "u", + "\u0171": "u", + "\u0173": "u", + "\u0174": "W", + "\u0175": "w", + "\u0176": "Y", + "\u0177": "y", + "\u0178": "Y", + "\u0179": "Z", + "\u017B": "Z", + "\u017D": "Z", + "\u017A": "z", + "\u017C": "z", + "\u017E": "z", + "\u0132": "IJ", + "\u0133": "ij", + "\u0152": "Oe", + "\u0153": "oe", + "\u0149": "'n", + "\u017F": "ss" + }; + var freeGlobal = typeof global == "object" && global && global.Object === Object && global; + var freeSelf = typeof self == "object" && self && self.Object === Object && self; + var root = freeGlobal || freeSelf || Function("return this")(); + function basePropertyOf(object) { + return function(key) { + return object == null ? void 0 : object[key]; + }; + } + var deburrLetter = basePropertyOf(deburredLetters); + var objectProto = Object.prototype; + var objectToString = objectProto.toString; + var Symbol = root.Symbol; + var symbolProto = Symbol ? Symbol.prototype : void 0; + var symbolToString = symbolProto ? symbolProto.toString : void 0; + function baseToString(value) { + if (typeof value == "string") { + return value; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ""; + } + var result = value + ""; + return result == "0" && 1 / value == -INFINITY ? "-0" : result; + } + function isObjectLike(value) { + return !!value && typeof value == "object"; + } + function isSymbol(value) { + return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag; + } + function toString(value) { + return value == null ? "" : baseToString(value); + } + function deburr(string) { + string = toString(string); + return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ""); + } + module2.exports = deburr; + } +}); + +// node_modules/@sindresorhus/transliterate/node_modules/escape-string-regexp/index.js +var require_escape_string_regexp2 = __commonJS({ + "node_modules/@sindresorhus/transliterate/node_modules/escape-string-regexp/index.js"(exports, module2) { + "use strict"; + var matchOperatorsRegex = /[|\\{}()[\]^$+*?.-]/g; + module2.exports = (string) => { + if (typeof string !== "string") { + throw new TypeError("Expected a string"); + } + return string.replace(matchOperatorsRegex, "\\$&"); + }; + } +}); + +// node_modules/@sindresorhus/transliterate/replacements.js +var require_replacements = __commonJS({ + "node_modules/@sindresorhus/transliterate/replacements.js"(exports, module2) { + "use strict"; + module2.exports = [ + ["\xDF", "ss"], + ["\xE4", "ae"], + ["\xC4", "Ae"], + ["\xF6", "oe"], + ["\xD6", "Oe"], + ["\xFC", "ue"], + ["\xDC", "Ue"], + ["\xC0", "A"], + ["\xC1", "A"], + ["\xC2", "A"], + ["\xC3", "A"], + ["\xC4", "Ae"], + ["\xC5", "A"], + ["\xC6", "AE"], + ["\xC7", "C"], + ["\xC8", "E"], + ["\xC9", "E"], + ["\xCA", "E"], + ["\xCB", "E"], + ["\xCC", "I"], + ["\xCD", "I"], + ["\xCE", "I"], + ["\xCF", "I"], + ["\xD0", "D"], + ["\xD1", "N"], + ["\xD2", "O"], + ["\xD3", "O"], + ["\xD4", "O"], + ["\xD5", "O"], + ["\xD6", "Oe"], + ["\u0150", "O"], + ["\xD8", "O"], + ["\xD9", "U"], + ["\xDA", "U"], + ["\xDB", "U"], + ["\xDC", "Ue"], + ["\u0170", "U"], + ["\xDD", "Y"], + ["\xDE", "TH"], + ["\xDF", "ss"], + ["\xE0", "a"], + ["\xE1", "a"], + ["\xE2", "a"], + ["\xE3", "a"], + ["\xE4", "ae"], + ["\xE5", "a"], + ["\xE6", "ae"], + ["\xE7", "c"], + ["\xE8", "e"], + ["\xE9", "e"], + ["\xEA", "e"], + ["\xEB", "e"], + ["\xEC", "i"], + ["\xED", "i"], + ["\xEE", "i"], + ["\xEF", "i"], + ["\xF0", "d"], + ["\xF1", "n"], + ["\xF2", "o"], + ["\xF3", "o"], + ["\xF4", "o"], + ["\xF5", "o"], + ["\xF6", "oe"], + ["\u0151", "o"], + ["\xF8", "o"], + ["\xF9", "u"], + ["\xFA", "u"], + ["\xFB", "u"], + ["\xFC", "ue"], + ["\u0171", "u"], + ["\xFD", "y"], + ["\xFE", "th"], + ["\xFF", "y"], + ["\u1E9E", "SS"], + ["\xE0", "a"], + ["\xC0", "A"], + ["\xE1", "a"], + ["\xC1", "A"], + ["\xE2", "a"], + ["\xC2", "A"], + ["\xE3", "a"], + ["\xC3", "A"], + ["\xE8", "e"], + ["\xC8", "E"], + ["\xE9", "e"], + ["\xC9", "E"], + ["\xEA", "e"], + ["\xCA", "E"], + ["\xEC", "i"], + ["\xCC", "I"], + ["\xED", "i"], + ["\xCD", "I"], + ["\xF2", "o"], + ["\xD2", "O"], + ["\xF3", "o"], + ["\xD3", "O"], + ["\xF4", "o"], + ["\xD4", "O"], + ["\xF5", "o"], + ["\xD5", "O"], + ["\xF9", "u"], + ["\xD9", "U"], + ["\xFA", "u"], + ["\xDA", "U"], + ["\xFD", "y"], + ["\xDD", "Y"], + ["\u0103", "a"], + ["\u0102", "A"], + ["\u0110", "D"], + ["\u0111", "d"], + ["\u0129", "i"], + ["\u0128", "I"], + ["\u0169", "u"], + ["\u0168", "U"], + ["\u01A1", "o"], + ["\u01A0", "O"], + ["\u01B0", "u"], + ["\u01AF", "U"], + ["\u1EA1", "a"], + ["\u1EA0", "A"], + ["\u1EA3", "a"], + ["\u1EA2", "A"], + ["\u1EA5", "a"], + ["\u1EA4", "A"], + ["\u1EA7", "a"], + ["\u1EA6", "A"], + ["\u1EA9", "a"], + ["\u1EA8", "A"], + ["\u1EAB", "a"], + ["\u1EAA", "A"], + ["\u1EAD", "a"], + ["\u1EAC", "A"], + ["\u1EAF", "a"], + ["\u1EAE", "A"], + ["\u1EB1", "a"], + ["\u1EB0", "A"], + ["\u1EB3", "a"], + ["\u1EB2", "A"], + ["\u1EB5", "a"], + ["\u1EB4", "A"], + ["\u1EB7", "a"], + ["\u1EB6", "A"], + ["\u1EB9", "e"], + ["\u1EB8", "E"], + ["\u1EBB", "e"], + ["\u1EBA", "E"], + ["\u1EBD", "e"], + ["\u1EBC", "E"], + ["\u1EBF", "e"], + ["\u1EBE", "E"], + ["\u1EC1", "e"], + ["\u1EC0", "E"], + ["\u1EC3", "e"], + ["\u1EC2", "E"], + ["\u1EC5", "e"], + ["\u1EC4", "E"], + ["\u1EC7", "e"], + ["\u1EC6", "E"], + ["\u1EC9", "i"], + ["\u1EC8", "I"], + ["\u1ECB", "i"], + ["\u1ECA", "I"], + ["\u1ECD", "o"], + ["\u1ECC", "O"], + ["\u1ECF", "o"], + ["\u1ECE", "O"], + ["\u1ED1", "o"], + ["\u1ED0", "O"], + ["\u1ED3", "o"], + ["\u1ED2", "O"], + ["\u1ED5", "o"], + ["\u1ED4", "O"], + ["\u1ED7", "o"], + ["\u1ED6", "O"], + ["\u1ED9", "o"], + ["\u1ED8", "O"], + ["\u1EDB", "o"], + ["\u1EDA", "O"], + ["\u1EDD", "o"], + ["\u1EDC", "O"], + ["\u1EDF", "o"], + ["\u1EDE", "O"], + ["\u1EE1", "o"], + ["\u1EE0", "O"], + ["\u1EE3", "o"], + ["\u1EE2", "O"], + ["\u1EE5", "u"], + ["\u1EE4", "U"], + ["\u1EE7", "u"], + ["\u1EE6", "U"], + ["\u1EE9", "u"], + ["\u1EE8", "U"], + ["\u1EEB", "u"], + ["\u1EEA", "U"], + ["\u1EED", "u"], + ["\u1EEC", "U"], + ["\u1EEF", "u"], + ["\u1EEE", "U"], + ["\u1EF1", "u"], + ["\u1EF0", "U"], + ["\u1EF3", "y"], + ["\u1EF2", "Y"], + ["\u1EF5", "y"], + ["\u1EF4", "Y"], + ["\u1EF7", "y"], + ["\u1EF6", "Y"], + ["\u1EF9", "y"], + ["\u1EF8", "Y"], + ["\u0621", "e"], + ["\u0622", "a"], + ["\u0623", "a"], + ["\u0624", "w"], + ["\u0625", "i"], + ["\u0626", "y"], + ["\u0627", "a"], + ["\u0628", "b"], + ["\u0629", "t"], + ["\u062A", "t"], + ["\u062B", "th"], + ["\u062C", "j"], + ["\u062D", "h"], + ["\u062E", "kh"], + ["\u062F", "d"], + ["\u0630", "dh"], + ["\u0631", "r"], + ["\u0632", "z"], + ["\u0633", "s"], + ["\u0634", "sh"], + ["\u0635", "s"], + ["\u0636", "d"], + ["\u0637", "t"], + ["\u0638", "z"], + ["\u0639", "e"], + ["\u063A", "gh"], + ["\u0640", "_"], + ["\u0641", "f"], + ["\u0642", "q"], + ["\u0643", "k"], + ["\u0644", "l"], + ["\u0645", "m"], + ["\u0646", "n"], + ["\u0647", "h"], + ["\u0648", "w"], + ["\u0649", "a"], + ["\u064A", "y"], + ["\u064E\u200E", "a"], + ["\u064F", "u"], + ["\u0650\u200E", "i"], + ["\u0660", "0"], + ["\u0661", "1"], + ["\u0662", "2"], + ["\u0663", "3"], + ["\u0664", "4"], + ["\u0665", "5"], + ["\u0666", "6"], + ["\u0667", "7"], + ["\u0668", "8"], + ["\u0669", "9"], + ["\u0686", "ch"], + ["\u06A9", "k"], + ["\u06AF", "g"], + ["\u067E", "p"], + ["\u0698", "zh"], + ["\u06CC", "y"], + ["\u06F0", "0"], + ["\u06F1", "1"], + ["\u06F2", "2"], + ["\u06F3", "3"], + ["\u06F4", "4"], + ["\u06F5", "5"], + ["\u06F6", "6"], + ["\u06F7", "7"], + ["\u06F8", "8"], + ["\u06F9", "9"], + ["\u067C", "p"], + ["\u0681", "z"], + ["\u0685", "c"], + ["\u0689", "d"], + ["\uFEAB", "d"], + ["\uFEAD", "r"], + ["\u0693", "r"], + ["\uFEAF", "z"], + ["\u0696", "g"], + ["\u069A", "x"], + ["\u06AB", "g"], + ["\u06BC", "n"], + ["\u06C0", "e"], + ["\u06D0", "e"], + ["\u06CD", "ai"], + ["\u0679", "t"], + ["\u0688", "d"], + ["\u0691", "r"], + ["\u06BA", "n"], + ["\u06C1", "h"], + ["\u06BE", "h"], + ["\u06D2", "e"], + ["\u0410", "A"], + ["\u0430", "a"], + ["\u0411", "B"], + ["\u0431", "b"], + ["\u0412", "V"], + ["\u0432", "v"], + ["\u0413", "G"], + ["\u0433", "g"], + ["\u0414", "D"], + ["\u0434", "d"], + ["\u0415", "E"], + ["\u0435", "e"], + ["\u0416", "Zh"], + ["\u0436", "zh"], + ["\u0417", "Z"], + ["\u0437", "z"], + ["\u0418", "I"], + ["\u0438", "i"], + ["\u0419", "J"], + ["\u0439", "j"], + ["\u041A", "K"], + ["\u043A", "k"], + ["\u041B", "L"], + ["\u043B", "l"], + ["\u041C", "M"], + ["\u043C", "m"], + ["\u041D", "N"], + ["\u043D", "n"], + ["\u041E", "O"], + ["\u043E", "o"], + ["\u041F", "P"], + ["\u043F", "p"], + ["\u0420", "R"], + ["\u0440", "r"], + ["\u0421", "S"], + ["\u0441", "s"], + ["\u0422", "T"], + ["\u0442", "t"], + ["\u0423", "U"], + ["\u0443", "u"], + ["\u0424", "F"], + ["\u0444", "f"], + ["\u0425", "H"], + ["\u0445", "h"], + ["\u0426", "Cz"], + ["\u0446", "cz"], + ["\u0427", "Ch"], + ["\u0447", "ch"], + ["\u0428", "Sh"], + ["\u0448", "sh"], + ["\u0429", "Shh"], + ["\u0449", "shh"], + ["\u042A", ""], + ["\u044A", ""], + ["\u042B", "Y"], + ["\u044B", "y"], + ["\u042C", ""], + ["\u044C", ""], + ["\u042D", "E"], + ["\u044D", "e"], + ["\u042E", "Yu"], + ["\u044E", "yu"], + ["\u042F", "Ya"], + ["\u044F", "ya"], + ["\u0401", "Yo"], + ["\u0451", "yo"], + ["\u0103", "a"], + ["\u0102", "A"], + ["\u0219", "s"], + ["\u0218", "S"], + ["\u021B", "t"], + ["\u021A", "T"], + ["\u0163", "t"], + ["\u0162", "T"], + ["\u015F", "s"], + ["\u015E", "S"], + ["\xE7", "c"], + ["\xC7", "C"], + ["\u011F", "g"], + ["\u011E", "G"], + ["\u0131", "i"], + ["\u0130", "I"], + ["\u0561", "a"], + ["\u0531", "A"], + ["\u0562", "b"], + ["\u0532", "B"], + ["\u0563", "g"], + ["\u0533", "G"], + ["\u0564", "d"], + ["\u0534", "D"], + ["\u0565", "ye"], + ["\u0535", "Ye"], + ["\u0566", "z"], + ["\u0536", "Z"], + ["\u0567", "e"], + ["\u0537", "E"], + ["\u0568", "y"], + ["\u0538", "Y"], + ["\u0569", "t"], + ["\u0539", "T"], + ["\u056A", "zh"], + ["\u053A", "Zh"], + ["\u056B", "i"], + ["\u053B", "I"], + ["\u056C", "l"], + ["\u053C", "L"], + ["\u056D", "kh"], + ["\u053D", "Kh"], + ["\u056E", "ts"], + ["\u053E", "Ts"], + ["\u056F", "k"], + ["\u053F", "K"], + ["\u0570", "h"], + ["\u0540", "H"], + ["\u0571", "dz"], + ["\u0541", "Dz"], + ["\u0572", "gh"], + ["\u0542", "Gh"], + ["\u0573", "tch"], + ["\u0543", "Tch"], + ["\u0574", "m"], + ["\u0544", "M"], + ["\u0575", "y"], + ["\u0545", "Y"], + ["\u0576", "n"], + ["\u0546", "N"], + ["\u0577", "sh"], + ["\u0547", "Sh"], + ["\u0578", "vo"], + ["\u0548", "Vo"], + ["\u0579", "ch"], + ["\u0549", "Ch"], + ["\u057A", "p"], + ["\u054A", "P"], + ["\u057B", "j"], + ["\u054B", "J"], + ["\u057C", "r"], + ["\u054C", "R"], + ["\u057D", "s"], + ["\u054D", "S"], + ["\u057E", "v"], + ["\u054E", "V"], + ["\u057F", "t"], + ["\u054F", "T"], + ["\u0580", "r"], + ["\u0550", "R"], + ["\u0581", "c"], + ["\u0551", "C"], + ["\u0578\u0582", "u"], + ["\u0548\u0552", "U"], + ["\u0548\u0582", "U"], + ["\u0583", "p"], + ["\u0553", "P"], + ["\u0584", "q"], + ["\u0554", "Q"], + ["\u0585", "o"], + ["\u0555", "O"], + ["\u0586", "f"], + ["\u0556", "F"], + ["\u0587", "yev"], + ["\u10D0", "a"], + ["\u10D1", "b"], + ["\u10D2", "g"], + ["\u10D3", "d"], + ["\u10D4", "e"], + ["\u10D5", "v"], + ["\u10D6", "z"], + ["\u10D7", "t"], + ["\u10D8", "i"], + ["\u10D9", "k"], + ["\u10DA", "l"], + ["\u10DB", "m"], + ["\u10DC", "n"], + ["\u10DD", "o"], + ["\u10DE", "p"], + ["\u10DF", "zh"], + ["\u10E0", "r"], + ["\u10E1", "s"], + ["\u10E2", "t"], + ["\u10E3", "u"], + ["\u10E4", "ph"], + ["\u10E5", "q"], + ["\u10E6", "gh"], + ["\u10E7", "k"], + ["\u10E8", "sh"], + ["\u10E9", "ch"], + ["\u10EA", "ts"], + ["\u10EB", "dz"], + ["\u10EC", "ts"], + ["\u10ED", "tch"], + ["\u10EE", "kh"], + ["\u10EF", "j"], + ["\u10F0", "h"], + ["\u010D", "c"], + ["\u010F", "d"], + ["\u011B", "e"], + ["\u0148", "n"], + ["\u0159", "r"], + ["\u0161", "s"], + ["\u0165", "t"], + ["\u016F", "u"], + ["\u017E", "z"], + ["\u010C", "C"], + ["\u010E", "D"], + ["\u011A", "E"], + ["\u0147", "N"], + ["\u0158", "R"], + ["\u0160", "S"], + ["\u0164", "T"], + ["\u016E", "U"], + ["\u017D", "Z"], + ["\u0780", "h"], + ["\u0781", "sh"], + ["\u0782", "n"], + ["\u0783", "r"], + ["\u0784", "b"], + ["\u0785", "lh"], + ["\u0786", "k"], + ["\u0787", "a"], + ["\u0788", "v"], + ["\u0789", "m"], + ["\u078A", "f"], + ["\u078B", "dh"], + ["\u078C", "th"], + ["\u078D", "l"], + ["\u078E", "g"], + ["\u078F", "gn"], + ["\u0790", "s"], + ["\u0791", "d"], + ["\u0792", "z"], + ["\u0793", "t"], + ["\u0794", "y"], + ["\u0795", "p"], + ["\u0796", "j"], + ["\u0797", "ch"], + ["\u0798", "tt"], + ["\u0799", "hh"], + ["\u079A", "kh"], + ["\u079B", "th"], + ["\u079C", "z"], + ["\u079D", "sh"], + ["\u079E", "s"], + ["\u079F", "d"], + ["\u07A0", "t"], + ["\u07A1", "z"], + ["\u07A2", "a"], + ["\u07A3", "gh"], + ["\u07A4", "q"], + ["\u07A5", "w"], + ["\u07A6", "a"], + ["\u07A7", "aa"], + ["\u07A8", "i"], + ["\u07A9", "ee"], + ["\u07AA", "u"], + ["\u07AB", "oo"], + ["\u07AC", "e"], + ["\u07AD", "ey"], + ["\u07AE", "o"], + ["\u07AF", "oa"], + ["\u07B0", ""], + ["\u03B1", "a"], + ["\u03B2", "v"], + ["\u03B3", "g"], + ["\u03B4", "d"], + ["\u03B5", "e"], + ["\u03B6", "z"], + ["\u03B7", "i"], + ["\u03B8", "th"], + ["\u03B9", "i"], + ["\u03BA", "k"], + ["\u03BB", "l"], + ["\u03BC", "m"], + ["\u03BD", "n"], + ["\u03BE", "ks"], + ["\u03BF", "o"], + ["\u03C0", "p"], + ["\u03C1", "r"], + ["\u03C3", "s"], + ["\u03C4", "t"], + ["\u03C5", "y"], + ["\u03C6", "f"], + ["\u03C7", "x"], + ["\u03C8", "ps"], + ["\u03C9", "o"], + ["\u03AC", "a"], + ["\u03AD", "e"], + ["\u03AF", "i"], + ["\u03CC", "o"], + ["\u03CD", "y"], + ["\u03AE", "i"], + ["\u03CE", "o"], + ["\u03C2", "s"], + ["\u03CA", "i"], + ["\u03B0", "y"], + ["\u03CB", "y"], + ["\u0390", "i"], + ["\u0391", "A"], + ["\u0392", "B"], + ["\u0393", "G"], + ["\u0394", "D"], + ["\u0395", "E"], + ["\u0396", "Z"], + ["\u0397", "I"], + ["\u0398", "TH"], + ["\u0399", "I"], + ["\u039A", "K"], + ["\u039B", "L"], + ["\u039C", "M"], + ["\u039D", "N"], + ["\u039E", "KS"], + ["\u039F", "O"], + ["\u03A0", "P"], + ["\u03A1", "R"], + ["\u03A3", "S"], + ["\u03A4", "T"], + ["\u03A5", "Y"], + ["\u03A6", "F"], + ["\u03A7", "X"], + ["\u03A8", "PS"], + ["\u03A9", "O"], + ["\u0386", "A"], + ["\u0388", "E"], + ["\u038A", "I"], + ["\u038C", "O"], + ["\u038E", "Y"], + ["\u0389", "I"], + ["\u038F", "O"], + ["\u03AA", "I"], + ["\u03AB", "Y"], + ["\u0101", "a"], + ["\u0113", "e"], + ["\u0123", "g"], + ["\u012B", "i"], + ["\u0137", "k"], + ["\u013C", "l"], + ["\u0146", "n"], + ["\u016B", "u"], + ["\u0100", "A"], + ["\u0112", "E"], + ["\u0122", "G"], + ["\u012A", "I"], + ["\u0136", "K"], + ["\u013B", "L"], + ["\u0145", "N"], + ["\u016A", "U"], + ["\u010D", "c"], + ["\u0161", "s"], + ["\u017E", "z"], + ["\u010C", "C"], + ["\u0160", "S"], + ["\u017D", "Z"], + ["\u0105", "a"], + ["\u010D", "c"], + ["\u0119", "e"], + ["\u0117", "e"], + ["\u012F", "i"], + ["\u0161", "s"], + ["\u0173", "u"], + ["\u016B", "u"], + ["\u017E", "z"], + ["\u0104", "A"], + ["\u010C", "C"], + ["\u0118", "E"], + ["\u0116", "E"], + ["\u012E", "I"], + ["\u0160", "S"], + ["\u0172", "U"], + ["\u016A", "U"], + ["\u040C", "Kj"], + ["\u045C", "kj"], + ["\u0409", "Lj"], + ["\u0459", "lj"], + ["\u040A", "Nj"], + ["\u045A", "nj"], + ["\u0422\u0441", "Ts"], + ["\u0442\u0441", "ts"], + ["\u0105", "a"], + ["\u0107", "c"], + ["\u0119", "e"], + ["\u0142", "l"], + ["\u0144", "n"], + ["\u015B", "s"], + ["\u017A", "z"], + ["\u017C", "z"], + ["\u0104", "A"], + ["\u0106", "C"], + ["\u0118", "E"], + ["\u0141", "L"], + ["\u0143", "N"], + ["\u015A", "S"], + ["\u0179", "Z"], + ["\u017B", "Z"], + ["\u0404", "Ye"], + ["\u0406", "I"], + ["\u0407", "Yi"], + ["\u0490", "G"], + ["\u0454", "ye"], + ["\u0456", "i"], + ["\u0457", "yi"], + ["\u0491", "g"] + ]; + } +}); + +// node_modules/@sindresorhus/transliterate/index.js +var require_transliterate = __commonJS({ + "node_modules/@sindresorhus/transliterate/index.js"(exports, module2) { + "use strict"; + var deburr = require_lodash(); + var escapeStringRegexp = require_escape_string_regexp2(); + var builtinReplacements = require_replacements(); + var doCustomReplacements = (string, replacements) => { + for (const [key, value] of replacements) { + string = string.replace(new RegExp(escapeStringRegexp(key), "g"), value); + } + return string; + }; + module2.exports = (string, options) => { + if (typeof string !== "string") { + throw new TypeError(`Expected a string, got \`${typeof string}\``); + } + options = __spreadValues({ + customReplacements: [] + }, options); + const customReplacements = new Map([ + ...builtinReplacements, + ...options.customReplacements + ]); + string = string.normalize(); + string = doCustomReplacements(string, customReplacements); + string = deburr(string); + return string; + }; + } +}); + +// node_modules/@sindresorhus/slugify/overridable-replacements.js +var require_overridable_replacements = __commonJS({ + "node_modules/@sindresorhus/slugify/overridable-replacements.js"(exports, module2) { + "use strict"; + module2.exports = [ + ["&", " and "], + ["\u{1F984}", " unicorn "], + ["\u2665", " love "] + ]; + } +}); + +// node_modules/@sindresorhus/slugify/index.js +var require_slugify = __commonJS({ + "node_modules/@sindresorhus/slugify/index.js"(exports, module2) { + "use strict"; + var escapeStringRegexp = require_escape_string_regexp(); + var transliterate = require_transliterate(); + var builtinOverridableReplacements = require_overridable_replacements(); + var decamelize = (string) => { + return string.replace(/([A-Z]{2,})(\d+)/g, "$1 $2").replace(/([a-z\d]+)([A-Z]{2,})/g, "$1 $2").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1 $2"); + }; + var removeMootSeparators = (string, separator) => { + const escapedSeparator = escapeStringRegexp(separator); + return string.replace(new RegExp(`${escapedSeparator}{2,}`, "g"), separator).replace(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, "g"), ""); + }; + var slugify3 = (string, options) => { + if (typeof string !== "string") { + throw new TypeError(`Expected a string, got \`${typeof string}\``); + } + options = __spreadValues({ + separator: "-", + lowercase: true, + decamelize: true, + customReplacements: [], + preserveLeadingUnderscore: false + }, options); + const shouldPrependUnderscore = options.preserveLeadingUnderscore && string.startsWith("_"); + const customReplacements = new Map([ + ...builtinOverridableReplacements, + ...options.customReplacements + ]); + string = transliterate(string, { customReplacements }); + if (options.decamelize) { + string = decamelize(string); + } + let patternSlug = /[^a-zA-Z\d]+/g; + if (options.lowercase) { + string = string.toLowerCase(); + patternSlug = /[^a-z\d]+/g; + } + string = string.replace(patternSlug, options.separator); + string = string.replace(/\\/g, ""); + if (options.separator) { + string = removeMootSeparators(string, options.separator); + } + if (shouldPrependUnderscore) { + string = `_${string}`; + } + return string; + }; + var counter = () => { + const occurrences = new Map(); + const countable = (string, options) => { + string = slugify3(string, options); + if (!string) { + return ""; + } + const stringLower = string.toLowerCase(); + const numberless = occurrences.get(stringLower.replace(/(?:-\d+?)+?$/, "")) || 0; + const counter2 = occurrences.get(stringLower); + occurrences.set(stringLower, typeof counter2 === "number" ? counter2 + 1 : 1); + const newCounter = occurrences.get(stringLower) || 2; + if (newCounter >= 2 || numberless > 2) { + string = `${string}-${newCounter}`; + } + return string; + }; + countable.reset = () => { + occurrences.clear(); + }; + return countable; + }; + module2.exports = slugify3; + module2.exports.counter = counter; + } +}); + +// node_modules/crypto-js/core.js +var require_core = __commonJS({ + "node_modules/crypto-js/core.js"(exports, module2) { + (function(root, factory) { + if (typeof exports === "object") { + module2.exports = exports = factory(); + } else if (typeof define === "function" && define.amd) { + define([], factory); + } else { + root.CryptoJS = factory(); + } + })(exports, function() { + var CryptoJS = CryptoJS || function(Math2, undefined2) { + var crypto2; + if (typeof window !== "undefined" && window.crypto) { + crypto2 = window.crypto; + } + if (typeof self !== "undefined" && self.crypto) { + crypto2 = self.crypto; + } + if (typeof globalThis !== "undefined" && globalThis.crypto) { + crypto2 = globalThis.crypto; + } + if (!crypto2 && typeof window !== "undefined" && window.msCrypto) { + crypto2 = window.msCrypto; + } + if (!crypto2 && typeof global !== "undefined" && global.crypto) { + crypto2 = global.crypto; + } + if (!crypto2 && typeof require === "function") { + try { + crypto2 = require("crypto"); + } catch (err) { + } + } + var cryptoSecureRandomInt = function() { + if (crypto2) { + if (typeof crypto2.getRandomValues === "function") { + try { + return crypto2.getRandomValues(new Uint32Array(1))[0]; + } catch (err) { + } + } + if (typeof crypto2.randomBytes === "function") { + try { + return crypto2.randomBytes(4).readInt32LE(); + } catch (err) { + } + } + } + throw new Error("Native crypto module could not be used to get secure random number."); + }; + var create = Object.create || function() { + function F() { + } + return function(obj) { + var subtype; + F.prototype = obj; + subtype = new F(); + F.prototype = null; + return subtype; + }; + }(); + var C = {}; + var C_lib = C.lib = {}; + var Base = C_lib.Base = function() { + return { + extend: function(overrides) { + var subtype = create(this); + if (overrides) { + subtype.mixIn(overrides); + } + if (!subtype.hasOwnProperty("init") || this.init === subtype.init) { + subtype.init = function() { + subtype.$super.init.apply(this, arguments); + }; + } + subtype.init.prototype = subtype; + subtype.$super = this; + return subtype; + }, + create: function() { + var instance = this.extend(); + instance.init.apply(instance, arguments); + return instance; + }, + init: function() { + }, + mixIn: function(properties) { + for (var propertyName in properties) { + if (properties.hasOwnProperty(propertyName)) { + this[propertyName] = properties[propertyName]; + } + } + if (properties.hasOwnProperty("toString")) { + this.toString = properties.toString; + } + }, + clone: function() { + return this.init.prototype.extend(this); + } + }; + }(); + var WordArray = C_lib.WordArray = Base.extend({ + init: function(words, sigBytes) { + words = this.words = words || []; + if (sigBytes != undefined2) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 4; + } + }, + toString: function(encoder) { + return (encoder || Hex).stringify(this); + }, + concat: function(wordArray) { + var thisWords = this.words; + var thatWords = wordArray.words; + var thisSigBytes = this.sigBytes; + var thatSigBytes = wordArray.sigBytes; + this.clamp(); + if (thisSigBytes % 4) { + for (var i = 0; i < thatSigBytes; i++) { + var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 255; + thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8; + } + } else { + for (var j = 0; j < thatSigBytes; j += 4) { + thisWords[thisSigBytes + j >>> 2] = thatWords[j >>> 2]; + } + } + this.sigBytes += thatSigBytes; + return this; + }, + clamp: function() { + var words = this.words; + var sigBytes = this.sigBytes; + words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8; + words.length = Math2.ceil(sigBytes / 4); + }, + clone: function() { + var clone3 = Base.clone.call(this); + clone3.words = this.words.slice(0); + return clone3; + }, + random: function(nBytes) { + var words = []; + for (var i = 0; i < nBytes; i += 4) { + words.push(cryptoSecureRandomInt()); + } + return new WordArray.init(words, nBytes); + } + }); + var C_enc = C.enc = {}; + var Hex = C_enc.Hex = { + stringify: function(wordArray) { + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var hexChars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255; + hexChars.push((bite >>> 4).toString(16)); + hexChars.push((bite & 15).toString(16)); + } + return hexChars.join(""); + }, + parse: function(hexStr) { + var hexStrLength = hexStr.length; + var words = []; + for (var i = 0; i < hexStrLength; i += 2) { + words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4; + } + return new WordArray.init(words, hexStrLength / 2); + } + }; + var Latin1 = C_enc.Latin1 = { + stringify: function(wordArray) { + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var latin1Chars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255; + latin1Chars.push(String.fromCharCode(bite)); + } + return latin1Chars.join(""); + }, + parse: function(latin1Str) { + var latin1StrLength = latin1Str.length; + var words = []; + for (var i = 0; i < latin1StrLength; i++) { + words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8; + } + return new WordArray.init(words, latin1StrLength); + } + }; + var Utf8 = C_enc.Utf8 = { + stringify: function(wordArray) { + try { + return decodeURIComponent(escape(Latin1.stringify(wordArray))); + } catch (e) { + throw new Error("Malformed UTF-8 data"); + } + }, + parse: function(utf8Str) { + return Latin1.parse(unescape(encodeURIComponent(utf8Str))); + } + }; + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({ + reset: function() { + this._data = new WordArray.init(); + this._nDataBytes = 0; + }, + _append: function(data) { + if (typeof data == "string") { + data = Utf8.parse(data); + } + this._data.concat(data); + this._nDataBytes += data.sigBytes; + }, + _process: function(doFlush) { + var processedWords; + var data = this._data; + var dataWords = data.words; + var dataSigBytes = data.sigBytes; + var blockSize = this.blockSize; + var blockSizeBytes = blockSize * 4; + var nBlocksReady = dataSigBytes / blockSizeBytes; + if (doFlush) { + nBlocksReady = Math2.ceil(nBlocksReady); + } else { + nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0); + } + var nWordsReady = nBlocksReady * blockSize; + var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes); + if (nWordsReady) { + for (var offset3 = 0; offset3 < nWordsReady; offset3 += blockSize) { + this._doProcessBlock(dataWords, offset3); + } + processedWords = dataWords.splice(0, nWordsReady); + data.sigBytes -= nBytesReady; + } + return new WordArray.init(processedWords, nBytesReady); + }, + clone: function() { + var clone3 = Base.clone.call(this); + clone3._data = this._data.clone(); + return clone3; + }, + _minBufferSize: 0 + }); + var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({ + cfg: Base.extend(), + init: function(cfg) { + this.cfg = this.cfg.extend(cfg); + this.reset(); + }, + reset: function() { + BufferedBlockAlgorithm.reset.call(this); + this._doReset(); + }, + update: function(messageUpdate) { + this._append(messageUpdate); + this._process(); + return this; + }, + finalize: function(messageUpdate) { + if (messageUpdate) { + this._append(messageUpdate); + } + var hash3 = this._doFinalize(); + return hash3; + }, + blockSize: 512 / 32, + _createHelper: function(hasher) { + return function(message, cfg) { + return new hasher.init(cfg).finalize(message); + }; + }, + _createHmacHelper: function(hasher) { + return function(message, key) { + return new C_algo.HMAC.init(hasher, key).finalize(message); + }; + } + }); + var C_algo = C.algo = {}; + return C; + }(Math); + return CryptoJS; + }); + } +}); + +// node_modules/crypto-js/sha1.js +var require_sha1 = __commonJS({ + "node_modules/crypto-js/sha1.js"(exports, module2) { + (function(root, factory) { + if (typeof exports === "object") { + module2.exports = exports = factory(require_core()); + } else if (typeof define === "function" && define.amd) { + define(["./core"], factory); + } else { + factory(root.CryptoJS); + } + })(exports, function(CryptoJS) { + (function() { + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var Hasher = C_lib.Hasher; + var C_algo = C.algo; + var W = []; + var SHA1 = C_algo.SHA1 = Hasher.extend({ + _doReset: function() { + this._hash = new WordArray.init([ + 1732584193, + 4023233417, + 2562383102, + 271733878, + 3285377520 + ]); + }, + _doProcessBlock: function(M, offset3) { + var H = this._hash.words; + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + for (var i = 0; i < 80; i++) { + if (i < 16) { + W[i] = M[offset3 + i] | 0; + } else { + var n2 = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; + W[i] = n2 << 1 | n2 >>> 31; + } + var t = (a << 5 | a >>> 27) + e + W[i]; + if (i < 20) { + t += (b & c | ~b & d) + 1518500249; + } else if (i < 40) { + t += (b ^ c ^ d) + 1859775393; + } else if (i < 60) { + t += (b & c | b & d | c & d) - 1894007588; + } else { + t += (b ^ c ^ d) - 899497514; + } + e = d; + d = c; + c = b << 30 | b >>> 2; + b = a; + a = t; + } + H[0] = H[0] + a | 0; + H[1] = H[1] + b | 0; + H[2] = H[2] + c | 0; + H[3] = H[3] + d | 0; + H[4] = H[4] + e | 0; + }, + _doFinalize: function() { + var data = this._data; + var dataWords = data.words; + var nBitsTotal = this._nDataBytes * 8; + var nBitsLeft = data.sigBytes * 8; + dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32; + dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296); + dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal; + data.sigBytes = dataWords.length * 4; + this._process(); + return this._hash; + }, + clone: function() { + var clone3 = Hasher.clone.call(this); + clone3._hash = this._hash.clone(); + return clone3; + } + }); + C.SHA1 = Hasher._createHelper(SHA1); + C.HmacSHA1 = Hasher._createHmacHelper(SHA1); + })(); + return CryptoJS.SHA1; + }); + } +}); + +// node_modules/obsidian-dataview/lib/index.js +var require_lib = __commonJS({ + "node_modules/obsidian-dataview/lib/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + require("obsidian"); + var LuxonError2 = class extends Error { + }; + var InvalidDateTimeError2 = class extends LuxonError2 { + constructor(reason) { + super(`Invalid DateTime: ${reason.toMessage()}`); + } + }; + var InvalidIntervalError2 = class extends LuxonError2 { + constructor(reason) { + super(`Invalid Interval: ${reason.toMessage()}`); + } + }; + var InvalidDurationError2 = class extends LuxonError2 { + constructor(reason) { + super(`Invalid Duration: ${reason.toMessage()}`); + } + }; + var ConflictingSpecificationError2 = class extends LuxonError2 { + }; + var InvalidUnitError2 = class extends LuxonError2 { + constructor(unit) { + super(`Invalid unit ${unit}`); + } + }; + var InvalidArgumentError2 = class extends LuxonError2 { + }; + var ZoneIsAbstractError2 = class extends LuxonError2 { + constructor() { + super("Zone is an abstract class"); + } + }; + var n2 = "numeric"; + var s2 = "short"; + var l2 = "long"; + var DATE_SHORT2 = { + year: n2, + month: n2, + day: n2 + }; + var DATE_MED2 = { + year: n2, + month: s2, + day: n2 + }; + var DATE_MED_WITH_WEEKDAY2 = { + year: n2, + month: s2, + day: n2, + weekday: s2 + }; + var DATE_FULL2 = { + year: n2, + month: l2, + day: n2 + }; + var DATE_HUGE2 = { + year: n2, + month: l2, + day: n2, + weekday: l2 + }; + var TIME_SIMPLE2 = { + hour: n2, + minute: n2 + }; + var TIME_WITH_SECONDS2 = { + hour: n2, + minute: n2, + second: n2 + }; + var TIME_WITH_SHORT_OFFSET2 = { + hour: n2, + minute: n2, + second: n2, + timeZoneName: s2 + }; + var TIME_WITH_LONG_OFFSET2 = { + hour: n2, + minute: n2, + second: n2, + timeZoneName: l2 + }; + var TIME_24_SIMPLE2 = { + hour: n2, + minute: n2, + hourCycle: "h23" + }; + var TIME_24_WITH_SECONDS2 = { + hour: n2, + minute: n2, + second: n2, + hourCycle: "h23" + }; + var TIME_24_WITH_SHORT_OFFSET2 = { + hour: n2, + minute: n2, + second: n2, + hourCycle: "h23", + timeZoneName: s2 + }; + var TIME_24_WITH_LONG_OFFSET2 = { + hour: n2, + minute: n2, + second: n2, + hourCycle: "h23", + timeZoneName: l2 + }; + var DATETIME_SHORT2 = { + year: n2, + month: n2, + day: n2, + hour: n2, + minute: n2 + }; + var DATETIME_SHORT_WITH_SECONDS2 = { + year: n2, + month: n2, + day: n2, + hour: n2, + minute: n2, + second: n2 + }; + var DATETIME_MED2 = { + year: n2, + month: s2, + day: n2, + hour: n2, + minute: n2 + }; + var DATETIME_MED_WITH_SECONDS2 = { + year: n2, + month: s2, + day: n2, + hour: n2, + minute: n2, + second: n2 + }; + var DATETIME_MED_WITH_WEEKDAY2 = { + year: n2, + month: s2, + day: n2, + weekday: s2, + hour: n2, + minute: n2 + }; + var DATETIME_FULL2 = { + year: n2, + month: l2, + day: n2, + hour: n2, + minute: n2, + timeZoneName: s2 + }; + var DATETIME_FULL_WITH_SECONDS2 = { + year: n2, + month: l2, + day: n2, + hour: n2, + minute: n2, + second: n2, + timeZoneName: s2 + }; + var DATETIME_HUGE2 = { + year: n2, + month: l2, + day: n2, + weekday: l2, + hour: n2, + minute: n2, + timeZoneName: l2 + }; + var DATETIME_HUGE_WITH_SECONDS2 = { + year: n2, + month: l2, + day: n2, + weekday: l2, + hour: n2, + minute: n2, + second: n2, + timeZoneName: l2 + }; + var Zone2 = class { + get type() { + throw new ZoneIsAbstractError2(); + } + get name() { + throw new ZoneIsAbstractError2(); + } + get ianaName() { + return this.name; + } + get isUniversal() { + throw new ZoneIsAbstractError2(); + } + offsetName(ts, opts) { + throw new ZoneIsAbstractError2(); + } + formatOffset(ts, format2) { + throw new ZoneIsAbstractError2(); + } + offset(ts) { + throw new ZoneIsAbstractError2(); + } + equals(otherZone) { + throw new ZoneIsAbstractError2(); + } + get isValid() { + throw new ZoneIsAbstractError2(); + } + }; + var singleton$1 = null; + var SystemZone2 = class extends Zone2 { + static get instance() { + if (singleton$1 === null) { + singleton$1 = new SystemZone2(); + } + return singleton$1; + } + get type() { + return "system"; + } + get name() { + return new Intl.DateTimeFormat().resolvedOptions().timeZone; + } + get isUniversal() { + return false; + } + offsetName(ts, { format: format2, locale }) { + return parseZoneInfo2(ts, format2, locale); + } + formatOffset(ts, format2) { + return formatOffset2(this.offset(ts), format2); + } + offset(ts) { + return -new Date(ts).getTimezoneOffset(); + } + equals(otherZone) { + return otherZone.type === "system"; + } + get isValid() { + return true; + } + }; + var dtfCache2 = {}; + function makeDTF2(zone) { + if (!dtfCache2[zone]) { + dtfCache2[zone] = new Intl.DateTimeFormat("en-US", { + hour12: false, + timeZone: zone, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + era: "short" + }); + } + return dtfCache2[zone]; + } + var typeToPos2 = { + year: 0, + month: 1, + day: 2, + era: 3, + hour: 4, + minute: 5, + second: 6 + }; + function hackyOffset2(dtf, date) { + const formatted = dtf.format(date).replace(/\u200E/g, ""), parsed = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(formatted), [, fMonth, fDay, fYear, fadOrBc, fHour, fMinute, fSecond] = parsed; + return [fYear, fMonth, fDay, fadOrBc, fHour, fMinute, fSecond]; + } + function partsOffset2(dtf, date) { + const formatted = dtf.formatToParts(date); + const filled = []; + for (let i = 0; i < formatted.length; i++) { + const { type, value } = formatted[i]; + const pos = typeToPos2[type]; + if (type === "era") { + filled[pos] = value; + } else if (!isUndefined2(pos)) { + filled[pos] = parseInt(value, 10); + } + } + return filled; + } + var ianaZoneCache2 = {}; + var IANAZone2 = class extends Zone2 { + static create(name) { + if (!ianaZoneCache2[name]) { + ianaZoneCache2[name] = new IANAZone2(name); + } + return ianaZoneCache2[name]; + } + static resetCache() { + ianaZoneCache2 = {}; + dtfCache2 = {}; + } + static isValidSpecifier(s3) { + return this.isValidZone(s3); + } + static isValidZone(zone) { + if (!zone) { + return false; + } + try { + new Intl.DateTimeFormat("en-US", { timeZone: zone }).format(); + return true; + } catch (e) { + return false; + } + } + constructor(name) { + super(); + this.zoneName = name; + this.valid = IANAZone2.isValidZone(name); + } + get type() { + return "iana"; + } + get name() { + return this.zoneName; + } + get isUniversal() { + return false; + } + offsetName(ts, { format: format2, locale }) { + return parseZoneInfo2(ts, format2, locale, this.name); + } + formatOffset(ts, format2) { + return formatOffset2(this.offset(ts), format2); + } + offset(ts) { + const date = new Date(ts); + if (isNaN(date)) + return NaN; + const dtf = makeDTF2(this.name); + let [year, month, day, adOrBc, hour, minute, second] = dtf.formatToParts ? partsOffset2(dtf, date) : hackyOffset2(dtf, date); + if (adOrBc === "BC") { + year = -Math.abs(year) + 1; + } + const adjustedHour = hour === 24 ? 0 : hour; + const asUTC = objToLocalTS2({ + year, + month, + day, + hour: adjustedHour, + minute, + second, + millisecond: 0 + }); + let asTS = +date; + const over = asTS % 1e3; + asTS -= over >= 0 ? over : 1e3 + over; + return (asUTC - asTS) / (60 * 1e3); + } + equals(otherZone) { + return otherZone.type === "iana" && otherZone.name === this.name; + } + get isValid() { + return this.valid; + } + }; + var intlLFCache2 = {}; + function getCachedLF2(locString, opts = {}) { + const key = JSON.stringify([locString, opts]); + let dtf = intlLFCache2[key]; + if (!dtf) { + dtf = new Intl.ListFormat(locString, opts); + intlLFCache2[key] = dtf; + } + return dtf; + } + var intlDTCache2 = {}; + function getCachedDTF2(locString, opts = {}) { + const key = JSON.stringify([locString, opts]); + let dtf = intlDTCache2[key]; + if (!dtf) { + dtf = new Intl.DateTimeFormat(locString, opts); + intlDTCache2[key] = dtf; + } + return dtf; + } + var intlNumCache2 = {}; + function getCachedINF2(locString, opts = {}) { + const key = JSON.stringify([locString, opts]); + let inf = intlNumCache2[key]; + if (!inf) { + inf = new Intl.NumberFormat(locString, opts); + intlNumCache2[key] = inf; + } + return inf; + } + var intlRelCache2 = {}; + function getCachedRTF2(locString, opts = {}) { + const _a = opts, { base } = _a, cacheKeyOpts = __objRest(_a, ["base"]); + const key = JSON.stringify([locString, cacheKeyOpts]); + let inf = intlRelCache2[key]; + if (!inf) { + inf = new Intl.RelativeTimeFormat(locString, opts); + intlRelCache2[key] = inf; + } + return inf; + } + var sysLocaleCache2 = null; + function systemLocale2() { + if (sysLocaleCache2) { + return sysLocaleCache2; + } else { + sysLocaleCache2 = new Intl.DateTimeFormat().resolvedOptions().locale; + return sysLocaleCache2; + } + } + function parseLocaleString2(localeStr) { + const xIndex = localeStr.indexOf("-x-"); + if (xIndex !== -1) { + localeStr = localeStr.substring(0, xIndex); + } + const uIndex = localeStr.indexOf("-u-"); + if (uIndex === -1) { + return [localeStr]; + } else { + let options; + let selectedStr; + try { + options = getCachedDTF2(localeStr).resolvedOptions(); + selectedStr = localeStr; + } catch (e) { + const smaller = localeStr.substring(0, uIndex); + options = getCachedDTF2(smaller).resolvedOptions(); + selectedStr = smaller; + } + const { numberingSystem, calendar } = options; + return [selectedStr, numberingSystem, calendar]; + } + } + function intlConfigString2(localeStr, numberingSystem, outputCalendar) { + if (outputCalendar || numberingSystem) { + if (!localeStr.includes("-u-")) { + localeStr += "-u"; + } + if (outputCalendar) { + localeStr += `-ca-${outputCalendar}`; + } + if (numberingSystem) { + localeStr += `-nu-${numberingSystem}`; + } + return localeStr; + } else { + return localeStr; + } + } + function mapMonths2(f) { + const ms = []; + for (let i = 1; i <= 12; i++) { + const dt = DateTime2.utc(2016, i, 1); + ms.push(f(dt)); + } + return ms; + } + function mapWeekdays2(f) { + const ms = []; + for (let i = 1; i <= 7; i++) { + const dt = DateTime2.utc(2016, 11, 13 + i); + ms.push(f(dt)); + } + return ms; + } + function listStuff2(loc, length, defaultOK, englishFn, intlFn) { + const mode = loc.listingMode(defaultOK); + if (mode === "error") { + return null; + } else if (mode === "en") { + return englishFn(length); + } else { + return intlFn(length); + } + } + function supportsFastNumbers2(loc) { + if (loc.numberingSystem && loc.numberingSystem !== "latn") { + return false; + } else { + return loc.numberingSystem === "latn" || !loc.locale || loc.locale.startsWith("en") || new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn"; + } + } + var PolyNumberFormatter2 = class { + constructor(intl, forceSimple, opts) { + this.padTo = opts.padTo || 0; + this.floor = opts.floor || false; + const _a = opts, { padTo, floor } = _a, otherOpts = __objRest(_a, ["padTo", "floor"]); + if (!forceSimple || Object.keys(otherOpts).length > 0) { + const intlOpts = __spreadValues({ useGrouping: false }, opts); + if (opts.padTo > 0) + intlOpts.minimumIntegerDigits = opts.padTo; + this.inf = getCachedINF2(intl, intlOpts); + } + } + format(i) { + if (this.inf) { + const fixed = this.floor ? Math.floor(i) : i; + return this.inf.format(fixed); + } else { + const fixed = this.floor ? Math.floor(i) : roundTo2(i, 3); + return padStart2(fixed, this.padTo); + } + } + }; + var PolyDateFormatter2 = class { + constructor(dt, intl, opts) { + this.opts = opts; + let z = void 0; + if (dt.zone.isUniversal) { + const gmtOffset = -1 * (dt.offset / 60); + const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`; + if (dt.offset !== 0 && IANAZone2.create(offsetZ).valid) { + z = offsetZ; + this.dt = dt; + } else { + z = "UTC"; + if (opts.timeZoneName) { + this.dt = dt; + } else { + this.dt = dt.offset === 0 ? dt : DateTime2.fromMillis(dt.ts + dt.offset * 60 * 1e3); + } + } + } else if (dt.zone.type === "system") { + this.dt = dt; + } else { + this.dt = dt; + z = dt.zone.name; + } + const intlOpts = __spreadValues({}, this.opts); + intlOpts.timeZone = intlOpts.timeZone || z; + this.dtf = getCachedDTF2(intl, intlOpts); + } + format() { + return this.dtf.format(this.dt.toJSDate()); + } + formatToParts() { + return this.dtf.formatToParts(this.dt.toJSDate()); + } + resolvedOptions() { + return this.dtf.resolvedOptions(); + } + }; + var PolyRelFormatter2 = class { + constructor(intl, isEnglish, opts) { + this.opts = __spreadValues({ style: "long" }, opts); + if (!isEnglish && hasRelative2()) { + this.rtf = getCachedRTF2(intl, opts); + } + } + format(count, unit) { + if (this.rtf) { + return this.rtf.format(count, unit); + } else { + return formatRelativeTime2(unit, count, this.opts.numeric, this.opts.style !== "long"); + } + } + formatToParts(count, unit) { + if (this.rtf) { + return this.rtf.formatToParts(count, unit); + } else { + return []; + } + } + }; + var Locale2 = class { + static fromOpts(opts) { + return Locale2.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN); + } + static create(locale, numberingSystem, outputCalendar, defaultToEN = false) { + const specifiedLocale = locale || Settings2.defaultLocale; + const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale2()); + const numberingSystemR = numberingSystem || Settings2.defaultNumberingSystem; + const outputCalendarR = outputCalendar || Settings2.defaultOutputCalendar; + return new Locale2(localeR, numberingSystemR, outputCalendarR, specifiedLocale); + } + static resetCache() { + sysLocaleCache2 = null; + intlDTCache2 = {}; + intlNumCache2 = {}; + intlRelCache2 = {}; + } + static fromObject({ locale, numberingSystem, outputCalendar } = {}) { + return Locale2.create(locale, numberingSystem, outputCalendar); + } + constructor(locale, numbering, outputCalendar, specifiedLocale) { + const [parsedLocale, parsedNumberingSystem, parsedOutputCalendar] = parseLocaleString2(locale); + this.locale = parsedLocale; + this.numberingSystem = numbering || parsedNumberingSystem || null; + this.outputCalendar = outputCalendar || parsedOutputCalendar || null; + this.intl = intlConfigString2(this.locale, this.numberingSystem, this.outputCalendar); + this.weekdaysCache = { format: {}, standalone: {} }; + this.monthsCache = { format: {}, standalone: {} }; + this.meridiemCache = null; + this.eraCache = {}; + this.specifiedLocale = specifiedLocale; + this.fastNumbersCached = null; + } + get fastNumbers() { + if (this.fastNumbersCached == null) { + this.fastNumbersCached = supportsFastNumbers2(this); + } + return this.fastNumbersCached; + } + listingMode() { + const isActuallyEn = this.isEnglish(); + const hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory"); + return isActuallyEn && hasNoWeirdness ? "en" : "intl"; + } + clone(alts) { + if (!alts || Object.getOwnPropertyNames(alts).length === 0) { + return this; + } else { + return Locale2.create(alts.locale || this.specifiedLocale, alts.numberingSystem || this.numberingSystem, alts.outputCalendar || this.outputCalendar, alts.defaultToEN || false); + } + } + redefaultToEN(alts = {}) { + return this.clone(__spreadProps(__spreadValues({}, alts), { defaultToEN: true })); + } + redefaultToSystem(alts = {}) { + return this.clone(__spreadProps(__spreadValues({}, alts), { defaultToEN: false })); + } + months(length, format2 = false, defaultOK = true) { + return listStuff2(this, length, defaultOK, months2, () => { + const intl = format2 ? { month: length, day: "numeric" } : { month: length }, formatStr = format2 ? "format" : "standalone"; + if (!this.monthsCache[formatStr][length]) { + this.monthsCache[formatStr][length] = mapMonths2((dt) => this.extract(dt, intl, "month")); + } + return this.monthsCache[formatStr][length]; + }); + } + weekdays(length, format2 = false, defaultOK = true) { + return listStuff2(this, length, defaultOK, weekdays2, () => { + const intl = format2 ? { weekday: length, year: "numeric", month: "long", day: "numeric" } : { weekday: length }, formatStr = format2 ? "format" : "standalone"; + if (!this.weekdaysCache[formatStr][length]) { + this.weekdaysCache[formatStr][length] = mapWeekdays2((dt) => this.extract(dt, intl, "weekday")); + } + return this.weekdaysCache[formatStr][length]; + }); + } + meridiems(defaultOK = true) { + return listStuff2(this, void 0, defaultOK, () => meridiems2, () => { + if (!this.meridiemCache) { + const intl = { hour: "numeric", hourCycle: "h12" }; + this.meridiemCache = [DateTime2.utc(2016, 11, 13, 9), DateTime2.utc(2016, 11, 13, 19)].map((dt) => this.extract(dt, intl, "dayperiod")); + } + return this.meridiemCache; + }); + } + eras(length, defaultOK = true) { + return listStuff2(this, length, defaultOK, eras2, () => { + const intl = { era: length }; + if (!this.eraCache[length]) { + this.eraCache[length] = [DateTime2.utc(-40, 1, 1), DateTime2.utc(2017, 1, 1)].map((dt) => this.extract(dt, intl, "era")); + } + return this.eraCache[length]; + }); + } + extract(dt, intlOpts, field) { + const df = this.dtFormatter(dt, intlOpts), results = df.formatToParts(), matching = results.find((m) => m.type.toLowerCase() === field); + return matching ? matching.value : null; + } + numberFormatter(opts = {}) { + return new PolyNumberFormatter2(this.intl, opts.forceSimple || this.fastNumbers, opts); + } + dtFormatter(dt, intlOpts = {}) { + return new PolyDateFormatter2(dt, this.intl, intlOpts); + } + relFormatter(opts = {}) { + return new PolyRelFormatter2(this.intl, this.isEnglish(), opts); + } + listFormatter(opts = {}) { + return getCachedLF2(this.intl, opts); + } + isEnglish() { + return this.locale === "en" || this.locale.toLowerCase() === "en-us" || new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us"); + } + equals(other) { + return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar; + } + }; + var singleton3 = null; + var FixedOffsetZone2 = class extends Zone2 { + static get utcInstance() { + if (singleton3 === null) { + singleton3 = new FixedOffsetZone2(0); + } + return singleton3; + } + static instance(offset4) { + return offset4 === 0 ? FixedOffsetZone2.utcInstance : new FixedOffsetZone2(offset4); + } + static parseSpecifier(s3) { + if (s3) { + const r = s3.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i); + if (r) { + return new FixedOffsetZone2(signedOffset2(r[1], r[2])); + } + } + return null; + } + constructor(offset4) { + super(); + this.fixed = offset4; + } + get type() { + return "fixed"; + } + get name() { + return this.fixed === 0 ? "UTC" : `UTC${formatOffset2(this.fixed, "narrow")}`; + } + get ianaName() { + if (this.fixed === 0) { + return "Etc/UTC"; + } else { + return `Etc/GMT${formatOffset2(-this.fixed, "narrow")}`; + } + } + offsetName() { + return this.name; + } + formatOffset(ts, format2) { + return formatOffset2(this.fixed, format2); + } + get isUniversal() { + return true; + } + offset() { + return this.fixed; + } + equals(otherZone) { + return otherZone.type === "fixed" && otherZone.fixed === this.fixed; + } + get isValid() { + return true; + } + }; + var InvalidZone2 = class extends Zone2 { + constructor(zoneName) { + super(); + this.zoneName = zoneName; + } + get type() { + return "invalid"; + } + get name() { + return this.zoneName; + } + get isUniversal() { + return false; + } + offsetName() { + return null; + } + formatOffset() { + return ""; + } + offset() { + return NaN; + } + equals() { + return false; + } + get isValid() { + return false; + } + }; + function normalizeZone2(input, defaultZone3) { + if (isUndefined2(input) || input === null) { + return defaultZone3; + } else if (input instanceof Zone2) { + return input; + } else if (isString2(input)) { + const lowered = input.toLowerCase(); + if (lowered === "default") + return defaultZone3; + else if (lowered === "local" || lowered === "system") + return SystemZone2.instance; + else if (lowered === "utc" || lowered === "gmt") + return FixedOffsetZone2.utcInstance; + else + return FixedOffsetZone2.parseSpecifier(lowered) || IANAZone2.create(input); + } else if (isNumber2(input)) { + return FixedOffsetZone2.instance(input); + } else if (typeof input === "object" && input.offset && typeof input.offset === "number") { + return input; + } else { + return new InvalidZone2(input); + } + } + var now2 = () => Date.now(); + var defaultZone2 = "system"; + var defaultLocale2 = null; + var defaultNumberingSystem2 = null; + var defaultOutputCalendar2 = null; + var twoDigitCutoffYear2 = 60; + var throwOnInvalid2; + var Settings2 = class { + static get now() { + return now2; + } + static set now(n3) { + now2 = n3; + } + static set defaultZone(zone) { + defaultZone2 = zone; + } + static get defaultZone() { + return normalizeZone2(defaultZone2, SystemZone2.instance); + } + static get defaultLocale() { + return defaultLocale2; + } + static set defaultLocale(locale) { + defaultLocale2 = locale; + } + static get defaultNumberingSystem() { + return defaultNumberingSystem2; + } + static set defaultNumberingSystem(numberingSystem) { + defaultNumberingSystem2 = numberingSystem; + } + static get defaultOutputCalendar() { + return defaultOutputCalendar2; + } + static set defaultOutputCalendar(outputCalendar) { + defaultOutputCalendar2 = outputCalendar; + } + static get twoDigitCutoffYear() { + return twoDigitCutoffYear2; + } + static set twoDigitCutoffYear(cutoffYear) { + twoDigitCutoffYear2 = cutoffYear % 100; + } + static get throwOnInvalid() { + return throwOnInvalid2; + } + static set throwOnInvalid(t) { + throwOnInvalid2 = t; + } + static resetCaches() { + Locale2.resetCache(); + IANAZone2.resetCache(); + } + }; + function isUndefined2(o) { + return typeof o === "undefined"; + } + function isNumber2(o) { + return typeof o === "number"; + } + function isInteger2(o) { + return typeof o === "number" && o % 1 === 0; + } + function isString2(o) { + return typeof o === "string"; + } + function isDate2(o) { + return Object.prototype.toString.call(o) === "[object Date]"; + } + function hasRelative2() { + try { + return typeof Intl !== "undefined" && !!Intl.RelativeTimeFormat; + } catch (e) { + return false; + } + } + function maybeArray2(thing) { + return Array.isArray(thing) ? thing : [thing]; + } + function bestBy2(arr, by, compare) { + if (arr.length === 0) { + return void 0; + } + return arr.reduce((best, next) => { + const pair = [by(next), next]; + if (!best) { + return pair; + } else if (compare(best[0], pair[0]) === best[0]) { + return best; + } else { + return pair; + } + }, null)[1]; + } + function pick2(obj, keys) { + return keys.reduce((a, k) => { + a[k] = obj[k]; + return a; + }, {}); + } + function hasOwnProperty2(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); + } + function integerBetween2(thing, bottom2, top2) { + return isInteger2(thing) && thing >= bottom2 && thing <= top2; + } + function floorMod2(x, n3) { + return x - n3 * Math.floor(x / n3); + } + function padStart2(input, n3 = 2) { + const isNeg = input < 0; + let padded; + if (isNeg) { + padded = "-" + ("" + -input).padStart(n3, "0"); + } else { + padded = ("" + input).padStart(n3, "0"); + } + return padded; + } + function parseInteger2(string) { + if (isUndefined2(string) || string === null || string === "") { + return void 0; + } else { + return parseInt(string, 10); + } + } + function parseFloating2(string) { + if (isUndefined2(string) || string === null || string === "") { + return void 0; + } else { + return parseFloat(string); + } + } + function parseMillis2(fraction) { + if (isUndefined2(fraction) || fraction === null || fraction === "") { + return void 0; + } else { + const f = parseFloat("0." + fraction) * 1e3; + return Math.floor(f); + } + } + function roundTo2(number, digits, towardZero = false) { + const factor = 10 ** digits, rounder = towardZero ? Math.trunc : Math.round; + return rounder(number * factor) / factor; + } + function isLeapYear2(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + function daysInYear2(year) { + return isLeapYear2(year) ? 366 : 365; + } + function daysInMonth2(year, month) { + const modMonth = floorMod2(month - 1, 12) + 1, modYear = year + (month - modMonth) / 12; + if (modMonth === 2) { + return isLeapYear2(modYear) ? 29 : 28; + } else { + return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1]; + } + } + function objToLocalTS2(obj) { + let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond); + if (obj.year < 100 && obj.year >= 0) { + d = new Date(d); + d.setUTCFullYear(d.getUTCFullYear() - 1900); + } + return +d; + } + function weeksInWeekYear2(weekYear) { + const p1 = (weekYear + Math.floor(weekYear / 4) - Math.floor(weekYear / 100) + Math.floor(weekYear / 400)) % 7, last = weekYear - 1, p2 = (last + Math.floor(last / 4) - Math.floor(last / 100) + Math.floor(last / 400)) % 7; + return p1 === 4 || p2 === 3 ? 53 : 52; + } + function untruncateYear2(year) { + if (year > 99) { + return year; + } else + return year > Settings2.twoDigitCutoffYear ? 1900 + year : 2e3 + year; + } + function parseZoneInfo2(ts, offsetFormat, locale, timeZone = null) { + const date = new Date(ts), intlOpts = { + hourCycle: "h23", + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit" + }; + if (timeZone) { + intlOpts.timeZone = timeZone; + } + const modified = __spreadValues({ timeZoneName: offsetFormat }, intlOpts); + const parsed = new Intl.DateTimeFormat(locale, modified).formatToParts(date).find((m) => m.type.toLowerCase() === "timezonename"); + return parsed ? parsed.value : null; + } + function signedOffset2(offHourStr, offMinuteStr) { + let offHour = parseInt(offHourStr, 10); + if (Number.isNaN(offHour)) { + offHour = 0; + } + const offMin = parseInt(offMinuteStr, 10) || 0, offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin; + return offHour * 60 + offMinSigned; + } + function asNumber2(value) { + const numericValue = Number(value); + if (typeof value === "boolean" || value === "" || Number.isNaN(numericValue)) + throw new InvalidArgumentError2(`Invalid unit value ${value}`); + return numericValue; + } + function normalizeObject2(obj, normalizer) { + const normalized = {}; + for (const u in obj) { + if (hasOwnProperty2(obj, u)) { + const v = obj[u]; + if (v === void 0 || v === null) + continue; + normalized[normalizer(u)] = asNumber2(v); + } + } + return normalized; + } + function formatOffset2(offset4, format2) { + const hours = Math.trunc(Math.abs(offset4 / 60)), minutes = Math.trunc(Math.abs(offset4 % 60)), sign = offset4 >= 0 ? "+" : "-"; + switch (format2) { + case "short": + return `${sign}${padStart2(hours, 2)}:${padStart2(minutes, 2)}`; + case "narrow": + return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ""}`; + case "techie": + return `${sign}${padStart2(hours, 2)}${padStart2(minutes, 2)}`; + default: + throw new RangeError(`Value format ${format2} is out of range for property format`); + } + } + function timeObject2(obj) { + return pick2(obj, ["hour", "minute", "second", "millisecond"]); + } + var monthsLong2 = [ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December" + ]; + var monthsShort2 = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + var monthsNarrow2 = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"]; + function months2(length) { + switch (length) { + case "narrow": + return [...monthsNarrow2]; + case "short": + return [...monthsShort2]; + case "long": + return [...monthsLong2]; + case "numeric": + return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"]; + case "2-digit": + return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"]; + default: + return null; + } + } + var weekdaysLong2 = [ + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday", + "Sunday" + ]; + var weekdaysShort2 = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]; + var weekdaysNarrow2 = ["M", "T", "W", "T", "F", "S", "S"]; + function weekdays2(length) { + switch (length) { + case "narrow": + return [...weekdaysNarrow2]; + case "short": + return [...weekdaysShort2]; + case "long": + return [...weekdaysLong2]; + case "numeric": + return ["1", "2", "3", "4", "5", "6", "7"]; + default: + return null; + } + } + var meridiems2 = ["AM", "PM"]; + var erasLong2 = ["Before Christ", "Anno Domini"]; + var erasShort2 = ["BC", "AD"]; + var erasNarrow2 = ["B", "A"]; + function eras2(length) { + switch (length) { + case "narrow": + return [...erasNarrow2]; + case "short": + return [...erasShort2]; + case "long": + return [...erasLong2]; + default: + return null; + } + } + function meridiemForDateTime2(dt) { + return meridiems2[dt.hour < 12 ? 0 : 1]; + } + function weekdayForDateTime2(dt, length) { + return weekdays2(length)[dt.weekday - 1]; + } + function monthForDateTime2(dt, length) { + return months2(length)[dt.month - 1]; + } + function eraForDateTime2(dt, length) { + return eras2(length)[dt.year < 0 ? 0 : 1]; + } + function formatRelativeTime2(unit, count, numeric = "always", narrow = false) { + const units = { + years: ["year", "yr."], + quarters: ["quarter", "qtr."], + months: ["month", "mo."], + weeks: ["week", "wk."], + days: ["day", "day", "days"], + hours: ["hour", "hr."], + minutes: ["minute", "min."], + seconds: ["second", "sec."] + }; + const lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1; + if (numeric === "auto" && lastable) { + const isDay = unit === "days"; + switch (count) { + case 1: + return isDay ? "tomorrow" : `next ${units[unit][0]}`; + case -1: + return isDay ? "yesterday" : `last ${units[unit][0]}`; + case 0: + return isDay ? "today" : `this ${units[unit][0]}`; + } + } + const isInPast = Object.is(count, -0) || count < 0, fmtValue = Math.abs(count), singular = fmtValue === 1, lilUnits = units[unit], fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit; + return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`; + } + function stringifyTokens2(splits, tokenToString) { + let s3 = ""; + for (const token of splits) { + if (token.literal) { + s3 += token.val; + } else { + s3 += tokenToString(token.val); + } + } + return s3; + } + var macroTokenToFormatOpts2 = { + D: DATE_SHORT2, + DD: DATE_MED2, + DDD: DATE_FULL2, + DDDD: DATE_HUGE2, + t: TIME_SIMPLE2, + tt: TIME_WITH_SECONDS2, + ttt: TIME_WITH_SHORT_OFFSET2, + tttt: TIME_WITH_LONG_OFFSET2, + T: TIME_24_SIMPLE2, + TT: TIME_24_WITH_SECONDS2, + TTT: TIME_24_WITH_SHORT_OFFSET2, + TTTT: TIME_24_WITH_LONG_OFFSET2, + f: DATETIME_SHORT2, + ff: DATETIME_MED2, + fff: DATETIME_FULL2, + ffff: DATETIME_HUGE2, + F: DATETIME_SHORT_WITH_SECONDS2, + FF: DATETIME_MED_WITH_SECONDS2, + FFF: DATETIME_FULL_WITH_SECONDS2, + FFFF: DATETIME_HUGE_WITH_SECONDS2 + }; + var Formatter2 = class { + static create(locale, opts = {}) { + return new Formatter2(locale, opts); + } + static parseFormat(fmt) { + let current = null, currentFull = "", bracketed = false; + const splits = []; + for (let i = 0; i < fmt.length; i++) { + const c = fmt.charAt(i); + if (c === "'") { + if (currentFull.length > 0) { + splits.push({ literal: bracketed, val: currentFull }); + } + current = null; + currentFull = ""; + bracketed = !bracketed; + } else if (bracketed) { + currentFull += c; + } else if (c === current) { + currentFull += c; + } else { + if (currentFull.length > 0) { + splits.push({ literal: false, val: currentFull }); + } + currentFull = c; + current = c; + } + } + if (currentFull.length > 0) { + splits.push({ literal: bracketed, val: currentFull }); + } + return splits; + } + static macroTokenToFormatOpts(token) { + return macroTokenToFormatOpts2[token]; + } + constructor(locale, formatOpts) { + this.opts = formatOpts; + this.loc = locale; + this.systemLoc = null; + } + formatWithSystemDefault(dt, opts) { + if (this.systemLoc === null) { + this.systemLoc = this.loc.redefaultToSystem(); + } + const df = this.systemLoc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.format(); + } + formatDateTime(dt, opts = {}) { + const df = this.loc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.format(); + } + formatDateTimeParts(dt, opts = {}) { + const df = this.loc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.formatToParts(); + } + formatInterval(interval, opts = {}) { + const df = this.loc.dtFormatter(interval.start, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.dtf.formatRange(interval.start.toJSDate(), interval.end.toJSDate()); + } + resolvedOptions(dt, opts = {}) { + const df = this.loc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.resolvedOptions(); + } + num(n3, p = 0) { + if (this.opts.forceSimple) { + return padStart2(n3, p); + } + const opts = __spreadValues({}, this.opts); + if (p > 0) { + opts.padTo = p; + } + return this.loc.numberFormatter(opts).format(n3); + } + formatDateTimeFromString(dt, fmt) { + const knownEnglish = this.loc.listingMode() === "en", useDateTimeFormatter = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory", string = (opts, extract) => this.loc.extract(dt, opts, extract), formatOffset3 = (opts) => { + if (dt.isOffsetFixed && dt.offset === 0 && opts.allowZ) { + return "Z"; + } + return dt.isValid ? dt.zone.formatOffset(dt.ts, opts.format) : ""; + }, meridiem = () => knownEnglish ? meridiemForDateTime2(dt) : string({ hour: "numeric", hourCycle: "h12" }, "dayperiod"), month = (length, standalone) => knownEnglish ? monthForDateTime2(dt, length) : string(standalone ? { month: length } : { month: length, day: "numeric" }, "month"), weekday = (length, standalone) => knownEnglish ? weekdayForDateTime2(dt, length) : string(standalone ? { weekday: length } : { weekday: length, month: "long", day: "numeric" }, "weekday"), maybeMacro = (token) => { + const formatOpts = Formatter2.macroTokenToFormatOpts(token); + if (formatOpts) { + return this.formatWithSystemDefault(dt, formatOpts); + } else { + return token; + } + }, era = (length) => knownEnglish ? eraForDateTime2(dt, length) : string({ era: length }, "era"), tokenToString = (token) => { + switch (token) { + case "S": + return this.num(dt.millisecond); + case "u": + case "SSS": + return this.num(dt.millisecond, 3); + case "s": + return this.num(dt.second); + case "ss": + return this.num(dt.second, 2); + case "uu": + return this.num(Math.floor(dt.millisecond / 10), 2); + case "uuu": + return this.num(Math.floor(dt.millisecond / 100)); + case "m": + return this.num(dt.minute); + case "mm": + return this.num(dt.minute, 2); + case "h": + return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12); + case "hh": + return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12, 2); + case "H": + return this.num(dt.hour); + case "HH": + return this.num(dt.hour, 2); + case "Z": + return formatOffset3({ format: "narrow", allowZ: this.opts.allowZ }); + case "ZZ": + return formatOffset3({ format: "short", allowZ: this.opts.allowZ }); + case "ZZZ": + return formatOffset3({ format: "techie", allowZ: this.opts.allowZ }); + case "ZZZZ": + return dt.zone.offsetName(dt.ts, { format: "short", locale: this.loc.locale }); + case "ZZZZZ": + return dt.zone.offsetName(dt.ts, { format: "long", locale: this.loc.locale }); + case "z": + return dt.zoneName; + case "a": + return meridiem(); + case "d": + return useDateTimeFormatter ? string({ day: "numeric" }, "day") : this.num(dt.day); + case "dd": + return useDateTimeFormatter ? string({ day: "2-digit" }, "day") : this.num(dt.day, 2); + case "c": + return this.num(dt.weekday); + case "ccc": + return weekday("short", true); + case "cccc": + return weekday("long", true); + case "ccccc": + return weekday("narrow", true); + case "E": + return this.num(dt.weekday); + case "EEE": + return weekday("short", false); + case "EEEE": + return weekday("long", false); + case "EEEEE": + return weekday("narrow", false); + case "L": + return useDateTimeFormatter ? string({ month: "numeric", day: "numeric" }, "month") : this.num(dt.month); + case "LL": + return useDateTimeFormatter ? string({ month: "2-digit", day: "numeric" }, "month") : this.num(dt.month, 2); + case "LLL": + return month("short", true); + case "LLLL": + return month("long", true); + case "LLLLL": + return month("narrow", true); + case "M": + return useDateTimeFormatter ? string({ month: "numeric" }, "month") : this.num(dt.month); + case "MM": + return useDateTimeFormatter ? string({ month: "2-digit" }, "month") : this.num(dt.month, 2); + case "MMM": + return month("short", false); + case "MMMM": + return month("long", false); + case "MMMMM": + return month("narrow", false); + case "y": + return useDateTimeFormatter ? string({ year: "numeric" }, "year") : this.num(dt.year); + case "yy": + return useDateTimeFormatter ? string({ year: "2-digit" }, "year") : this.num(dt.year.toString().slice(-2), 2); + case "yyyy": + return useDateTimeFormatter ? string({ year: "numeric" }, "year") : this.num(dt.year, 4); + case "yyyyyy": + return useDateTimeFormatter ? string({ year: "numeric" }, "year") : this.num(dt.year, 6); + case "G": + return era("short"); + case "GG": + return era("long"); + case "GGGGG": + return era("narrow"); + case "kk": + return this.num(dt.weekYear.toString().slice(-2), 2); + case "kkkk": + return this.num(dt.weekYear, 4); + case "W": + return this.num(dt.weekNumber); + case "WW": + return this.num(dt.weekNumber, 2); + case "o": + return this.num(dt.ordinal); + case "ooo": + return this.num(dt.ordinal, 3); + case "q": + return this.num(dt.quarter); + case "qq": + return this.num(dt.quarter, 2); + case "X": + return this.num(Math.floor(dt.ts / 1e3)); + case "x": + return this.num(dt.ts); + default: + return maybeMacro(token); + } + }; + return stringifyTokens2(Formatter2.parseFormat(fmt), tokenToString); + } + formatDurationFromString(dur, fmt) { + const tokenToField = (token) => { + switch (token[0]) { + case "S": + return "millisecond"; + case "s": + return "second"; + case "m": + return "minute"; + case "h": + return "hour"; + case "d": + return "day"; + case "w": + return "week"; + case "M": + return "month"; + case "y": + return "year"; + default: + return null; + } + }, tokenToString = (lildur) => (token) => { + const mapped = tokenToField(token); + if (mapped) { + return this.num(lildur.get(mapped), token.length); + } else { + return token; + } + }, tokens = Formatter2.parseFormat(fmt), realTokens = tokens.reduce((found, { literal, val }) => literal ? found : found.concat(val), []), collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter((t) => t)); + return stringifyTokens2(tokens, tokenToString(collapsed)); + } + }; + var Invalid2 = class { + constructor(reason, explanation) { + this.reason = reason; + this.explanation = explanation; + } + toMessage() { + if (this.explanation) { + return `${this.reason}: ${this.explanation}`; + } else { + return this.reason; + } + } + }; + var ianaRegex2 = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/; + function combineRegexes2(...regexes) { + const full = regexes.reduce((f, r) => f + r.source, ""); + return RegExp(`^${full}$`); + } + function combineExtractors2(...extractors) { + return (m) => extractors.reduce(([mergedVals, mergedZone, cursor], ex) => { + const [val, zone, next] = ex(m, cursor); + return [__spreadValues(__spreadValues({}, mergedVals), val), zone || mergedZone, next]; + }, [{}, null, 1]).slice(0, 2); + } + function parse3(s3, ...patterns) { + if (s3 == null) { + return [null, null]; + } + for (const [regex, extractor] of patterns) { + const m = regex.exec(s3); + if (m) { + return extractor(m); + } + } + return [null, null]; + } + function simpleParse2(...keys) { + return (match3, cursor) => { + const ret = {}; + let i; + for (i = 0; i < keys.length; i++) { + ret[keys[i]] = parseInteger2(match3[cursor + i]); + } + return [ret, null, cursor + i]; + }; + } + var offsetRegex2 = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/; + var isoExtendedZone2 = `(?:${offsetRegex2.source}?(?:\\[(${ianaRegex2.source})\\])?)?`; + var isoTimeBaseRegex2 = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/; + var isoTimeRegex2 = RegExp(`${isoTimeBaseRegex2.source}${isoExtendedZone2}`); + var isoTimeExtensionRegex2 = RegExp(`(?:T${isoTimeRegex2.source})?`); + var isoYmdRegex2 = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/; + var isoWeekRegex2 = /(\d{4})-?W(\d\d)(?:-?(\d))?/; + var isoOrdinalRegex2 = /(\d{4})-?(\d{3})/; + var extractISOWeekData2 = simpleParse2("weekYear", "weekNumber", "weekDay"); + var extractISOOrdinalData2 = simpleParse2("year", "ordinal"); + var sqlYmdRegex2 = /(\d{4})-(\d\d)-(\d\d)/; + var sqlTimeRegex2 = RegExp(`${isoTimeBaseRegex2.source} ?(?:${offsetRegex2.source}|(${ianaRegex2.source}))?`); + var sqlTimeExtensionRegex2 = RegExp(`(?: ${sqlTimeRegex2.source})?`); + function int2(match3, pos, fallback) { + const m = match3[pos]; + return isUndefined2(m) ? fallback : parseInteger2(m); + } + function extractISOYmd2(match3, cursor) { + const item = { + year: int2(match3, cursor), + month: int2(match3, cursor + 1, 1), + day: int2(match3, cursor + 2, 1) + }; + return [item, null, cursor + 3]; + } + function extractISOTime2(match3, cursor) { + const item = { + hours: int2(match3, cursor, 0), + minutes: int2(match3, cursor + 1, 0), + seconds: int2(match3, cursor + 2, 0), + milliseconds: parseMillis2(match3[cursor + 3]) + }; + return [item, null, cursor + 4]; + } + function extractISOOffset2(match3, cursor) { + const local = !match3[cursor] && !match3[cursor + 1], fullOffset = signedOffset2(match3[cursor + 1], match3[cursor + 2]), zone = local ? null : FixedOffsetZone2.instance(fullOffset); + return [{}, zone, cursor + 3]; + } + function extractIANAZone2(match3, cursor) { + const zone = match3[cursor] ? IANAZone2.create(match3[cursor]) : null; + return [{}, zone, cursor + 1]; + } + var isoTimeOnly2 = RegExp(`^T?${isoTimeBaseRegex2.source}$`); + var isoDuration2 = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/; + function extractISODuration2(match3) { + const [s3, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] = match3; + const hasNegativePrefix = s3[0] === "-"; + const negativeSeconds = secondStr && secondStr[0] === "-"; + const maybeNegate = (num, force = false) => num !== void 0 && (force || num && hasNegativePrefix) ? -num : num; + return [ + { + years: maybeNegate(parseFloating2(yearStr)), + months: maybeNegate(parseFloating2(monthStr)), + weeks: maybeNegate(parseFloating2(weekStr)), + days: maybeNegate(parseFloating2(dayStr)), + hours: maybeNegate(parseFloating2(hourStr)), + minutes: maybeNegate(parseFloating2(minuteStr)), + seconds: maybeNegate(parseFloating2(secondStr), secondStr === "-0"), + milliseconds: maybeNegate(parseMillis2(millisecondsStr), negativeSeconds) + } + ]; + } + var obsOffsets2 = { + GMT: 0, + EDT: -4 * 60, + EST: -5 * 60, + CDT: -5 * 60, + CST: -6 * 60, + MDT: -6 * 60, + MST: -7 * 60, + PDT: -7 * 60, + PST: -8 * 60 + }; + function fromStrings2(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { + const result = { + year: yearStr.length === 2 ? untruncateYear2(parseInteger2(yearStr)) : parseInteger2(yearStr), + month: monthsShort2.indexOf(monthStr) + 1, + day: parseInteger2(dayStr), + hour: parseInteger2(hourStr), + minute: parseInteger2(minuteStr) + }; + if (secondStr) + result.second = parseInteger2(secondStr); + if (weekdayStr) { + result.weekday = weekdayStr.length > 3 ? weekdaysLong2.indexOf(weekdayStr) + 1 : weekdaysShort2.indexOf(weekdayStr) + 1; + } + return result; + } + var rfc28222 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/; + function extractRFC28222(match3) { + const [ + , + weekdayStr, + dayStr, + monthStr, + yearStr, + hourStr, + minuteStr, + secondStr, + obsOffset, + milOffset, + offHourStr, + offMinuteStr + ] = match3, result = fromStrings2(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr); + let offset4; + if (obsOffset) { + offset4 = obsOffsets2[obsOffset]; + } else if (milOffset) { + offset4 = 0; + } else { + offset4 = signedOffset2(offHourStr, offMinuteStr); + } + return [result, new FixedOffsetZone2(offset4)]; + } + function preprocessRFC28222(s3) { + return s3.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim(); + } + var rfc11232 = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/; + var rfc8502 = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/; + var ascii2 = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/; + function extractRFC1123Or8502(match3) { + const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr] = match3, result = fromStrings2(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr); + return [result, FixedOffsetZone2.utcInstance]; + } + function extractASCII2(match3) { + const [, weekdayStr, monthStr, dayStr, hourStr, minuteStr, secondStr, yearStr] = match3, result = fromStrings2(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr); + return [result, FixedOffsetZone2.utcInstance]; + } + var isoYmdWithTimeExtensionRegex2 = combineRegexes2(isoYmdRegex2, isoTimeExtensionRegex2); + var isoWeekWithTimeExtensionRegex2 = combineRegexes2(isoWeekRegex2, isoTimeExtensionRegex2); + var isoOrdinalWithTimeExtensionRegex2 = combineRegexes2(isoOrdinalRegex2, isoTimeExtensionRegex2); + var isoTimeCombinedRegex2 = combineRegexes2(isoTimeRegex2); + var extractISOYmdTimeAndOffset2 = combineExtractors2(extractISOYmd2, extractISOTime2, extractISOOffset2, extractIANAZone2); + var extractISOWeekTimeAndOffset2 = combineExtractors2(extractISOWeekData2, extractISOTime2, extractISOOffset2, extractIANAZone2); + var extractISOOrdinalDateAndTime2 = combineExtractors2(extractISOOrdinalData2, extractISOTime2, extractISOOffset2, extractIANAZone2); + var extractISOTimeAndOffset2 = combineExtractors2(extractISOTime2, extractISOOffset2, extractIANAZone2); + function parseISODate2(s3) { + return parse3(s3, [isoYmdWithTimeExtensionRegex2, extractISOYmdTimeAndOffset2], [isoWeekWithTimeExtensionRegex2, extractISOWeekTimeAndOffset2], [isoOrdinalWithTimeExtensionRegex2, extractISOOrdinalDateAndTime2], [isoTimeCombinedRegex2, extractISOTimeAndOffset2]); + } + function parseRFC2822Date2(s3) { + return parse3(preprocessRFC28222(s3), [rfc28222, extractRFC28222]); + } + function parseHTTPDate2(s3) { + return parse3(s3, [rfc11232, extractRFC1123Or8502], [rfc8502, extractRFC1123Or8502], [ascii2, extractASCII2]); + } + function parseISODuration2(s3) { + return parse3(s3, [isoDuration2, extractISODuration2]); + } + var extractISOTimeOnly2 = combineExtractors2(extractISOTime2); + function parseISOTimeOnly2(s3) { + return parse3(s3, [isoTimeOnly2, extractISOTimeOnly2]); + } + var sqlYmdWithTimeExtensionRegex2 = combineRegexes2(sqlYmdRegex2, sqlTimeExtensionRegex2); + var sqlTimeCombinedRegex2 = combineRegexes2(sqlTimeRegex2); + var extractISOTimeOffsetAndIANAZone2 = combineExtractors2(extractISOTime2, extractISOOffset2, extractIANAZone2); + function parseSQL2(s3) { + return parse3(s3, [sqlYmdWithTimeExtensionRegex2, extractISOYmdTimeAndOffset2], [sqlTimeCombinedRegex2, extractISOTimeOffsetAndIANAZone2]); + } + var INVALID$2 = "Invalid Duration"; + var lowOrderMatrix2 = { + weeks: { + days: 7, + hours: 7 * 24, + minutes: 7 * 24 * 60, + seconds: 7 * 24 * 60 * 60, + milliseconds: 7 * 24 * 60 * 60 * 1e3 + }, + days: { + hours: 24, + minutes: 24 * 60, + seconds: 24 * 60 * 60, + milliseconds: 24 * 60 * 60 * 1e3 + }, + hours: { minutes: 60, seconds: 60 * 60, milliseconds: 60 * 60 * 1e3 }, + minutes: { seconds: 60, milliseconds: 60 * 1e3 }, + seconds: { milliseconds: 1e3 } + }; + var casualMatrix2 = __spreadValues({ + years: { + quarters: 4, + months: 12, + weeks: 52, + days: 365, + hours: 365 * 24, + minutes: 365 * 24 * 60, + seconds: 365 * 24 * 60 * 60, + milliseconds: 365 * 24 * 60 * 60 * 1e3 + }, + quarters: { + months: 3, + weeks: 13, + days: 91, + hours: 91 * 24, + minutes: 91 * 24 * 60, + seconds: 91 * 24 * 60 * 60, + milliseconds: 91 * 24 * 60 * 60 * 1e3 + }, + months: { + weeks: 4, + days: 30, + hours: 30 * 24, + minutes: 30 * 24 * 60, + seconds: 30 * 24 * 60 * 60, + milliseconds: 30 * 24 * 60 * 60 * 1e3 + } + }, lowOrderMatrix2); + var daysInYearAccurate2 = 146097 / 400; + var daysInMonthAccurate2 = 146097 / 4800; + var accurateMatrix2 = __spreadValues({ + years: { + quarters: 4, + months: 12, + weeks: daysInYearAccurate2 / 7, + days: daysInYearAccurate2, + hours: daysInYearAccurate2 * 24, + minutes: daysInYearAccurate2 * 24 * 60, + seconds: daysInYearAccurate2 * 24 * 60 * 60, + milliseconds: daysInYearAccurate2 * 24 * 60 * 60 * 1e3 + }, + quarters: { + months: 3, + weeks: daysInYearAccurate2 / 28, + days: daysInYearAccurate2 / 4, + hours: daysInYearAccurate2 * 24 / 4, + minutes: daysInYearAccurate2 * 24 * 60 / 4, + seconds: daysInYearAccurate2 * 24 * 60 * 60 / 4, + milliseconds: daysInYearAccurate2 * 24 * 60 * 60 * 1e3 / 4 + }, + months: { + weeks: daysInMonthAccurate2 / 7, + days: daysInMonthAccurate2, + hours: daysInMonthAccurate2 * 24, + minutes: daysInMonthAccurate2 * 24 * 60, + seconds: daysInMonthAccurate2 * 24 * 60 * 60, + milliseconds: daysInMonthAccurate2 * 24 * 60 * 60 * 1e3 + } + }, lowOrderMatrix2); + var orderedUnits$1 = [ + "years", + "quarters", + "months", + "weeks", + "days", + "hours", + "minutes", + "seconds", + "milliseconds" + ]; + var reverseUnits2 = orderedUnits$1.slice(0).reverse(); + function clone$1(dur, alts, clear = false) { + const conf = { + values: clear ? alts.values : __spreadValues(__spreadValues({}, dur.values), alts.values || {}), + loc: dur.loc.clone(alts.loc), + conversionAccuracy: alts.conversionAccuracy || dur.conversionAccuracy, + matrix: alts.matrix || dur.matrix + }; + return new Duration2(conf); + } + function antiTrunc2(n3) { + return n3 < 0 ? Math.floor(n3) : Math.ceil(n3); + } + function convert2(matrix, fromMap, fromUnit, toMap, toUnit) { + const conv = matrix[toUnit][fromUnit], raw = fromMap[fromUnit] / conv, sameSign = Math.sign(raw) === Math.sign(toMap[toUnit]), added = !sameSign && toMap[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc2(raw) : Math.trunc(raw); + toMap[toUnit] += added; + fromMap[fromUnit] -= added * conv; + } + function normalizeValues2(matrix, vals) { + reverseUnits2.reduce((previous, current) => { + if (!isUndefined2(vals[current])) { + if (previous) { + convert2(matrix, vals, previous, vals, current); + } + return current; + } else { + return previous; + } + }, null); + } + function removeZeroes2(vals) { + const newVals = {}; + for (const [key, value] of Object.entries(vals)) { + if (value !== 0) { + newVals[key] = value; + } + } + return newVals; + } + var Duration2 = class { + constructor(config) { + const accurate = config.conversionAccuracy === "longterm" || false; + let matrix = accurate ? accurateMatrix2 : casualMatrix2; + if (config.matrix) { + matrix = config.matrix; + } + this.values = config.values; + this.loc = config.loc || Locale2.create(); + this.conversionAccuracy = accurate ? "longterm" : "casual"; + this.invalid = config.invalid || null; + this.matrix = matrix; + this.isLuxonDuration = true; + } + static fromMillis(count, opts) { + return Duration2.fromObject({ milliseconds: count }, opts); + } + static fromObject(obj, opts = {}) { + if (obj == null || typeof obj !== "object") { + throw new InvalidArgumentError2(`Duration.fromObject: argument expected to be an object, got ${obj === null ? "null" : typeof obj}`); + } + return new Duration2({ + values: normalizeObject2(obj, Duration2.normalizeUnit), + loc: Locale2.fromObject(opts), + conversionAccuracy: opts.conversionAccuracy, + matrix: opts.matrix + }); + } + static fromDurationLike(durationLike) { + if (isNumber2(durationLike)) { + return Duration2.fromMillis(durationLike); + } else if (Duration2.isDuration(durationLike)) { + return durationLike; + } else if (typeof durationLike === "object") { + return Duration2.fromObject(durationLike); + } else { + throw new InvalidArgumentError2(`Unknown duration argument ${durationLike} of type ${typeof durationLike}`); + } + } + static fromISO(text, opts) { + const [parsed] = parseISODuration2(text); + if (parsed) { + return Duration2.fromObject(parsed, opts); + } else { + return Duration2.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`); + } + } + static fromISOTime(text, opts) { + const [parsed] = parseISOTimeOnly2(text); + if (parsed) { + return Duration2.fromObject(parsed, opts); + } else { + return Duration2.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`); + } + } + static invalid(reason, explanation = null) { + if (!reason) { + throw new InvalidArgumentError2("need to specify a reason the Duration is invalid"); + } + const invalid = reason instanceof Invalid2 ? reason : new Invalid2(reason, explanation); + if (Settings2.throwOnInvalid) { + throw new InvalidDurationError2(invalid); + } else { + return new Duration2({ invalid }); + } + } + static normalizeUnit(unit) { + const normalized = { + year: "years", + years: "years", + quarter: "quarters", + quarters: "quarters", + month: "months", + months: "months", + week: "weeks", + weeks: "weeks", + day: "days", + days: "days", + hour: "hours", + hours: "hours", + minute: "minutes", + minutes: "minutes", + second: "seconds", + seconds: "seconds", + millisecond: "milliseconds", + milliseconds: "milliseconds" + }[unit ? unit.toLowerCase() : unit]; + if (!normalized) + throw new InvalidUnitError2(unit); + return normalized; + } + static isDuration(o) { + return o && o.isLuxonDuration || false; + } + get locale() { + return this.isValid ? this.loc.locale : null; + } + get numberingSystem() { + return this.isValid ? this.loc.numberingSystem : null; + } + toFormat(fmt, opts = {}) { + const fmtOpts = __spreadProps(__spreadValues({}, opts), { + floor: opts.round !== false && opts.floor !== false + }); + return this.isValid ? Formatter2.create(this.loc, fmtOpts).formatDurationFromString(this, fmt) : INVALID$2; + } + toHuman(opts = {}) { + const l3 = orderedUnits$1.map((unit) => { + const val = this.values[unit]; + if (isUndefined2(val)) { + return null; + } + return this.loc.numberFormatter(__spreadProps(__spreadValues({ style: "unit", unitDisplay: "long" }, opts), { unit: unit.slice(0, -1) })).format(val); + }).filter((n3) => n3); + return this.loc.listFormatter(__spreadValues({ type: "conjunction", style: opts.listStyle || "narrow" }, opts)).format(l3); + } + toObject() { + if (!this.isValid) + return {}; + return __spreadValues({}, this.values); + } + toISO() { + if (!this.isValid) + return null; + let s3 = "P"; + if (this.years !== 0) + s3 += this.years + "Y"; + if (this.months !== 0 || this.quarters !== 0) + s3 += this.months + this.quarters * 3 + "M"; + if (this.weeks !== 0) + s3 += this.weeks + "W"; + if (this.days !== 0) + s3 += this.days + "D"; + if (this.hours !== 0 || this.minutes !== 0 || this.seconds !== 0 || this.milliseconds !== 0) + s3 += "T"; + if (this.hours !== 0) + s3 += this.hours + "H"; + if (this.minutes !== 0) + s3 += this.minutes + "M"; + if (this.seconds !== 0 || this.milliseconds !== 0) + s3 += roundTo2(this.seconds + this.milliseconds / 1e3, 3) + "S"; + if (s3 === "P") + s3 += "T0S"; + return s3; + } + toISOTime(opts = {}) { + if (!this.isValid) + return null; + const millis = this.toMillis(); + if (millis < 0 || millis >= 864e5) + return null; + opts = __spreadValues({ + suppressMilliseconds: false, + suppressSeconds: false, + includePrefix: false, + format: "extended" + }, opts); + const value = this.shiftTo("hours", "minutes", "seconds", "milliseconds"); + let fmt = opts.format === "basic" ? "hhmm" : "hh:mm"; + if (!opts.suppressSeconds || value.seconds !== 0 || value.milliseconds !== 0) { + fmt += opts.format === "basic" ? "ss" : ":ss"; + if (!opts.suppressMilliseconds || value.milliseconds !== 0) { + fmt += ".SSS"; + } + } + let str = value.toFormat(fmt); + if (opts.includePrefix) { + str = "T" + str; + } + return str; + } + toJSON() { + return this.toISO(); + } + toString() { + return this.toISO(); + } + toMillis() { + return this.as("milliseconds"); + } + valueOf() { + return this.toMillis(); + } + plus(duration) { + if (!this.isValid) + return this; + const dur = Duration2.fromDurationLike(duration), result = {}; + for (const k of orderedUnits$1) { + if (hasOwnProperty2(dur.values, k) || hasOwnProperty2(this.values, k)) { + result[k] = dur.get(k) + this.get(k); + } + } + return clone$1(this, { values: result }, true); + } + minus(duration) { + if (!this.isValid) + return this; + const dur = Duration2.fromDurationLike(duration); + return this.plus(dur.negate()); + } + mapUnits(fn2) { + if (!this.isValid) + return this; + const result = {}; + for (const k of Object.keys(this.values)) { + result[k] = asNumber2(fn2(this.values[k], k)); + } + return clone$1(this, { values: result }, true); + } + get(unit) { + return this[Duration2.normalizeUnit(unit)]; + } + set(values) { + if (!this.isValid) + return this; + const mixed = __spreadValues(__spreadValues({}, this.values), normalizeObject2(values, Duration2.normalizeUnit)); + return clone$1(this, { values: mixed }); + } + reconfigure({ locale, numberingSystem, conversionAccuracy, matrix } = {}) { + const loc = this.loc.clone({ locale, numberingSystem }); + const opts = { loc, matrix, conversionAccuracy }; + return clone$1(this, opts); + } + as(unit) { + return this.isValid ? this.shiftTo(unit).get(unit) : NaN; + } + normalize() { + if (!this.isValid) + return this; + const vals = this.toObject(); + normalizeValues2(this.matrix, vals); + return clone$1(this, { values: vals }, true); + } + rescale() { + if (!this.isValid) + return this; + const vals = removeZeroes2(this.normalize().shiftToAll().toObject()); + return clone$1(this, { values: vals }, true); + } + shiftTo(...units) { + if (!this.isValid) + return this; + if (units.length === 0) { + return this; + } + units = units.map((u) => Duration2.normalizeUnit(u)); + const built = {}, accumulated = {}, vals = this.toObject(); + let lastUnit; + for (const k of orderedUnits$1) { + if (units.indexOf(k) >= 0) { + lastUnit = k; + let own = 0; + for (const ak in accumulated) { + own += this.matrix[ak][k] * accumulated[ak]; + accumulated[ak] = 0; + } + if (isNumber2(vals[k])) { + own += vals[k]; + } + const i = Math.trunc(own); + built[k] = i; + accumulated[k] = (own * 1e3 - i * 1e3) / 1e3; + for (const down in vals) { + if (orderedUnits$1.indexOf(down) > orderedUnits$1.indexOf(k)) { + convert2(this.matrix, vals, down, built, k); + } + } + } else if (isNumber2(vals[k])) { + accumulated[k] = vals[k]; + } + } + for (const key in accumulated) { + if (accumulated[key] !== 0) { + built[lastUnit] += key === lastUnit ? accumulated[key] : accumulated[key] / this.matrix[lastUnit][key]; + } + } + return clone$1(this, { values: built }, true).normalize(); + } + shiftToAll() { + if (!this.isValid) + return this; + return this.shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds"); + } + negate() { + if (!this.isValid) + return this; + const negated = {}; + for (const k of Object.keys(this.values)) { + negated[k] = this.values[k] === 0 ? 0 : -this.values[k]; + } + return clone$1(this, { values: negated }, true); + } + get years() { + return this.isValid ? this.values.years || 0 : NaN; + } + get quarters() { + return this.isValid ? this.values.quarters || 0 : NaN; + } + get months() { + return this.isValid ? this.values.months || 0 : NaN; + } + get weeks() { + return this.isValid ? this.values.weeks || 0 : NaN; + } + get days() { + return this.isValid ? this.values.days || 0 : NaN; + } + get hours() { + return this.isValid ? this.values.hours || 0 : NaN; + } + get minutes() { + return this.isValid ? this.values.minutes || 0 : NaN; + } + get seconds() { + return this.isValid ? this.values.seconds || 0 : NaN; + } + get milliseconds() { + return this.isValid ? this.values.milliseconds || 0 : NaN; + } + get isValid() { + return this.invalid === null; + } + get invalidReason() { + return this.invalid ? this.invalid.reason : null; + } + get invalidExplanation() { + return this.invalid ? this.invalid.explanation : null; + } + equals(other) { + if (!this.isValid || !other.isValid) { + return false; + } + if (!this.loc.equals(other.loc)) { + return false; + } + function eq(v1, v2) { + if (v1 === void 0 || v1 === 0) + return v2 === void 0 || v2 === 0; + return v1 === v2; + } + for (const u of orderedUnits$1) { + if (!eq(this.values[u], other.values[u])) { + return false; + } + } + return true; + } + }; + var INVALID$1 = "Invalid Interval"; + function validateStartEnd2(start2, end2) { + if (!start2 || !start2.isValid) { + return Interval2.invalid("missing or invalid start"); + } else if (!end2 || !end2.isValid) { + return Interval2.invalid("missing or invalid end"); + } else if (end2 < start2) { + return Interval2.invalid("end before start", `The end of an interval must be after its start, but you had start=${start2.toISO()} and end=${end2.toISO()}`); + } else { + return null; + } + } + var Interval2 = class { + constructor(config) { + this.s = config.start; + this.e = config.end; + this.invalid = config.invalid || null; + this.isLuxonInterval = true; + } + static invalid(reason, explanation = null) { + if (!reason) { + throw new InvalidArgumentError2("need to specify a reason the Interval is invalid"); + } + const invalid = reason instanceof Invalid2 ? reason : new Invalid2(reason, explanation); + if (Settings2.throwOnInvalid) { + throw new InvalidIntervalError2(invalid); + } else { + return new Interval2({ invalid }); + } + } + static fromDateTimes(start2, end2) { + const builtStart = friendlyDateTime2(start2), builtEnd = friendlyDateTime2(end2); + const validateError = validateStartEnd2(builtStart, builtEnd); + if (validateError == null) { + return new Interval2({ + start: builtStart, + end: builtEnd + }); + } else { + return validateError; + } + } + static after(start2, duration) { + const dur = Duration2.fromDurationLike(duration), dt = friendlyDateTime2(start2); + return Interval2.fromDateTimes(dt, dt.plus(dur)); + } + static before(end2, duration) { + const dur = Duration2.fromDurationLike(duration), dt = friendlyDateTime2(end2); + return Interval2.fromDateTimes(dt.minus(dur), dt); + } + static fromISO(text, opts) { + const [s3, e] = (text || "").split("/", 2); + if (s3 && e) { + let start2, startIsValid; + try { + start2 = DateTime2.fromISO(s3, opts); + startIsValid = start2.isValid; + } catch (e2) { + startIsValid = false; + } + let end2, endIsValid; + try { + end2 = DateTime2.fromISO(e, opts); + endIsValid = end2.isValid; + } catch (e2) { + endIsValid = false; + } + if (startIsValid && endIsValid) { + return Interval2.fromDateTimes(start2, end2); + } + if (startIsValid) { + const dur = Duration2.fromISO(e, opts); + if (dur.isValid) { + return Interval2.after(start2, dur); + } + } else if (endIsValid) { + const dur = Duration2.fromISO(s3, opts); + if (dur.isValid) { + return Interval2.before(end2, dur); + } + } + } + return Interval2.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`); + } + static isInterval(o) { + return o && o.isLuxonInterval || false; + } + get start() { + return this.isValid ? this.s : null; + } + get end() { + return this.isValid ? this.e : null; + } + get isValid() { + return this.invalidReason === null; + } + get invalidReason() { + return this.invalid ? this.invalid.reason : null; + } + get invalidExplanation() { + return this.invalid ? this.invalid.explanation : null; + } + length(unit = "milliseconds") { + return this.isValid ? this.toDuration(...[unit]).get(unit) : NaN; + } + count(unit = "milliseconds") { + if (!this.isValid) + return NaN; + const start2 = this.start.startOf(unit), end2 = this.end.startOf(unit); + return Math.floor(end2.diff(start2, unit).get(unit)) + 1; + } + hasSame(unit) { + return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false; + } + isEmpty() { + return this.s.valueOf() === this.e.valueOf(); + } + isAfter(dateTime) { + if (!this.isValid) + return false; + return this.s > dateTime; + } + isBefore(dateTime) { + if (!this.isValid) + return false; + return this.e <= dateTime; + } + contains(dateTime) { + if (!this.isValid) + return false; + return this.s <= dateTime && this.e > dateTime; + } + set({ start: start2, end: end2 } = {}) { + if (!this.isValid) + return this; + return Interval2.fromDateTimes(start2 || this.s, end2 || this.e); + } + splitAt(...dateTimes) { + if (!this.isValid) + return []; + const sorted = dateTimes.map(friendlyDateTime2).filter((d) => this.contains(d)).sort(), results = []; + let { s: s3 } = this, i = 0; + while (s3 < this.e) { + const added = sorted[i] || this.e, next = +added > +this.e ? this.e : added; + results.push(Interval2.fromDateTimes(s3, next)); + s3 = next; + i += 1; + } + return results; + } + splitBy(duration) { + const dur = Duration2.fromDurationLike(duration); + if (!this.isValid || !dur.isValid || dur.as("milliseconds") === 0) { + return []; + } + let { s: s3 } = this, idx = 1, next; + const results = []; + while (s3 < this.e) { + const added = this.start.plus(dur.mapUnits((x) => x * idx)); + next = +added > +this.e ? this.e : added; + results.push(Interval2.fromDateTimes(s3, next)); + s3 = next; + idx += 1; + } + return results; + } + divideEqually(numberOfParts) { + if (!this.isValid) + return []; + return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts); + } + overlaps(other) { + return this.e > other.s && this.s < other.e; + } + abutsStart(other) { + if (!this.isValid) + return false; + return +this.e === +other.s; + } + abutsEnd(other) { + if (!this.isValid) + return false; + return +other.e === +this.s; + } + engulfs(other) { + if (!this.isValid) + return false; + return this.s <= other.s && this.e >= other.e; + } + equals(other) { + if (!this.isValid || !other.isValid) { + return false; + } + return this.s.equals(other.s) && this.e.equals(other.e); + } + intersection(other) { + if (!this.isValid) + return this; + const s3 = this.s > other.s ? this.s : other.s, e = this.e < other.e ? this.e : other.e; + if (s3 >= e) { + return null; + } else { + return Interval2.fromDateTimes(s3, e); + } + } + union(other) { + if (!this.isValid) + return this; + const s3 = this.s < other.s ? this.s : other.s, e = this.e > other.e ? this.e : other.e; + return Interval2.fromDateTimes(s3, e); + } + static merge(intervals) { + const [found, final] = intervals.sort((a, b) => a.s - b.s).reduce(([sofar, current], item) => { + if (!current) { + return [sofar, item]; + } else if (current.overlaps(item) || current.abutsStart(item)) { + return [sofar, current.union(item)]; + } else { + return [sofar.concat([current]), item]; + } + }, [[], null]); + if (final) { + found.push(final); + } + return found; + } + static xor(intervals) { + let start2 = null, currentCount = 0; + const results = [], ends = intervals.map((i) => [ + { time: i.s, type: "s" }, + { time: i.e, type: "e" } + ]), flattened = Array.prototype.concat(...ends), arr = flattened.sort((a, b) => a.time - b.time); + for (const i of arr) { + currentCount += i.type === "s" ? 1 : -1; + if (currentCount === 1) { + start2 = i.time; + } else { + if (start2 && +start2 !== +i.time) { + results.push(Interval2.fromDateTimes(start2, i.time)); + } + start2 = null; + } + } + return Interval2.merge(results); + } + difference(...intervals) { + return Interval2.xor([this].concat(intervals)).map((i) => this.intersection(i)).filter((i) => i && !i.isEmpty()); + } + toString() { + if (!this.isValid) + return INVALID$1; + return `[${this.s.toISO()} \u2013 ${this.e.toISO()})`; + } + toLocaleString(formatOpts = DATE_SHORT2, opts = {}) { + return this.isValid ? Formatter2.create(this.s.loc.clone(opts), formatOpts).formatInterval(this) : INVALID$1; + } + toISO(opts) { + if (!this.isValid) + return INVALID$1; + return `${this.s.toISO(opts)}/${this.e.toISO(opts)}`; + } + toISODate() { + if (!this.isValid) + return INVALID$1; + return `${this.s.toISODate()}/${this.e.toISODate()}`; + } + toISOTime(opts) { + if (!this.isValid) + return INVALID$1; + return `${this.s.toISOTime(opts)}/${this.e.toISOTime(opts)}`; + } + toFormat(dateFormat, { separator = " \u2013 " } = {}) { + if (!this.isValid) + return INVALID$1; + return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`; + } + toDuration(unit, opts) { + if (!this.isValid) { + return Duration2.invalid(this.invalidReason); + } + return this.e.diff(this.s, unit, opts); + } + mapEndpoints(mapFn) { + return Interval2.fromDateTimes(mapFn(this.s), mapFn(this.e)); + } + }; + var Info2 = class { + static hasDST(zone = Settings2.defaultZone) { + const proto = DateTime2.now().setZone(zone).set({ month: 12 }); + return !zone.isUniversal && proto.offset !== proto.set({ month: 6 }).offset; + } + static isValidIANAZone(zone) { + return IANAZone2.isValidZone(zone); + } + static normalizeZone(input) { + return normalizeZone2(input, Settings2.defaultZone); + } + static months(length = "long", { locale = null, numberingSystem = null, locObj = null, outputCalendar = "gregory" } = {}) { + return (locObj || Locale2.create(locale, numberingSystem, outputCalendar)).months(length); + } + static monthsFormat(length = "long", { locale = null, numberingSystem = null, locObj = null, outputCalendar = "gregory" } = {}) { + return (locObj || Locale2.create(locale, numberingSystem, outputCalendar)).months(length, true); + } + static weekdays(length = "long", { locale = null, numberingSystem = null, locObj = null } = {}) { + return (locObj || Locale2.create(locale, numberingSystem, null)).weekdays(length); + } + static weekdaysFormat(length = "long", { locale = null, numberingSystem = null, locObj = null } = {}) { + return (locObj || Locale2.create(locale, numberingSystem, null)).weekdays(length, true); + } + static meridiems({ locale = null } = {}) { + return Locale2.create(locale).meridiems(); + } + static eras(length = "short", { locale = null } = {}) { + return Locale2.create(locale, null, "gregory").eras(length); + } + static features() { + return { relative: hasRelative2() }; + } + }; + function dayDiff2(earlier, later) { + const utcDayStart = (dt) => dt.toUTC(0, { keepLocalTime: true }).startOf("day").valueOf(), ms = utcDayStart(later) - utcDayStart(earlier); + return Math.floor(Duration2.fromMillis(ms).as("days")); + } + function highOrderDiffs2(cursor, later, units) { + const differs = [ + ["years", (a, b) => b.year - a.year], + ["quarters", (a, b) => b.quarter - a.quarter + (b.year - a.year) * 4], + ["months", (a, b) => b.month - a.month + (b.year - a.year) * 12], + [ + "weeks", + (a, b) => { + const days = dayDiff2(a, b); + return (days - days % 7) / 7; + } + ], + ["days", dayDiff2] + ]; + const results = {}; + const earlier = cursor; + let lowestOrder, highWater; + for (const [unit, differ] of differs) { + if (units.indexOf(unit) >= 0) { + lowestOrder = unit; + results[unit] = differ(cursor, later); + highWater = earlier.plus(results); + if (highWater > later) { + results[unit]--; + cursor = earlier.plus(results); + } else { + cursor = highWater; + } + } + } + return [cursor, results, highWater, lowestOrder]; + } + function diff(earlier, later, units, opts) { + let [cursor, results, highWater, lowestOrder] = highOrderDiffs2(earlier, later, units); + const remainingMillis = later - cursor; + const lowerOrderUnits = units.filter((u) => ["hours", "minutes", "seconds", "milliseconds"].indexOf(u) >= 0); + if (lowerOrderUnits.length === 0) { + if (highWater < later) { + highWater = cursor.plus({ [lowestOrder]: 1 }); + } + if (highWater !== cursor) { + results[lowestOrder] = (results[lowestOrder] || 0) + remainingMillis / (highWater - cursor); + } + } + const duration = Duration2.fromObject(results, opts); + if (lowerOrderUnits.length > 0) { + return Duration2.fromMillis(remainingMillis, opts).shiftTo(...lowerOrderUnits).plus(duration); + } else { + return duration; + } + } + var numberingSystems2 = { + arab: "[\u0660-\u0669]", + arabext: "[\u06F0-\u06F9]", + bali: "[\u1B50-\u1B59]", + beng: "[\u09E6-\u09EF]", + deva: "[\u0966-\u096F]", + fullwide: "[\uFF10-\uFF19]", + gujr: "[\u0AE6-\u0AEF]", + hanidec: "[\u3007|\u4E00|\u4E8C|\u4E09|\u56DB|\u4E94|\u516D|\u4E03|\u516B|\u4E5D]", + khmr: "[\u17E0-\u17E9]", + knda: "[\u0CE6-\u0CEF]", + laoo: "[\u0ED0-\u0ED9]", + limb: "[\u1946-\u194F]", + mlym: "[\u0D66-\u0D6F]", + mong: "[\u1810-\u1819]", + mymr: "[\u1040-\u1049]", + orya: "[\u0B66-\u0B6F]", + tamldec: "[\u0BE6-\u0BEF]", + telu: "[\u0C66-\u0C6F]", + thai: "[\u0E50-\u0E59]", + tibt: "[\u0F20-\u0F29]", + latn: "\\d" + }; + var numberingSystemsUTF162 = { + arab: [1632, 1641], + arabext: [1776, 1785], + bali: [6992, 7001], + beng: [2534, 2543], + deva: [2406, 2415], + fullwide: [65296, 65303], + gujr: [2790, 2799], + khmr: [6112, 6121], + knda: [3302, 3311], + laoo: [3792, 3801], + limb: [6470, 6479], + mlym: [3430, 3439], + mong: [6160, 6169], + mymr: [4160, 4169], + orya: [2918, 2927], + tamldec: [3046, 3055], + telu: [3174, 3183], + thai: [3664, 3673], + tibt: [3872, 3881] + }; + var hanidecChars2 = numberingSystems2.hanidec.replace(/[\[|\]]/g, "").split(""); + function parseDigits2(str) { + let value = parseInt(str, 10); + if (isNaN(value)) { + value = ""; + for (let i = 0; i < str.length; i++) { + const code = str.charCodeAt(i); + if (str[i].search(numberingSystems2.hanidec) !== -1) { + value += hanidecChars2.indexOf(str[i]); + } else { + for (const key in numberingSystemsUTF162) { + const [min2, max2] = numberingSystemsUTF162[key]; + if (code >= min2 && code <= max2) { + value += code - min2; + } + } + } + } + return parseInt(value, 10); + } else { + return value; + } + } + function digitRegex2({ numberingSystem }, append = "") { + return new RegExp(`${numberingSystems2[numberingSystem || "latn"]}${append}`); + } + var MISSING_FTP2 = "missing Intl.DateTimeFormat.formatToParts support"; + function intUnit2(regex, post = (i) => i) { + return { regex, deser: ([s3]) => post(parseDigits2(s3)) }; + } + var NBSP2 = String.fromCharCode(160); + var spaceOrNBSP2 = `[ ${NBSP2}]`; + var spaceOrNBSPRegExp2 = new RegExp(spaceOrNBSP2, "g"); + function fixListRegex2(s3) { + return s3.replace(/\./g, "\\.?").replace(spaceOrNBSPRegExp2, spaceOrNBSP2); + } + function stripInsensitivities2(s3) { + return s3.replace(/\./g, "").replace(spaceOrNBSPRegExp2, " ").toLowerCase(); + } + function oneOf2(strings, startIndex) { + if (strings === null) { + return null; + } else { + return { + regex: RegExp(strings.map(fixListRegex2).join("|")), + deser: ([s3]) => strings.findIndex((i) => stripInsensitivities2(s3) === stripInsensitivities2(i)) + startIndex + }; + } + } + function offset3(regex, groups) { + return { regex, deser: ([, h, m]) => signedOffset2(h, m), groups }; + } + function simple2(regex) { + return { regex, deser: ([s3]) => s3 }; + } + function escapeToken2(value) { + return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"); + } + function unitForToken2(token, loc) { + const one = digitRegex2(loc), two = digitRegex2(loc, "{2}"), three = digitRegex2(loc, "{3}"), four = digitRegex2(loc, "{4}"), six = digitRegex2(loc, "{6}"), oneOrTwo = digitRegex2(loc, "{1,2}"), oneToThree = digitRegex2(loc, "{1,3}"), oneToSix = digitRegex2(loc, "{1,6}"), oneToNine = digitRegex2(loc, "{1,9}"), twoToFour = digitRegex2(loc, "{2,4}"), fourToSix = digitRegex2(loc, "{4,6}"), literal = (t) => ({ regex: RegExp(escapeToken2(t.val)), deser: ([s3]) => s3, literal: true }), unitate = (t) => { + if (token.literal) { + return literal(t); + } + switch (t.val) { + case "G": + return oneOf2(loc.eras("short", false), 0); + case "GG": + return oneOf2(loc.eras("long", false), 0); + case "y": + return intUnit2(oneToSix); + case "yy": + return intUnit2(twoToFour, untruncateYear2); + case "yyyy": + return intUnit2(four); + case "yyyyy": + return intUnit2(fourToSix); + case "yyyyyy": + return intUnit2(six); + case "M": + return intUnit2(oneOrTwo); + case "MM": + return intUnit2(two); + case "MMM": + return oneOf2(loc.months("short", true, false), 1); + case "MMMM": + return oneOf2(loc.months("long", true, false), 1); + case "L": + return intUnit2(oneOrTwo); + case "LL": + return intUnit2(two); + case "LLL": + return oneOf2(loc.months("short", false, false), 1); + case "LLLL": + return oneOf2(loc.months("long", false, false), 1); + case "d": + return intUnit2(oneOrTwo); + case "dd": + return intUnit2(two); + case "o": + return intUnit2(oneToThree); + case "ooo": + return intUnit2(three); + case "HH": + return intUnit2(two); + case "H": + return intUnit2(oneOrTwo); + case "hh": + return intUnit2(two); + case "h": + return intUnit2(oneOrTwo); + case "mm": + return intUnit2(two); + case "m": + return intUnit2(oneOrTwo); + case "q": + return intUnit2(oneOrTwo); + case "qq": + return intUnit2(two); + case "s": + return intUnit2(oneOrTwo); + case "ss": + return intUnit2(two); + case "S": + return intUnit2(oneToThree); + case "SSS": + return intUnit2(three); + case "u": + return simple2(oneToNine); + case "uu": + return simple2(oneOrTwo); + case "uuu": + return intUnit2(one); + case "a": + return oneOf2(loc.meridiems(), 0); + case "kkkk": + return intUnit2(four); + case "kk": + return intUnit2(twoToFour, untruncateYear2); + case "W": + return intUnit2(oneOrTwo); + case "WW": + return intUnit2(two); + case "E": + case "c": + return intUnit2(one); + case "EEE": + return oneOf2(loc.weekdays("short", false, false), 1); + case "EEEE": + return oneOf2(loc.weekdays("long", false, false), 1); + case "ccc": + return oneOf2(loc.weekdays("short", true, false), 1); + case "cccc": + return oneOf2(loc.weekdays("long", true, false), 1); + case "Z": + case "ZZ": + return offset3(new RegExp(`([+-]${oneOrTwo.source})(?::(${two.source}))?`), 2); + case "ZZZ": + return offset3(new RegExp(`([+-]${oneOrTwo.source})(${two.source})?`), 2); + case "z": + return simple2(/[a-z_+-/]{1,256}?/i); + default: + return literal(t); + } + }; + const unit = unitate(token) || { + invalidReason: MISSING_FTP2 + }; + unit.token = token; + return unit; + } + var partTypeStyleToTokenVal2 = { + year: { + "2-digit": "yy", + numeric: "yyyyy" + }, + month: { + numeric: "M", + "2-digit": "MM", + short: "MMM", + long: "MMMM" + }, + day: { + numeric: "d", + "2-digit": "dd" + }, + weekday: { + short: "EEE", + long: "EEEE" + }, + dayperiod: "a", + dayPeriod: "a", + hour: { + numeric: "h", + "2-digit": "hh" + }, + minute: { + numeric: "m", + "2-digit": "mm" + }, + second: { + numeric: "s", + "2-digit": "ss" + }, + timeZoneName: { + long: "ZZZZZ", + short: "ZZZ" + } + }; + function tokenForPart2(part, formatOpts) { + const { type, value } = part; + if (type === "literal") { + return { + literal: true, + val: value + }; + } + const style = formatOpts[type]; + let val = partTypeStyleToTokenVal2[type]; + if (typeof val === "object") { + val = val[style]; + } + if (val) { + return { + literal: false, + val + }; + } + return void 0; + } + function buildRegex2(units) { + const re = units.map((u) => u.regex).reduce((f, r) => `${f}(${r.source})`, ""); + return [`^${re}$`, units]; + } + function match2(input, regex, handlers) { + const matches = input.match(regex); + if (matches) { + const all = {}; + let matchIndex = 1; + for (const i in handlers) { + if (hasOwnProperty2(handlers, i)) { + const h = handlers[i], groups = h.groups ? h.groups + 1 : 1; + if (!h.literal && h.token) { + all[h.token.val[0]] = h.deser(matches.slice(matchIndex, matchIndex + groups)); + } + matchIndex += groups; + } + } + return [matches, all]; + } else { + return [matches, {}]; + } + } + function dateTimeFromMatches2(matches) { + const toField = (token) => { + switch (token) { + case "S": + return "millisecond"; + case "s": + return "second"; + case "m": + return "minute"; + case "h": + case "H": + return "hour"; + case "d": + return "day"; + case "o": + return "ordinal"; + case "L": + case "M": + return "month"; + case "y": + return "year"; + case "E": + case "c": + return "weekday"; + case "W": + return "weekNumber"; + case "k": + return "weekYear"; + case "q": + return "quarter"; + default: + return null; + } + }; + let zone = null; + let specificOffset; + if (!isUndefined2(matches.z)) { + zone = IANAZone2.create(matches.z); + } + if (!isUndefined2(matches.Z)) { + if (!zone) { + zone = new FixedOffsetZone2(matches.Z); + } + specificOffset = matches.Z; + } + if (!isUndefined2(matches.q)) { + matches.M = (matches.q - 1) * 3 + 1; + } + if (!isUndefined2(matches.h)) { + if (matches.h < 12 && matches.a === 1) { + matches.h += 12; + } else if (matches.h === 12 && matches.a === 0) { + matches.h = 0; + } + } + if (matches.G === 0 && matches.y) { + matches.y = -matches.y; + } + if (!isUndefined2(matches.u)) { + matches.S = parseMillis2(matches.u); + } + const vals = Object.keys(matches).reduce((r, k) => { + const f = toField(k); + if (f) { + r[f] = matches[k]; + } + return r; + }, {}); + return [vals, zone, specificOffset]; + } + var dummyDateTimeCache2 = null; + function getDummyDateTime2() { + if (!dummyDateTimeCache2) { + dummyDateTimeCache2 = DateTime2.fromMillis(1555555555555); + } + return dummyDateTimeCache2; + } + function maybeExpandMacroToken2(token, locale) { + if (token.literal) { + return token; + } + const formatOpts = Formatter2.macroTokenToFormatOpts(token.val); + const tokens = formatOptsToTokens2(formatOpts, locale); + if (tokens == null || tokens.includes(void 0)) { + return token; + } + return tokens; + } + function expandMacroTokens2(tokens, locale) { + return Array.prototype.concat(...tokens.map((t) => maybeExpandMacroToken2(t, locale))); + } + function explainFromTokens2(locale, input, format2) { + const tokens = expandMacroTokens2(Formatter2.parseFormat(format2), locale), units = tokens.map((t) => unitForToken2(t, locale)), disqualifyingUnit = units.find((t) => t.invalidReason); + if (disqualifyingUnit) { + return { input, tokens, invalidReason: disqualifyingUnit.invalidReason }; + } else { + const [regexString, handlers] = buildRegex2(units), regex = RegExp(regexString, "i"), [rawMatches, matches] = match2(input, regex, handlers), [result, zone, specificOffset] = matches ? dateTimeFromMatches2(matches) : [null, null, void 0]; + if (hasOwnProperty2(matches, "a") && hasOwnProperty2(matches, "H")) { + throw new ConflictingSpecificationError2("Can't include meridiem when specifying 24-hour format"); + } + return { input, tokens, regex, rawMatches, matches, result, zone, specificOffset }; + } + } + function parseFromTokens2(locale, input, format2) { + const { result, zone, specificOffset, invalidReason } = explainFromTokens2(locale, input, format2); + return [result, zone, specificOffset, invalidReason]; + } + function formatOptsToTokens2(formatOpts, locale) { + if (!formatOpts) { + return null; + } + const formatter = Formatter2.create(locale, formatOpts); + const parts = formatter.formatDateTimeParts(getDummyDateTime2()); + return parts.map((p) => tokenForPart2(p, formatOpts)); + } + var nonLeapLadder2 = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + var leapLadder2 = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]; + function unitOutOfRange2(unit, value) { + return new Invalid2("unit out of range", `you specified ${value} (of type ${typeof value}) as a ${unit}, which is invalid`); + } + function dayOfWeek2(year, month, day) { + const d = new Date(Date.UTC(year, month - 1, day)); + if (year < 100 && year >= 0) { + d.setUTCFullYear(d.getUTCFullYear() - 1900); + } + const js = d.getUTCDay(); + return js === 0 ? 7 : js; + } + function computeOrdinal2(year, month, day) { + return day + (isLeapYear2(year) ? leapLadder2 : nonLeapLadder2)[month - 1]; + } + function uncomputeOrdinal2(year, ordinal) { + const table = isLeapYear2(year) ? leapLadder2 : nonLeapLadder2, month0 = table.findIndex((i) => i < ordinal), day = ordinal - table[month0]; + return { month: month0 + 1, day }; + } + function gregorianToWeek2(gregObj) { + const { year, month, day } = gregObj, ordinal = computeOrdinal2(year, month, day), weekday = dayOfWeek2(year, month, day); + let weekNumber = Math.floor((ordinal - weekday + 10) / 7), weekYear; + if (weekNumber < 1) { + weekYear = year - 1; + weekNumber = weeksInWeekYear2(weekYear); + } else if (weekNumber > weeksInWeekYear2(year)) { + weekYear = year + 1; + weekNumber = 1; + } else { + weekYear = year; + } + return __spreadValues({ weekYear, weekNumber, weekday }, timeObject2(gregObj)); + } + function weekToGregorian2(weekData) { + const { weekYear, weekNumber, weekday } = weekData, weekdayOfJan4 = dayOfWeek2(weekYear, 1, 4), yearInDays = daysInYear2(weekYear); + let ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 3, year; + if (ordinal < 1) { + year = weekYear - 1; + ordinal += daysInYear2(year); + } else if (ordinal > yearInDays) { + year = weekYear + 1; + ordinal -= daysInYear2(weekYear); + } else { + year = weekYear; + } + const { month, day } = uncomputeOrdinal2(year, ordinal); + return __spreadValues({ year, month, day }, timeObject2(weekData)); + } + function gregorianToOrdinal2(gregData) { + const { year, month, day } = gregData; + const ordinal = computeOrdinal2(year, month, day); + return __spreadValues({ year, ordinal }, timeObject2(gregData)); + } + function ordinalToGregorian2(ordinalData) { + const { year, ordinal } = ordinalData; + const { month, day } = uncomputeOrdinal2(year, ordinal); + return __spreadValues({ year, month, day }, timeObject2(ordinalData)); + } + function hasInvalidWeekData2(obj) { + const validYear = isInteger2(obj.weekYear), validWeek = integerBetween2(obj.weekNumber, 1, weeksInWeekYear2(obj.weekYear)), validWeekday = integerBetween2(obj.weekday, 1, 7); + if (!validYear) { + return unitOutOfRange2("weekYear", obj.weekYear); + } else if (!validWeek) { + return unitOutOfRange2("week", obj.week); + } else if (!validWeekday) { + return unitOutOfRange2("weekday", obj.weekday); + } else + return false; + } + function hasInvalidOrdinalData2(obj) { + const validYear = isInteger2(obj.year), validOrdinal = integerBetween2(obj.ordinal, 1, daysInYear2(obj.year)); + if (!validYear) { + return unitOutOfRange2("year", obj.year); + } else if (!validOrdinal) { + return unitOutOfRange2("ordinal", obj.ordinal); + } else + return false; + } + function hasInvalidGregorianData2(obj) { + const validYear = isInteger2(obj.year), validMonth = integerBetween2(obj.month, 1, 12), validDay = integerBetween2(obj.day, 1, daysInMonth2(obj.year, obj.month)); + if (!validYear) { + return unitOutOfRange2("year", obj.year); + } else if (!validMonth) { + return unitOutOfRange2("month", obj.month); + } else if (!validDay) { + return unitOutOfRange2("day", obj.day); + } else + return false; + } + function hasInvalidTimeData2(obj) { + const { hour, minute, second, millisecond } = obj; + const validHour = integerBetween2(hour, 0, 23) || hour === 24 && minute === 0 && second === 0 && millisecond === 0, validMinute = integerBetween2(minute, 0, 59), validSecond = integerBetween2(second, 0, 59), validMillisecond = integerBetween2(millisecond, 0, 999); + if (!validHour) { + return unitOutOfRange2("hour", hour); + } else if (!validMinute) { + return unitOutOfRange2("minute", minute); + } else if (!validSecond) { + return unitOutOfRange2("second", second); + } else if (!validMillisecond) { + return unitOutOfRange2("millisecond", millisecond); + } else + return false; + } + var INVALID4 = "Invalid DateTime"; + var MAX_DATE2 = 864e13; + function unsupportedZone2(zone) { + return new Invalid2("unsupported zone", `the zone "${zone.name}" is not supported`); + } + function possiblyCachedWeekData2(dt) { + if (dt.weekData === null) { + dt.weekData = gregorianToWeek2(dt.c); + } + return dt.weekData; + } + function clone3(inst, alts) { + const current = { + ts: inst.ts, + zone: inst.zone, + c: inst.c, + o: inst.o, + loc: inst.loc, + invalid: inst.invalid + }; + return new DateTime2(__spreadProps(__spreadValues(__spreadValues({}, current), alts), { old: current })); + } + function fixOffset2(localTS, o, tz) { + let utcGuess = localTS - o * 60 * 1e3; + const o2 = tz.offset(utcGuess); + if (o === o2) { + return [utcGuess, o]; + } + utcGuess -= (o2 - o) * 60 * 1e3; + const o3 = tz.offset(utcGuess); + if (o2 === o3) { + return [utcGuess, o2]; + } + return [localTS - Math.min(o2, o3) * 60 * 1e3, Math.max(o2, o3)]; + } + function tsToObj2(ts, offset4) { + ts += offset4 * 60 * 1e3; + const d = new Date(ts); + return { + year: d.getUTCFullYear(), + month: d.getUTCMonth() + 1, + day: d.getUTCDate(), + hour: d.getUTCHours(), + minute: d.getUTCMinutes(), + second: d.getUTCSeconds(), + millisecond: d.getUTCMilliseconds() + }; + } + function objToTS2(obj, offset4, zone) { + return fixOffset2(objToLocalTS2(obj), offset4, zone); + } + function adjustTime2(inst, dur) { + const oPre = inst.o, year = inst.c.year + Math.trunc(dur.years), month = inst.c.month + Math.trunc(dur.months) + Math.trunc(dur.quarters) * 3, c = __spreadProps(__spreadValues({}, inst.c), { + year, + month, + day: Math.min(inst.c.day, daysInMonth2(year, month)) + Math.trunc(dur.days) + Math.trunc(dur.weeks) * 7 + }), millisToAdd = Duration2.fromObject({ + years: dur.years - Math.trunc(dur.years), + quarters: dur.quarters - Math.trunc(dur.quarters), + months: dur.months - Math.trunc(dur.months), + weeks: dur.weeks - Math.trunc(dur.weeks), + days: dur.days - Math.trunc(dur.days), + hours: dur.hours, + minutes: dur.minutes, + seconds: dur.seconds, + milliseconds: dur.milliseconds + }).as("milliseconds"), localTS = objToLocalTS2(c); + let [ts, o] = fixOffset2(localTS, oPre, inst.zone); + if (millisToAdd !== 0) { + ts += millisToAdd; + o = inst.zone.offset(ts); + } + return { ts, o }; + } + function parseDataToDateTime2(parsed, parsedZone, opts, format2, text, specificOffset) { + const { setZone, zone } = opts; + if (parsed && Object.keys(parsed).length !== 0) { + const interpretationZone = parsedZone || zone, inst = DateTime2.fromObject(parsed, __spreadProps(__spreadValues({}, opts), { + zone: interpretationZone, + specificOffset + })); + return setZone ? inst : inst.setZone(zone); + } else { + return DateTime2.invalid(new Invalid2("unparsable", `the input "${text}" can't be parsed as ${format2}`)); + } + } + function toTechFormat2(dt, format2, allowZ = true) { + return dt.isValid ? Formatter2.create(Locale2.create("en-US"), { + allowZ, + forceSimple: true + }).formatDateTimeFromString(dt, format2) : null; + } + function toISODate2(o, extended) { + const longFormat = o.c.year > 9999 || o.c.year < 0; + let c = ""; + if (longFormat && o.c.year >= 0) + c += "+"; + c += padStart2(o.c.year, longFormat ? 6 : 4); + if (extended) { + c += "-"; + c += padStart2(o.c.month); + c += "-"; + c += padStart2(o.c.day); + } else { + c += padStart2(o.c.month); + c += padStart2(o.c.day); + } + return c; + } + function toISOTime2(o, extended, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone) { + let c = padStart2(o.c.hour); + if (extended) { + c += ":"; + c += padStart2(o.c.minute); + if (o.c.second !== 0 || !suppressSeconds) { + c += ":"; + } + } else { + c += padStart2(o.c.minute); + } + if (o.c.second !== 0 || !suppressSeconds) { + c += padStart2(o.c.second); + if (o.c.millisecond !== 0 || !suppressMilliseconds) { + c += "."; + c += padStart2(o.c.millisecond, 3); + } + } + if (includeOffset) { + if (o.isOffsetFixed && o.offset === 0 && !extendedZone) { + c += "Z"; + } else if (o.o < 0) { + c += "-"; + c += padStart2(Math.trunc(-o.o / 60)); + c += ":"; + c += padStart2(Math.trunc(-o.o % 60)); + } else { + c += "+"; + c += padStart2(Math.trunc(o.o / 60)); + c += ":"; + c += padStart2(Math.trunc(o.o % 60)); + } + } + if (extendedZone) { + c += "[" + o.zone.ianaName + "]"; + } + return c; + } + var defaultUnitValues2 = { + month: 1, + day: 1, + hour: 0, + minute: 0, + second: 0, + millisecond: 0 + }; + var defaultWeekUnitValues2 = { + weekNumber: 1, + weekday: 1, + hour: 0, + minute: 0, + second: 0, + millisecond: 0 + }; + var defaultOrdinalUnitValues2 = { + ordinal: 1, + hour: 0, + minute: 0, + second: 0, + millisecond: 0 + }; + var orderedUnits3 = ["year", "month", "day", "hour", "minute", "second", "millisecond"]; + var orderedWeekUnits2 = [ + "weekYear", + "weekNumber", + "weekday", + "hour", + "minute", + "second", + "millisecond" + ]; + var orderedOrdinalUnits2 = ["year", "ordinal", "hour", "minute", "second", "millisecond"]; + function normalizeUnit2(unit) { + const normalized = { + year: "year", + years: "year", + month: "month", + months: "month", + day: "day", + days: "day", + hour: "hour", + hours: "hour", + minute: "minute", + minutes: "minute", + quarter: "quarter", + quarters: "quarter", + second: "second", + seconds: "second", + millisecond: "millisecond", + milliseconds: "millisecond", + weekday: "weekday", + weekdays: "weekday", + weeknumber: "weekNumber", + weeksnumber: "weekNumber", + weeknumbers: "weekNumber", + weekyear: "weekYear", + weekyears: "weekYear", + ordinal: "ordinal" + }[unit.toLowerCase()]; + if (!normalized) + throw new InvalidUnitError2(unit); + return normalized; + } + function quickDT2(obj, opts) { + const zone = normalizeZone2(opts.zone, Settings2.defaultZone), loc = Locale2.fromObject(opts), tsNow = Settings2.now(); + let ts, o; + if (!isUndefined2(obj.year)) { + for (const u of orderedUnits3) { + if (isUndefined2(obj[u])) { + obj[u] = defaultUnitValues2[u]; + } + } + const invalid = hasInvalidGregorianData2(obj) || hasInvalidTimeData2(obj); + if (invalid) { + return DateTime2.invalid(invalid); + } + const offsetProvis = zone.offset(tsNow); + [ts, o] = objToTS2(obj, offsetProvis, zone); + } else { + ts = tsNow; + } + return new DateTime2({ ts, zone, loc, o }); + } + function diffRelative2(start2, end2, opts) { + const round2 = isUndefined2(opts.round) ? true : opts.round, format2 = (c, unit) => { + c = roundTo2(c, round2 || opts.calendary ? 0 : 2, true); + const formatter = end2.loc.clone(opts).relFormatter(opts); + return formatter.format(c, unit); + }, differ = (unit) => { + if (opts.calendary) { + if (!end2.hasSame(start2, unit)) { + return end2.startOf(unit).diff(start2.startOf(unit), unit).get(unit); + } else + return 0; + } else { + return end2.diff(start2, unit).get(unit); + } + }; + if (opts.unit) { + return format2(differ(opts.unit), opts.unit); + } + for (const unit of opts.units) { + const count = differ(unit); + if (Math.abs(count) >= 1) { + return format2(count, unit); + } + } + return format2(start2 > end2 ? -0 : 0, opts.units[opts.units.length - 1]); + } + function lastOpts2(argList) { + let opts = {}, args; + if (argList.length > 0 && typeof argList[argList.length - 1] === "object") { + opts = argList[argList.length - 1]; + args = Array.from(argList).slice(0, argList.length - 1); + } else { + args = Array.from(argList); + } + return [opts, args]; + } + var DateTime2 = class { + constructor(config) { + const zone = config.zone || Settings2.defaultZone; + let invalid = config.invalid || (Number.isNaN(config.ts) ? new Invalid2("invalid input") : null) || (!zone.isValid ? unsupportedZone2(zone) : null); + this.ts = isUndefined2(config.ts) ? Settings2.now() : config.ts; + let c = null, o = null; + if (!invalid) { + const unchanged = config.old && config.old.ts === this.ts && config.old.zone.equals(zone); + if (unchanged) { + [c, o] = [config.old.c, config.old.o]; + } else { + const ot = zone.offset(this.ts); + c = tsToObj2(this.ts, ot); + invalid = Number.isNaN(c.year) ? new Invalid2("invalid input") : null; + c = invalid ? null : c; + o = invalid ? null : ot; + } + } + this._zone = zone; + this.loc = config.loc || Locale2.create(); + this.invalid = invalid; + this.weekData = null; + this.c = c; + this.o = o; + this.isLuxonDateTime = true; + } + static now() { + return new DateTime2({}); + } + static local() { + const [opts, args] = lastOpts2(arguments), [year, month, day, hour, minute, second, millisecond] = args; + return quickDT2({ year, month, day, hour, minute, second, millisecond }, opts); + } + static utc() { + const [opts, args] = lastOpts2(arguments), [year, month, day, hour, minute, second, millisecond] = args; + opts.zone = FixedOffsetZone2.utcInstance; + return quickDT2({ year, month, day, hour, minute, second, millisecond }, opts); + } + static fromJSDate(date, options = {}) { + const ts = isDate2(date) ? date.valueOf() : NaN; + if (Number.isNaN(ts)) { + return DateTime2.invalid("invalid input"); + } + const zoneToUse = normalizeZone2(options.zone, Settings2.defaultZone); + if (!zoneToUse.isValid) { + return DateTime2.invalid(unsupportedZone2(zoneToUse)); + } + return new DateTime2({ + ts, + zone: zoneToUse, + loc: Locale2.fromObject(options) + }); + } + static fromMillis(milliseconds, options = {}) { + if (!isNumber2(milliseconds)) { + throw new InvalidArgumentError2(`fromMillis requires a numerical input, but received a ${typeof milliseconds} with value ${milliseconds}`); + } else if (milliseconds < -MAX_DATE2 || milliseconds > MAX_DATE2) { + return DateTime2.invalid("Timestamp out of range"); + } else { + return new DateTime2({ + ts: milliseconds, + zone: normalizeZone2(options.zone, Settings2.defaultZone), + loc: Locale2.fromObject(options) + }); + } + } + static fromSeconds(seconds, options = {}) { + if (!isNumber2(seconds)) { + throw new InvalidArgumentError2("fromSeconds requires a numerical input"); + } else { + return new DateTime2({ + ts: seconds * 1e3, + zone: normalizeZone2(options.zone, Settings2.defaultZone), + loc: Locale2.fromObject(options) + }); + } + } + static fromObject(obj, opts = {}) { + obj = obj || {}; + const zoneToUse = normalizeZone2(opts.zone, Settings2.defaultZone); + if (!zoneToUse.isValid) { + return DateTime2.invalid(unsupportedZone2(zoneToUse)); + } + const tsNow = Settings2.now(), offsetProvis = !isUndefined2(opts.specificOffset) ? opts.specificOffset : zoneToUse.offset(tsNow), normalized = normalizeObject2(obj, normalizeUnit2), containsOrdinal = !isUndefined2(normalized.ordinal), containsGregorYear = !isUndefined2(normalized.year), containsGregorMD = !isUndefined2(normalized.month) || !isUndefined2(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber, loc = Locale2.fromObject(opts); + if ((containsGregor || containsOrdinal) && definiteWeekDef) { + throw new ConflictingSpecificationError2("Can't mix weekYear/weekNumber units with year/month/day or ordinals"); + } + if (containsGregorMD && containsOrdinal) { + throw new ConflictingSpecificationError2("Can't mix ordinal dates with month/day"); + } + const useWeekData = definiteWeekDef || normalized.weekday && !containsGregor; + let units, defaultValues, objNow = tsToObj2(tsNow, offsetProvis); + if (useWeekData) { + units = orderedWeekUnits2; + defaultValues = defaultWeekUnitValues2; + objNow = gregorianToWeek2(objNow); + } else if (containsOrdinal) { + units = orderedOrdinalUnits2; + defaultValues = defaultOrdinalUnitValues2; + objNow = gregorianToOrdinal2(objNow); + } else { + units = orderedUnits3; + defaultValues = defaultUnitValues2; + } + let foundFirst = false; + for (const u of units) { + const v = normalized[u]; + if (!isUndefined2(v)) { + foundFirst = true; + } else if (foundFirst) { + normalized[u] = defaultValues[u]; + } else { + normalized[u] = objNow[u]; + } + } + const higherOrderInvalid = useWeekData ? hasInvalidWeekData2(normalized) : containsOrdinal ? hasInvalidOrdinalData2(normalized) : hasInvalidGregorianData2(normalized), invalid = higherOrderInvalid || hasInvalidTimeData2(normalized); + if (invalid) { + return DateTime2.invalid(invalid); + } + const gregorian = useWeekData ? weekToGregorian2(normalized) : containsOrdinal ? ordinalToGregorian2(normalized) : normalized, [tsFinal, offsetFinal] = objToTS2(gregorian, offsetProvis, zoneToUse), inst = new DateTime2({ + ts: tsFinal, + zone: zoneToUse, + o: offsetFinal, + loc + }); + if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) { + return DateTime2.invalid("mismatched weekday", `you can't specify both a weekday of ${normalized.weekday} and a date of ${inst.toISO()}`); + } + return inst; + } + static fromISO(text, opts = {}) { + const [vals, parsedZone] = parseISODate2(text); + return parseDataToDateTime2(vals, parsedZone, opts, "ISO 8601", text); + } + static fromRFC2822(text, opts = {}) { + const [vals, parsedZone] = parseRFC2822Date2(text); + return parseDataToDateTime2(vals, parsedZone, opts, "RFC 2822", text); + } + static fromHTTP(text, opts = {}) { + const [vals, parsedZone] = parseHTTPDate2(text); + return parseDataToDateTime2(vals, parsedZone, opts, "HTTP", opts); + } + static fromFormat(text, fmt, opts = {}) { + if (isUndefined2(text) || isUndefined2(fmt)) { + throw new InvalidArgumentError2("fromFormat requires an input string and a format"); + } + const { locale = null, numberingSystem = null } = opts, localeToUse = Locale2.fromOpts({ + locale, + numberingSystem, + defaultToEN: true + }), [vals, parsedZone, specificOffset, invalid] = parseFromTokens2(localeToUse, text, fmt); + if (invalid) { + return DateTime2.invalid(invalid); + } else { + return parseDataToDateTime2(vals, parsedZone, opts, `format ${fmt}`, text, specificOffset); + } + } + static fromString(text, fmt, opts = {}) { + return DateTime2.fromFormat(text, fmt, opts); + } + static fromSQL(text, opts = {}) { + const [vals, parsedZone] = parseSQL2(text); + return parseDataToDateTime2(vals, parsedZone, opts, "SQL", text); + } + static invalid(reason, explanation = null) { + if (!reason) { + throw new InvalidArgumentError2("need to specify a reason the DateTime is invalid"); + } + const invalid = reason instanceof Invalid2 ? reason : new Invalid2(reason, explanation); + if (Settings2.throwOnInvalid) { + throw new InvalidDateTimeError2(invalid); + } else { + return new DateTime2({ invalid }); + } + } + static isDateTime(o) { + return o && o.isLuxonDateTime || false; + } + static parseFormatForOpts(formatOpts, localeOpts = {}) { + const tokenList = formatOptsToTokens2(formatOpts, Locale2.fromObject(localeOpts)); + return !tokenList ? null : tokenList.map((t) => t ? t.val : null).join(""); + } + static expandFormat(fmt, localeOpts = {}) { + const expanded = expandMacroTokens2(Formatter2.parseFormat(fmt), Locale2.fromObject(localeOpts)); + return expanded.map((t) => t.val).join(""); + } + get(unit) { + return this[unit]; + } + get isValid() { + return this.invalid === null; + } + get invalidReason() { + return this.invalid ? this.invalid.reason : null; + } + get invalidExplanation() { + return this.invalid ? this.invalid.explanation : null; + } + get locale() { + return this.isValid ? this.loc.locale : null; + } + get numberingSystem() { + return this.isValid ? this.loc.numberingSystem : null; + } + get outputCalendar() { + return this.isValid ? this.loc.outputCalendar : null; + } + get zone() { + return this._zone; + } + get zoneName() { + return this.isValid ? this.zone.name : null; + } + get year() { + return this.isValid ? this.c.year : NaN; + } + get quarter() { + return this.isValid ? Math.ceil(this.c.month / 3) : NaN; + } + get month() { + return this.isValid ? this.c.month : NaN; + } + get day() { + return this.isValid ? this.c.day : NaN; + } + get hour() { + return this.isValid ? this.c.hour : NaN; + } + get minute() { + return this.isValid ? this.c.minute : NaN; + } + get second() { + return this.isValid ? this.c.second : NaN; + } + get millisecond() { + return this.isValid ? this.c.millisecond : NaN; + } + get weekYear() { + return this.isValid ? possiblyCachedWeekData2(this).weekYear : NaN; + } + get weekNumber() { + return this.isValid ? possiblyCachedWeekData2(this).weekNumber : NaN; + } + get weekday() { + return this.isValid ? possiblyCachedWeekData2(this).weekday : NaN; + } + get ordinal() { + return this.isValid ? gregorianToOrdinal2(this.c).ordinal : NaN; + } + get monthShort() { + return this.isValid ? Info2.months("short", { locObj: this.loc })[this.month - 1] : null; + } + get monthLong() { + return this.isValid ? Info2.months("long", { locObj: this.loc })[this.month - 1] : null; + } + get weekdayShort() { + return this.isValid ? Info2.weekdays("short", { locObj: this.loc })[this.weekday - 1] : null; + } + get weekdayLong() { + return this.isValid ? Info2.weekdays("long", { locObj: this.loc })[this.weekday - 1] : null; + } + get offset() { + return this.isValid ? +this.o : NaN; + } + get offsetNameShort() { + if (this.isValid) { + return this.zone.offsetName(this.ts, { + format: "short", + locale: this.locale + }); + } else { + return null; + } + } + get offsetNameLong() { + if (this.isValid) { + return this.zone.offsetName(this.ts, { + format: "long", + locale: this.locale + }); + } else { + return null; + } + } + get isOffsetFixed() { + return this.isValid ? this.zone.isUniversal : null; + } + get isInDST() { + if (this.isOffsetFixed) { + return false; + } else { + return this.offset > this.set({ month: 1, day: 1 }).offset || this.offset > this.set({ month: 5 }).offset; + } + } + get isInLeapYear() { + return isLeapYear2(this.year); + } + get daysInMonth() { + return daysInMonth2(this.year, this.month); + } + get daysInYear() { + return this.isValid ? daysInYear2(this.year) : NaN; + } + get weeksInWeekYear() { + return this.isValid ? weeksInWeekYear2(this.weekYear) : NaN; + } + resolvedLocaleOptions(opts = {}) { + const { locale, numberingSystem, calendar } = Formatter2.create(this.loc.clone(opts), opts).resolvedOptions(this); + return { locale, numberingSystem, outputCalendar: calendar }; + } + toUTC(offset4 = 0, opts = {}) { + return this.setZone(FixedOffsetZone2.instance(offset4), opts); + } + toLocal() { + return this.setZone(Settings2.defaultZone); + } + setZone(zone, { keepLocalTime = false, keepCalendarTime = false } = {}) { + zone = normalizeZone2(zone, Settings2.defaultZone); + if (zone.equals(this.zone)) { + return this; + } else if (!zone.isValid) { + return DateTime2.invalid(unsupportedZone2(zone)); + } else { + let newTS = this.ts; + if (keepLocalTime || keepCalendarTime) { + const offsetGuess = zone.offset(this.ts); + const asObj = this.toObject(); + [newTS] = objToTS2(asObj, offsetGuess, zone); + } + return clone3(this, { ts: newTS, zone }); + } + } + reconfigure({ locale, numberingSystem, outputCalendar } = {}) { + const loc = this.loc.clone({ locale, numberingSystem, outputCalendar }); + return clone3(this, { loc }); + } + setLocale(locale) { + return this.reconfigure({ locale }); + } + set(values) { + if (!this.isValid) + return this; + const normalized = normalizeObject2(values, normalizeUnit2), settingWeekStuff = !isUndefined2(normalized.weekYear) || !isUndefined2(normalized.weekNumber) || !isUndefined2(normalized.weekday), containsOrdinal = !isUndefined2(normalized.ordinal), containsGregorYear = !isUndefined2(normalized.year), containsGregorMD = !isUndefined2(normalized.month) || !isUndefined2(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber; + if ((containsGregor || containsOrdinal) && definiteWeekDef) { + throw new ConflictingSpecificationError2("Can't mix weekYear/weekNumber units with year/month/day or ordinals"); + } + if (containsGregorMD && containsOrdinal) { + throw new ConflictingSpecificationError2("Can't mix ordinal dates with month/day"); + } + let mixed; + if (settingWeekStuff) { + mixed = weekToGregorian2(__spreadValues(__spreadValues({}, gregorianToWeek2(this.c)), normalized)); + } else if (!isUndefined2(normalized.ordinal)) { + mixed = ordinalToGregorian2(__spreadValues(__spreadValues({}, gregorianToOrdinal2(this.c)), normalized)); + } else { + mixed = __spreadValues(__spreadValues({}, this.toObject()), normalized); + if (isUndefined2(normalized.day)) { + mixed.day = Math.min(daysInMonth2(mixed.year, mixed.month), mixed.day); + } + } + const [ts, o] = objToTS2(mixed, this.o, this.zone); + return clone3(this, { ts, o }); + } + plus(duration) { + if (!this.isValid) + return this; + const dur = Duration2.fromDurationLike(duration); + return clone3(this, adjustTime2(this, dur)); + } + minus(duration) { + if (!this.isValid) + return this; + const dur = Duration2.fromDurationLike(duration).negate(); + return clone3(this, adjustTime2(this, dur)); + } + startOf(unit) { + if (!this.isValid) + return this; + const o = {}, normalizedUnit = Duration2.normalizeUnit(unit); + switch (normalizedUnit) { + case "years": + o.month = 1; + case "quarters": + case "months": + o.day = 1; + case "weeks": + case "days": + o.hour = 0; + case "hours": + o.minute = 0; + case "minutes": + o.second = 0; + case "seconds": + o.millisecond = 0; + break; + } + if (normalizedUnit === "weeks") { + o.weekday = 1; + } + if (normalizedUnit === "quarters") { + const q = Math.ceil(this.month / 3); + o.month = (q - 1) * 3 + 1; + } + return this.set(o); + } + endOf(unit) { + return this.isValid ? this.plus({ [unit]: 1 }).startOf(unit).minus(1) : this; + } + toFormat(fmt, opts = {}) { + return this.isValid ? Formatter2.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID4; + } + toLocaleString(formatOpts = DATE_SHORT2, opts = {}) { + return this.isValid ? Formatter2.create(this.loc.clone(opts), formatOpts).formatDateTime(this) : INVALID4; + } + toLocaleParts(opts = {}) { + return this.isValid ? Formatter2.create(this.loc.clone(opts), opts).formatDateTimeParts(this) : []; + } + toISO({ + format: format2 = "extended", + suppressSeconds = false, + suppressMilliseconds = false, + includeOffset = true, + extendedZone = false + } = {}) { + if (!this.isValid) { + return null; + } + const ext = format2 === "extended"; + let c = toISODate2(this, ext); + c += "T"; + c += toISOTime2(this, ext, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone); + return c; + } + toISODate({ format: format2 = "extended" } = {}) { + if (!this.isValid) { + return null; + } + return toISODate2(this, format2 === "extended"); + } + toISOWeekDate() { + return toTechFormat2(this, "kkkk-'W'WW-c"); + } + toISOTime({ + suppressMilliseconds = false, + suppressSeconds = false, + includeOffset = true, + includePrefix = false, + extendedZone = false, + format: format2 = "extended" + } = {}) { + if (!this.isValid) { + return null; + } + let c = includePrefix ? "T" : ""; + return c + toISOTime2(this, format2 === "extended", suppressSeconds, suppressMilliseconds, includeOffset, extendedZone); + } + toRFC2822() { + return toTechFormat2(this, "EEE, dd LLL yyyy HH:mm:ss ZZZ", false); + } + toHTTP() { + return toTechFormat2(this.toUTC(), "EEE, dd LLL yyyy HH:mm:ss 'GMT'"); + } + toSQLDate() { + if (!this.isValid) { + return null; + } + return toISODate2(this, true); + } + toSQLTime({ includeOffset = true, includeZone = false, includeOffsetSpace = true } = {}) { + let fmt = "HH:mm:ss.SSS"; + if (includeZone || includeOffset) { + if (includeOffsetSpace) { + fmt += " "; + } + if (includeZone) { + fmt += "z"; + } else if (includeOffset) { + fmt += "ZZ"; + } + } + return toTechFormat2(this, fmt, true); + } + toSQL(opts = {}) { + if (!this.isValid) { + return null; + } + return `${this.toSQLDate()} ${this.toSQLTime(opts)}`; + } + toString() { + return this.isValid ? this.toISO() : INVALID4; + } + valueOf() { + return this.toMillis(); + } + toMillis() { + return this.isValid ? this.ts : NaN; + } + toSeconds() { + return this.isValid ? this.ts / 1e3 : NaN; + } + toUnixInteger() { + return this.isValid ? Math.floor(this.ts / 1e3) : NaN; + } + toJSON() { + return this.toISO(); + } + toBSON() { + return this.toJSDate(); + } + toObject(opts = {}) { + if (!this.isValid) + return {}; + const base = __spreadValues({}, this.c); + if (opts.includeConfig) { + base.outputCalendar = this.outputCalendar; + base.numberingSystem = this.loc.numberingSystem; + base.locale = this.loc.locale; + } + return base; + } + toJSDate() { + return new Date(this.isValid ? this.ts : NaN); + } + diff(otherDateTime, unit = "milliseconds", opts = {}) { + if (!this.isValid || !otherDateTime.isValid) { + return Duration2.invalid("created by diffing an invalid DateTime"); + } + const durOpts = __spreadValues({ locale: this.locale, numberingSystem: this.numberingSystem }, opts); + const units = maybeArray2(unit).map(Duration2.normalizeUnit), otherIsLater = otherDateTime.valueOf() > this.valueOf(), earlier = otherIsLater ? this : otherDateTime, later = otherIsLater ? otherDateTime : this, diffed = diff(earlier, later, units, durOpts); + return otherIsLater ? diffed.negate() : diffed; + } + diffNow(unit = "milliseconds", opts = {}) { + return this.diff(DateTime2.now(), unit, opts); + } + until(otherDateTime) { + return this.isValid ? Interval2.fromDateTimes(this, otherDateTime) : this; + } + hasSame(otherDateTime, unit) { + if (!this.isValid) + return false; + const inputMs = otherDateTime.valueOf(); + const adjustedToZone = this.setZone(otherDateTime.zone, { keepLocalTime: true }); + return adjustedToZone.startOf(unit) <= inputMs && inputMs <= adjustedToZone.endOf(unit); + } + equals(other) { + return this.isValid && other.isValid && this.valueOf() === other.valueOf() && this.zone.equals(other.zone) && this.loc.equals(other.loc); + } + toRelative(options = {}) { + if (!this.isValid) + return null; + const base = options.base || DateTime2.fromObject({}, { zone: this.zone }), padding = options.padding ? this < base ? -options.padding : options.padding : 0; + let units = ["years", "months", "days", "hours", "minutes", "seconds"]; + let unit = options.unit; + if (Array.isArray(options.unit)) { + units = options.unit; + unit = void 0; + } + return diffRelative2(base, this.plus(padding), __spreadProps(__spreadValues({}, options), { + numeric: "always", + units, + unit + })); + } + toRelativeCalendar(options = {}) { + if (!this.isValid) + return null; + return diffRelative2(options.base || DateTime2.fromObject({}, { zone: this.zone }), this, __spreadProps(__spreadValues({}, options), { + numeric: "auto", + units: ["years", "months", "days"], + calendary: true + })); + } + static min(...dateTimes) { + if (!dateTimes.every(DateTime2.isDateTime)) { + throw new InvalidArgumentError2("min requires all arguments be DateTimes"); + } + return bestBy2(dateTimes, (i) => i.valueOf(), Math.min); + } + static max(...dateTimes) { + if (!dateTimes.every(DateTime2.isDateTime)) { + throw new InvalidArgumentError2("max requires all arguments be DateTimes"); + } + return bestBy2(dateTimes, (i) => i.valueOf(), Math.max); + } + static fromFormatExplain(text, fmt, options = {}) { + const { locale = null, numberingSystem = null } = options, localeToUse = Locale2.fromOpts({ + locale, + numberingSystem, + defaultToEN: true + }); + return explainFromTokens2(localeToUse, text, fmt); + } + static fromStringExplain(text, fmt, options = {}) { + return DateTime2.fromFormatExplain(text, fmt, options); + } + static get DATE_SHORT() { + return DATE_SHORT2; + } + static get DATE_MED() { + return DATE_MED2; + } + static get DATE_MED_WITH_WEEKDAY() { + return DATE_MED_WITH_WEEKDAY2; + } + static get DATE_FULL() { + return DATE_FULL2; + } + static get DATE_HUGE() { + return DATE_HUGE2; + } + static get TIME_SIMPLE() { + return TIME_SIMPLE2; + } + static get TIME_WITH_SECONDS() { + return TIME_WITH_SECONDS2; + } + static get TIME_WITH_SHORT_OFFSET() { + return TIME_WITH_SHORT_OFFSET2; + } + static get TIME_WITH_LONG_OFFSET() { + return TIME_WITH_LONG_OFFSET2; + } + static get TIME_24_SIMPLE() { + return TIME_24_SIMPLE2; + } + static get TIME_24_WITH_SECONDS() { + return TIME_24_WITH_SECONDS2; + } + static get TIME_24_WITH_SHORT_OFFSET() { + return TIME_24_WITH_SHORT_OFFSET2; + } + static get TIME_24_WITH_LONG_OFFSET() { + return TIME_24_WITH_LONG_OFFSET2; + } + static get DATETIME_SHORT() { + return DATETIME_SHORT2; + } + static get DATETIME_SHORT_WITH_SECONDS() { + return DATETIME_SHORT_WITH_SECONDS2; + } + static get DATETIME_MED() { + return DATETIME_MED2; + } + static get DATETIME_MED_WITH_SECONDS() { + return DATETIME_MED_WITH_SECONDS2; + } + static get DATETIME_MED_WITH_WEEKDAY() { + return DATETIME_MED_WITH_WEEKDAY2; + } + static get DATETIME_FULL() { + return DATETIME_FULL2; + } + static get DATETIME_FULL_WITH_SECONDS() { + return DATETIME_FULL_WITH_SECONDS2; + } + static get DATETIME_HUGE() { + return DATETIME_HUGE2; + } + static get DATETIME_HUGE_WITH_SECONDS() { + return DATETIME_HUGE_WITH_SECONDS2; + } + }; + function friendlyDateTime2(dateTimeish) { + if (DateTime2.isDateTime(dateTimeish)) { + return dateTimeish; + } else if (dateTimeish && dateTimeish.valueOf && isNumber2(dateTimeish.valueOf())) { + return DateTime2.fromJSDate(dateTimeish); + } else if (dateTimeish && typeof dateTimeish === "object") { + return DateTime2.fromObject(dateTimeish); + } else { + throw new InvalidArgumentError2(`Unknown datetime argument: ${dateTimeish}, of type ${typeof dateTimeish}`); + } + } + var DEFAULT_QUERY_SETTINGS = { + renderNullAs: "\\-", + taskCompletionTracking: false, + taskCompletionUseEmojiShorthand: false, + taskCompletionText: "completion", + taskCompletionDateFormat: "yyyy-MM-dd", + recursiveSubTaskCompletion: false, + warnOnEmptyResult: true, + refreshEnabled: true, + refreshInterval: 2500, + defaultDateFormat: "MMMM dd, yyyy", + defaultDateTimeFormat: "h:mm a - MMMM dd, yyyy", + maxRecursiveRenderDepth: 4, + tableIdColumnName: "File", + tableGroupColumnName: "Group", + showResultCount: true + }; + var DEFAULT_EXPORT_SETTINGS = { + allowHtml: true + }; + __spreadValues(__spreadValues(__spreadValues({}, DEFAULT_QUERY_SETTINGS), DEFAULT_EXPORT_SETTINGS), { + inlineQueryPrefix: "=", + inlineJsQueryPrefix: "$=", + inlineQueriesInCodeblocks: true, + enableInlineDataview: true, + enableDataviewJs: false, + enableInlineDataviewJs: false, + prettyRenderInlineFields: true, + dataviewJsKeyword: "dataviewjs" + }); + var Success = class { + constructor(value) { + this.value = value; + this.successful = true; + } + map(f) { + return new Success(f(this.value)); + } + flatMap(f) { + return f(this.value); + } + mapErr(f) { + return this; + } + bimap(succ, _fail) { + return this.map(succ); + } + orElse(_value) { + return this.value; + } + cast() { + return this; + } + orElseThrow(_message) { + return this.value; + } + }; + var Failure = class { + constructor(error) { + this.error = error; + this.successful = false; + } + map(_f) { + return this; + } + flatMap(_f) { + return this; + } + mapErr(f) { + return new Failure(f(this.error)); + } + bimap(_succ, fail) { + return this.mapErr(fail); + } + orElse(value) { + return value; + } + cast() { + return this; + } + orElseThrow(message) { + if (message) + throw new Error(message(this.error)); + else + throw new Error("" + this.error); + } + }; + var Result; + (function(Result2) { + function success(value) { + return new Success(value); + } + Result2.success = success; + function failure(error) { + return new Failure(error); + } + Result2.failure = failure; + function flatMap2(first, second, f) { + if (first.successful) { + if (second.successful) + return f(first.value, second.value); + else + return failure(second.error); + } else { + return failure(first.error); + } + } + Result2.flatMap2 = flatMap2; + function map2(first, second, f) { + return flatMap2(first, second, (a, b) => success(f(a, b))); + } + Result2.map2 = map2; + })(Result || (Result = {})); + var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {}; + var parsimmon_umd_min = { exports: {} }; + (function(module3, exports2) { + !function(n3, t) { + module3.exports = t(); + }(typeof self != "undefined" ? self : commonjsGlobal, function() { + return function(n3) { + var t = {}; + function r(e) { + if (t[e]) + return t[e].exports; + var u = t[e] = { i: e, l: false, exports: {} }; + return n3[e].call(u.exports, u, u.exports, r), u.l = true, u.exports; + } + return r.m = n3, r.c = t, r.d = function(n4, t2, e) { + r.o(n4, t2) || Object.defineProperty(n4, t2, { configurable: false, enumerable: true, get: e }); + }, r.r = function(n4) { + Object.defineProperty(n4, "__esModule", { value: true }); + }, r.n = function(n4) { + var t2 = n4 && n4.__esModule ? function() { + return n4.default; + } : function() { + return n4; + }; + return r.d(t2, "a", t2), t2; + }, r.o = function(n4, t2) { + return Object.prototype.hasOwnProperty.call(n4, t2); + }, r.p = "", r(r.s = 0); + }([function(n3, t, r) { + function e(n4) { + if (!(this instanceof e)) + return new e(n4); + this._ = n4; + } + var u = e.prototype; + function o(n4, t2) { + for (var r2 = 0; r2 < n4; r2++) + t2(r2); + } + function i(n4, t2, r2) { + return function(n5, t3) { + o(t3.length, function(r3) { + n5(t3[r3], r3, t3); + }); + }(function(r3, e2, u2) { + t2 = n4(t2, r3, e2, u2); + }, r2), t2; + } + function a(n4, t2) { + return i(function(t3, r2, e2, u2) { + return t3.concat([n4(r2, e2, u2)]); + }, [], t2); + } + function f(n4, t2) { + var r2 = { v: 0, buf: t2 }; + return o(n4, function() { + var n5; + r2 = { v: r2.v << 1 | (n5 = r2.buf, n5[0] >> 7), buf: function(n6) { + var t3 = i(function(n7, t4, r3, e2) { + return n7.concat(r3 === e2.length - 1 ? Buffer.from([t4, 0]).readUInt16BE(0) : e2.readUInt16BE(r3)); + }, [], n6); + return Buffer.from(a(function(n7) { + return (n7 << 1 & 65535) >> 8; + }, t3)); + }(r2.buf) }; + }), r2; + } + function c() { + return typeof Buffer != "undefined"; + } + function s3() { + if (!c()) + throw new Error("Buffer global does not exist; please use webpack if you need to parse Buffers in the browser."); + } + function l3(n4) { + s3(); + var t2 = i(function(n5, t3) { + return n5 + t3; + }, 0, n4); + if (t2 % 8 != 0) + throw new Error("The bits [" + n4.join(", ") + "] add up to " + t2 + " which is not an even number of bytes; the total should be divisible by 8"); + var r2, u2 = t2 / 8, o2 = (r2 = function(n5) { + return n5 > 48; + }, i(function(n5, t3) { + return n5 || (r2(t3) ? t3 : n5); + }, null, n4)); + if (o2) + throw new Error(o2 + " bit range requested exceeds 48 bit (6 byte) Number max."); + return new e(function(t3, r3) { + var e2 = u2 + r3; + return e2 > t3.length ? x(r3, u2.toString() + " bytes") : b(e2, i(function(n5, t4) { + var r4 = f(t4, n5.buf); + return { coll: n5.coll.concat(r4.v), buf: r4.buf }; + }, { coll: [], buf: t3.slice(r3, e2) }, n4).coll); + }); + } + function h(n4, t2) { + return new e(function(r2, e2) { + return s3(), e2 + t2 > r2.length ? x(e2, t2 + " bytes for " + n4) : b(e2 + t2, r2.slice(e2, e2 + t2)); + }); + } + function p(n4, t2) { + if (typeof (r2 = t2) != "number" || Math.floor(r2) !== r2 || t2 < 0 || t2 > 6) + throw new Error(n4 + " requires integer length in range [0, 6]."); + var r2; + } + function d(n4) { + return p("uintBE", n4), h("uintBE(" + n4 + ")", n4).map(function(t2) { + return t2.readUIntBE(0, n4); + }); + } + function v(n4) { + return p("uintLE", n4), h("uintLE(" + n4 + ")", n4).map(function(t2) { + return t2.readUIntLE(0, n4); + }); + } + function g(n4) { + return p("intBE", n4), h("intBE(" + n4 + ")", n4).map(function(t2) { + return t2.readIntBE(0, n4); + }); + } + function m(n4) { + return p("intLE", n4), h("intLE(" + n4 + ")", n4).map(function(t2) { + return t2.readIntLE(0, n4); + }); + } + function y(n4) { + return n4 instanceof e; + } + function E(n4) { + return {}.toString.call(n4) === "[object Array]"; + } + function w(n4) { + return c() && Buffer.isBuffer(n4); + } + function b(n4, t2) { + return { status: true, index: n4, value: t2, furthest: -1, expected: [] }; + } + function x(n4, t2) { + return E(t2) || (t2 = [t2]), { status: false, index: -1, value: null, furthest: n4, expected: t2 }; + } + function B(n4, t2) { + if (!t2) + return n4; + if (n4.furthest > t2.furthest) + return n4; + var r2 = n4.furthest === t2.furthest ? function(n5, t3) { + if (function() { + if (e._supportsSet !== void 0) + return e._supportsSet; + var n6 = typeof Set != "undefined"; + return e._supportsSet = n6, n6; + }() && Array.from) { + for (var r3 = new Set(n5), u2 = 0; u2 < t3.length; u2++) + r3.add(t3[u2]); + var o2 = Array.from(r3); + return o2.sort(), o2; + } + for (var i2 = {}, a2 = 0; a2 < n5.length; a2++) + i2[n5[a2]] = true; + for (var f2 = 0; f2 < t3.length; f2++) + i2[t3[f2]] = true; + var c2 = []; + for (var s4 in i2) + ({}).hasOwnProperty.call(i2, s4) && c2.push(s4); + return c2.sort(), c2; + }(n4.expected, t2.expected) : t2.expected; + return { status: n4.status, index: n4.index, value: n4.value, furthest: t2.furthest, expected: r2 }; + } + var j = {}; + function S(n4, t2) { + if (w(n4)) + return { offset: t2, line: -1, column: -1 }; + n4 in j || (j[n4] = {}); + for (var r2 = j[n4], e2 = 0, u2 = 0, o2 = 0, i2 = t2; i2 >= 0; ) { + if (i2 in r2) { + e2 = r2[i2].line, o2 === 0 && (o2 = r2[i2].lineStart); + break; + } + (n4.charAt(i2) === "\n" || n4.charAt(i2) === "\r" && n4.charAt(i2 + 1) !== "\n") && (u2++, o2 === 0 && (o2 = i2 + 1)), i2--; + } + var a2 = e2 + u2, f2 = t2 - o2; + return r2[t2] = { line: a2, lineStart: o2 }, { offset: t2, line: a2 + 1, column: f2 + 1 }; + } + function _(n4) { + if (!y(n4)) + throw new Error("not a parser: " + n4); + } + function L(n4, t2) { + return typeof n4 == "string" ? n4.charAt(t2) : n4[t2]; + } + function O(n4) { + if (typeof n4 != "number") + throw new Error("not a number: " + n4); + } + function k(n4) { + if (typeof n4 != "function") + throw new Error("not a function: " + n4); + } + function P(n4) { + if (typeof n4 != "string") + throw new Error("not a string: " + n4); + } + var q = 2, A = 3, I = 8, F = 5 * I, M = 4 * I, z = " "; + function R(n4, t2) { + return new Array(t2 + 1).join(n4); + } + function U(n4, t2, r2) { + var e2 = t2 - n4.length; + return e2 <= 0 ? n4 : R(r2, e2) + n4; + } + function W(n4, t2, r2, e2) { + return { from: n4 - t2 > 0 ? n4 - t2 : 0, to: n4 + r2 > e2 ? e2 : n4 + r2 }; + } + function D(n4, t2) { + var r2, e2, u2, o2, f2, c2 = t2.index, s4 = c2.offset, l4 = 1; + if (s4 === n4.length) + return "Got the end of the input"; + if (w(n4)) { + var h2 = s4 - s4 % I, p2 = s4 - h2, d2 = W(h2, F, M + I, n4.length), v2 = a(function(n5) { + return a(function(n6) { + return U(n6.toString(16), 2, "0"); + }, n5); + }, function(n5, t3) { + var r3 = n5.length, e3 = [], u3 = 0; + if (r3 <= t3) + return [n5.slice()]; + for (var o3 = 0; o3 < r3; o3++) + e3[u3] || e3.push([]), e3[u3].push(n5[o3]), (o3 + 1) % t3 == 0 && u3++; + return e3; + }(n4.slice(d2.from, d2.to).toJSON().data, I)); + o2 = function(n5) { + return n5.from === 0 && n5.to === 1 ? { from: n5.from, to: n5.to } : { from: n5.from / I, to: Math.floor(n5.to / I) }; + }(d2), e2 = h2 / I, r2 = 3 * p2, p2 >= 4 && (r2 += 1), l4 = 2, u2 = a(function(n5) { + return n5.length <= 4 ? n5.join(" ") : n5.slice(0, 4).join(" ") + " " + n5.slice(4).join(" "); + }, v2), (f2 = (8 * (o2.to > 0 ? o2.to - 1 : o2.to)).toString(16).length) < 2 && (f2 = 2); + } else { + var g2 = n4.split(/\r\n|[\n\r\u2028\u2029]/); + r2 = c2.column - 1, e2 = c2.line - 1, o2 = W(e2, q, A, g2.length), u2 = g2.slice(o2.from, o2.to), f2 = o2.to.toString().length; + } + var m2 = e2 - o2.from; + return w(n4) && (f2 = (8 * (o2.to > 0 ? o2.to - 1 : o2.to)).toString(16).length) < 2 && (f2 = 2), i(function(t3, e3, u3) { + var i2, a2 = u3 === m2, c3 = a2 ? "> " : z; + return i2 = w(n4) ? U((8 * (o2.from + u3)).toString(16), f2, "0") : U((o2.from + u3 + 1).toString(), f2, " "), [].concat(t3, [c3 + i2 + " | " + e3], a2 ? [z + R(" ", f2) + " | " + U("", r2, " ") + R("^", l4)] : []); + }, [], u2).join("\n"); + } + function N(n4, t2) { + return ["\n", "-- PARSING FAILED " + R("-", 50), "\n\n", D(n4, t2), "\n\n", (r2 = t2.expected, r2.length === 1 ? "Expected:\n\n" + r2[0] : "Expected one of the following: \n\n" + r2.join(", ")), "\n"].join(""); + var r2; + } + function G(n4) { + return n4.flags !== void 0 ? n4.flags : [n4.global ? "g" : "", n4.ignoreCase ? "i" : "", n4.multiline ? "m" : "", n4.unicode ? "u" : "", n4.sticky ? "y" : ""].join(""); + } + function C() { + for (var n4 = [].slice.call(arguments), t2 = n4.length, r2 = 0; r2 < t2; r2 += 1) + _(n4[r2]); + return e(function(r3, e2) { + for (var u2, o2 = new Array(t2), i2 = 0; i2 < t2; i2 += 1) { + if (!(u2 = B(n4[i2]._(r3, e2), u2)).status) + return u2; + o2[i2] = u2.value, e2 = u2.index; + } + return B(b(e2, o2), u2); + }); + } + function J() { + var n4 = [].slice.call(arguments); + if (n4.length === 0) + throw new Error("seqMap needs at least one argument"); + var t2 = n4.pop(); + return k(t2), C.apply(null, n4).map(function(n5) { + return t2.apply(null, n5); + }); + } + function T() { + var n4 = [].slice.call(arguments), t2 = n4.length; + if (t2 === 0) + return Y("zero alternates"); + for (var r2 = 0; r2 < t2; r2 += 1) + _(n4[r2]); + return e(function(t3, r3) { + for (var e2, u2 = 0; u2 < n4.length; u2 += 1) + if ((e2 = B(n4[u2]._(t3, r3), e2)).status) + return e2; + return e2; + }); + } + function V(n4, t2) { + return H(n4, t2).or(X([])); + } + function H(n4, t2) { + return _(n4), _(t2), J(n4, t2.then(n4).many(), function(n5, t3) { + return [n5].concat(t3); + }); + } + function K(n4) { + P(n4); + var t2 = "'" + n4 + "'"; + return e(function(r2, e2) { + var u2 = e2 + n4.length, o2 = r2.slice(e2, u2); + return o2 === n4 ? b(u2, o2) : x(e2, t2); + }); + } + function Q(n4, t2) { + !function(n5) { + if (!(n5 instanceof RegExp)) + throw new Error("not a regexp: " + n5); + for (var t3 = G(n5), r3 = 0; r3 < t3.length; r3++) { + var e2 = t3.charAt(r3); + if (e2 !== "i" && e2 !== "m" && e2 !== "u" && e2 !== "s") + throw new Error('unsupported regexp flag "' + e2 + '": ' + n5); + } + }(n4), arguments.length >= 2 ? O(t2) : t2 = 0; + var r2 = function(n5) { + return RegExp("^(?:" + n5.source + ")", G(n5)); + }(n4), u2 = "" + n4; + return e(function(n5, e2) { + var o2 = r2.exec(n5.slice(e2)); + if (o2) { + if (0 <= t2 && t2 <= o2.length) { + var i2 = o2[0], a2 = o2[t2]; + return b(e2 + i2.length, a2); + } + return x(e2, "valid match group (0 to " + o2.length + ") in " + u2); + } + return x(e2, u2); + }); + } + function X(n4) { + return e(function(t2, r2) { + return b(r2, n4); + }); + } + function Y(n4) { + return e(function(t2, r2) { + return x(r2, n4); + }); + } + function Z(n4) { + if (y(n4)) + return e(function(t2, r2) { + var e2 = n4._(t2, r2); + return e2.index = r2, e2.value = "", e2; + }); + if (typeof n4 == "string") + return Z(K(n4)); + if (n4 instanceof RegExp) + return Z(Q(n4)); + throw new Error("not a string, regexp, or parser: " + n4); + } + function $(n4) { + return _(n4), e(function(t2, r2) { + var e2 = n4._(t2, r2), u2 = t2.slice(r2, e2.index); + return e2.status ? x(r2, 'not "' + u2 + '"') : b(r2, null); + }); + } + function nn(n4) { + return k(n4), e(function(t2, r2) { + var e2 = L(t2, r2); + return r2 < t2.length && n4(e2) ? b(r2 + 1, e2) : x(r2, "a character/byte matching " + n4); + }); + } + function tn(n4, t2) { + arguments.length < 2 && (t2 = n4, n4 = void 0); + var r2 = e(function(n5, e2) { + return r2._ = t2()._, r2._(n5, e2); + }); + return n4 ? r2.desc(n4) : r2; + } + function rn() { + return Y("fantasy-land/empty"); + } + u.parse = function(n4) { + if (typeof n4 != "string" && !w(n4)) + throw new Error(".parse must be called with a string or Buffer as its argument"); + var t2, r2 = this.skip(an)._(n4, 0); + return t2 = r2.status ? { status: true, value: r2.value } : { status: false, index: S(n4, r2.furthest), expected: r2.expected }, delete j[n4], t2; + }, u.tryParse = function(n4) { + var t2 = this.parse(n4); + if (t2.status) + return t2.value; + var r2 = N(n4, t2), e2 = new Error(r2); + throw e2.type = "ParsimmonError", e2.result = t2, e2; + }, u.assert = function(n4, t2) { + return this.chain(function(r2) { + return n4(r2) ? X(r2) : Y(t2); + }); + }, u.or = function(n4) { + return T(this, n4); + }, u.trim = function(n4) { + return this.wrap(n4, n4); + }, u.wrap = function(n4, t2) { + return J(n4, this, t2, function(n5, t3) { + return t3; + }); + }, u.thru = function(n4) { + return n4(this); + }, u.then = function(n4) { + return _(n4), C(this, n4).map(function(n5) { + return n5[1]; + }); + }, u.many = function() { + var n4 = this; + return e(function(t2, r2) { + for (var e2 = [], u2 = void 0; ; ) { + if (!(u2 = B(n4._(t2, r2), u2)).status) + return B(b(r2, e2), u2); + if (r2 === u2.index) + throw new Error("infinite loop detected in .many() parser --- calling .many() on a parser which can accept zero characters is usually the cause"); + r2 = u2.index, e2.push(u2.value); + } + }); + }, u.tieWith = function(n4) { + return P(n4), this.map(function(t2) { + if (function(n5) { + if (!E(n5)) + throw new Error("not an array: " + n5); + }(t2), t2.length) { + P(t2[0]); + for (var r2 = t2[0], e2 = 1; e2 < t2.length; e2++) + P(t2[e2]), r2 += n4 + t2[e2]; + return r2; + } + return ""; + }); + }, u.tie = function() { + return this.tieWith(""); + }, u.times = function(n4, t2) { + var r2 = this; + return arguments.length < 2 && (t2 = n4), O(n4), O(t2), e(function(e2, u2) { + for (var o2 = [], i2 = void 0, a2 = void 0, f2 = 0; f2 < n4; f2 += 1) { + if (a2 = B(i2 = r2._(e2, u2), a2), !i2.status) + return a2; + u2 = i2.index, o2.push(i2.value); + } + for (; f2 < t2 && (a2 = B(i2 = r2._(e2, u2), a2), i2.status); f2 += 1) + u2 = i2.index, o2.push(i2.value); + return B(b(u2, o2), a2); + }); + }, u.result = function(n4) { + return this.map(function() { + return n4; + }); + }, u.atMost = function(n4) { + return this.times(0, n4); + }, u.atLeast = function(n4) { + return J(this.times(n4), this.many(), function(n5, t2) { + return n5.concat(t2); + }); + }, u.map = function(n4) { + k(n4); + var t2 = this; + return e(function(r2, e2) { + var u2 = t2._(r2, e2); + return u2.status ? B(b(u2.index, n4(u2.value)), u2) : u2; + }); + }, u.contramap = function(n4) { + k(n4); + var t2 = this; + return e(function(r2, e2) { + var u2 = t2.parse(n4(r2.slice(e2))); + return u2.status ? b(e2 + r2.length, u2.value) : u2; + }); + }, u.promap = function(n4, t2) { + return k(n4), k(t2), this.contramap(n4).map(t2); + }, u.skip = function(n4) { + return C(this, n4).map(function(n5) { + return n5[0]; + }); + }, u.mark = function() { + return J(en, this, en, function(n4, t2, r2) { + return { start: n4, value: t2, end: r2 }; + }); + }, u.node = function(n4) { + return J(en, this, en, function(t2, r2, e2) { + return { name: n4, value: r2, start: t2, end: e2 }; + }); + }, u.sepBy = function(n4) { + return V(this, n4); + }, u.sepBy1 = function(n4) { + return H(this, n4); + }, u.lookahead = function(n4) { + return this.skip(Z(n4)); + }, u.notFollowedBy = function(n4) { + return this.skip($(n4)); + }, u.desc = function(n4) { + E(n4) || (n4 = [n4]); + var t2 = this; + return e(function(r2, e2) { + var u2 = t2._(r2, e2); + return u2.status || (u2.expected = n4), u2; + }); + }, u.fallback = function(n4) { + return this.or(X(n4)); + }, u.ap = function(n4) { + return J(n4, this, function(n5, t2) { + return n5(t2); + }); + }, u.chain = function(n4) { + var t2 = this; + return e(function(r2, e2) { + var u2 = t2._(r2, e2); + return u2.status ? B(n4(u2.value)._(r2, u2.index), u2) : u2; + }); + }, u.concat = u.or, u.empty = rn, u.of = X, u["fantasy-land/ap"] = u.ap, u["fantasy-land/chain"] = u.chain, u["fantasy-land/concat"] = u.concat, u["fantasy-land/empty"] = u.empty, u["fantasy-land/of"] = u.of, u["fantasy-land/map"] = u.map; + var en = e(function(n4, t2) { + return b(t2, S(n4, t2)); + }), un = e(function(n4, t2) { + return t2 >= n4.length ? x(t2, "any character/byte") : b(t2 + 1, L(n4, t2)); + }), on = e(function(n4, t2) { + return b(n4.length, n4.slice(t2)); + }), an = e(function(n4, t2) { + return t2 < n4.length ? x(t2, "EOF") : b(t2, null); + }), fn2 = Q(/[0-9]/).desc("a digit"), cn = Q(/[0-9]*/).desc("optional digits"), sn = Q(/[a-z]/i).desc("a letter"), ln = Q(/[a-z]*/i).desc("optional letters"), hn = Q(/\s*/).desc("optional whitespace"), pn = Q(/\s+/).desc("whitespace"), dn = K("\r"), vn = K("\n"), gn = K("\r\n"), mn = T(gn, vn, dn).desc("newline"), yn = T(mn, an); + e.all = on, e.alt = T, e.any = un, e.cr = dn, e.createLanguage = function(n4) { + var t2 = {}; + for (var r2 in n4) + ({}).hasOwnProperty.call(n4, r2) && function(r3) { + t2[r3] = tn(function() { + return n4[r3](t2); + }); + }(r2); + return t2; + }, e.crlf = gn, e.custom = function(n4) { + return e(n4(b, x)); + }, e.digit = fn2, e.digits = cn, e.empty = rn, e.end = yn, e.eof = an, e.fail = Y, e.formatError = N, e.index = en, e.isParser = y, e.lazy = tn, e.letter = sn, e.letters = ln, e.lf = vn, e.lookahead = Z, e.makeFailure = x, e.makeSuccess = b, e.newline = mn, e.noneOf = function(n4) { + return nn(function(t2) { + return n4.indexOf(t2) < 0; + }).desc("none of '" + n4 + "'"); + }, e.notFollowedBy = $, e.of = X, e.oneOf = function(n4) { + for (var t2 = n4.split(""), r2 = 0; r2 < t2.length; r2++) + t2[r2] = "'" + t2[r2] + "'"; + return nn(function(t3) { + return n4.indexOf(t3) >= 0; + }).desc(t2); + }, e.optWhitespace = hn, e.Parser = e, e.range = function(n4, t2) { + return nn(function(r2) { + return n4 <= r2 && r2 <= t2; + }).desc(n4 + "-" + t2); + }, e.regex = Q, e.regexp = Q, e.sepBy = V, e.sepBy1 = H, e.seq = C, e.seqMap = J, e.seqObj = function() { + for (var n4, t2 = {}, r2 = 0, u2 = (n4 = arguments, Array.prototype.slice.call(n4)), o2 = u2.length, i2 = 0; i2 < o2; i2 += 1) { + var a2 = u2[i2]; + if (!y(a2)) { + if (E(a2) && a2.length === 2 && typeof a2[0] == "string" && y(a2[1])) { + var f2 = a2[0]; + if (Object.prototype.hasOwnProperty.call(t2, f2)) + throw new Error("seqObj: duplicate key " + f2); + t2[f2] = true, r2++; + continue; + } + throw new Error("seqObj arguments must be parsers or [string, parser] array pairs."); + } + } + if (r2 === 0) + throw new Error("seqObj expects at least one named parser, found zero"); + return e(function(n5, t3) { + for (var r3, e2 = {}, i3 = 0; i3 < o2; i3 += 1) { + var a3, f3; + if (E(u2[i3]) ? (a3 = u2[i3][0], f3 = u2[i3][1]) : (a3 = null, f3 = u2[i3]), !(r3 = B(f3._(n5, t3), r3)).status) + return r3; + a3 && (e2[a3] = r3.value), t3 = r3.index; + } + return B(b(t3, e2), r3); + }); + }, e.string = K, e.succeed = X, e.takeWhile = function(n4) { + return k(n4), e(function(t2, r2) { + for (var e2 = r2; e2 < t2.length && n4(L(t2, e2)); ) + e2++; + return b(e2, t2.slice(r2, e2)); + }); + }, e.test = nn, e.whitespace = pn, e["fantasy-land/empty"] = rn, e["fantasy-land/of"] = X, e.Binary = { bitSeq: l3, bitSeqObj: function(n4) { + s3(); + var t2 = {}, r2 = 0, e2 = a(function(n5) { + if (E(n5)) { + var e3 = n5; + if (e3.length !== 2) + throw new Error("[" + e3.join(", ") + "] should be length 2, got length " + e3.length); + if (P(e3[0]), O(e3[1]), Object.prototype.hasOwnProperty.call(t2, e3[0])) + throw new Error("duplicate key in bitSeqObj: " + e3[0]); + return t2[e3[0]] = true, r2++, e3; + } + return O(n5), [null, n5]; + }, n4); + if (r2 < 1) + throw new Error("bitSeqObj expects at least one named pair, got [" + n4.join(", ") + "]"); + var u2 = a(function(n5) { + return n5[0]; + }, e2); + return l3(a(function(n5) { + return n5[1]; + }, e2)).map(function(n5) { + return i(function(n6, t3) { + return t3[0] !== null && (n6[t3[0]] = t3[1]), n6; + }, {}, a(function(t3, r3) { + return [t3, n5[r3]]; + }, u2)); + }); + }, byte: function(n4) { + if (s3(), O(n4), n4 > 255) + throw new Error("Value specified to byte constructor (" + n4 + "=0x" + n4.toString(16) + ") is larger in value than a single byte."); + var t2 = (n4 > 15 ? "0x" : "0x0") + n4.toString(16); + return e(function(r2, e2) { + var u2 = L(r2, e2); + return u2 === n4 ? b(e2 + 1, u2) : x(e2, t2); + }); + }, buffer: function(n4) { + return h("buffer", n4).map(function(n5) { + return Buffer.from(n5); + }); + }, encodedString: function(n4, t2) { + return h("string", t2).map(function(t3) { + return t3.toString(n4); + }); + }, uintBE: d, uint8BE: d(1), uint16BE: d(2), uint32BE: d(4), uintLE: v, uint8LE: v(1), uint16LE: v(2), uint32LE: v(4), intBE: g, int8BE: g(1), int16BE: g(2), int32BE: g(4), intLE: m, int8LE: m(1), int16LE: m(2), int32LE: m(4), floatBE: h("floatBE", 4).map(function(n4) { + return n4.readFloatBE(0); + }), floatLE: h("floatLE", 4).map(function(n4) { + return n4.readFloatLE(0); + }), doubleBE: h("doubleBE", 8).map(function(n4) { + return n4.readDoubleBE(0); + }), doubleLE: h("doubleLE", 8).map(function(n4) { + return n4.readDoubleLE(0); + }) }, n3.exports = e; + }]); + }); + })(parsimmon_umd_min); + var emojiRegex = () => { + return /(?:[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDD-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF6](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7C\uDE80-\uDE86\uDE90-\uDEAC\uDEB0-\uDEBA\uDEC0-\uDEC2\uDED0-\uDED9\uDEE0-\uDEE7]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?))/g; + }; + function normalizeDuration(dur) { + if (dur === void 0 || dur === null) + return dur; + return dur.shiftToAll().normalize(); + } + function getFileTitle(path) { + if (path.includes("/")) + path = path.substring(path.lastIndexOf("/") + 1); + if (path.endsWith(".md")) + path = path.substring(0, path.length - 3); + return path; + } + parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.regex(new RegExp(emojiRegex(), "")), parsimmon_umd_min.exports.regex(/[0-9\p{Letter}_-]+/u).map((str) => str.toLocaleLowerCase()), parsimmon_umd_min.exports.whitespace.map((_) => "-"), parsimmon_umd_min.exports.any.map((_) => "")).many().map((result) => result.join("")); + var HEADER_CANONICALIZER = parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.regex(new RegExp(emojiRegex(), "")), parsimmon_umd_min.exports.regex(/[0-9\p{Letter}_-]+/u), parsimmon_umd_min.exports.whitespace.map((_) => " "), parsimmon_umd_min.exports.any.map((_) => " ")).many().map((result) => { + return result.join("").split(/\s+/).join(" ").trim(); + }); + function normalizeHeaderForLink(header) { + return HEADER_CANONICALIZER.tryParse(header); + } + function renderMinimalDuration(dur) { + dur = normalizeDuration(dur); + dur = Duration2.fromObject(Object.fromEntries(Object.entries(dur.toObject()).filter(([, quantity]) => quantity > 0))); + return dur.toHuman(); + } + var Values; + (function(Values2) { + function toString(field, setting = DEFAULT_QUERY_SETTINGS, recursive = false) { + let wrapped = wrapValue(field); + if (!wrapped) + return setting.renderNullAs; + switch (wrapped.type) { + case "null": + return setting.renderNullAs; + case "string": + return wrapped.value; + case "number": + case "boolean": + return "" + wrapped.value; + case "html": + return wrapped.value.outerHTML; + case "widget": + return wrapped.value.markdown(); + case "link": + return wrapped.value.markdown(); + case "function": + return ""; + case "array": + let result = ""; + if (recursive) + result += "["; + result += wrapped.value.map((f) => toString(f, setting, true)).join(", "); + if (recursive) + result += "]"; + return result; + case "object": + return "{ " + Object.entries(wrapped.value).map((e) => e[0] + ": " + toString(e[1], setting, true)).join(", ") + " }"; + case "date": + if (wrapped.value.second == 0 && wrapped.value.hour == 0 && wrapped.value.minute == 0) { + return wrapped.value.toFormat(setting.defaultDateFormat); + } + return wrapped.value.toFormat(setting.defaultDateTimeFormat); + case "duration": + return renderMinimalDuration(wrapped.value); + } + } + Values2.toString = toString; + function wrapValue(val) { + if (isNull(val)) + return { type: "null", value: val }; + else if (isNumber3(val)) + return { type: "number", value: val }; + else if (isString3(val)) + return { type: "string", value: val }; + else if (isBoolean(val)) + return { type: "boolean", value: val }; + else if (isDuration(val)) + return { type: "duration", value: val }; + else if (isDate3(val)) + return { type: "date", value: val }; + else if (isWidget(val)) + return { type: "widget", value: val }; + else if (isArray(val)) + return { type: "array", value: val }; + else if (isLink(val)) + return { type: "link", value: val }; + else if (isFunction(val)) + return { type: "function", value: val }; + else if (isHtml(val)) + return { type: "html", value: val }; + else if (isObject2(val)) + return { type: "object", value: val }; + else + return void 0; + } + Values2.wrapValue = wrapValue; + function mapLeaves(val, func) { + if (isObject2(val)) { + let result = {}; + for (let [key, value] of Object.entries(val)) + result[key] = mapLeaves(value, func); + return result; + } else if (isArray(val)) { + let result = []; + for (let value of val) + result.push(mapLeaves(value, func)); + return result; + } else { + return func(val); + } + } + Values2.mapLeaves = mapLeaves; + function compareValue(val1, val2, linkNormalizer) { + var _a, _b; + if (val1 === void 0) + val1 = null; + if (val2 === void 0) + val2 = null; + if (val1 === null && val2 === null) + return 0; + else if (val1 === null) + return -1; + else if (val2 === null) + return 1; + let wrap1 = wrapValue(val1); + let wrap2 = wrapValue(val2); + if (wrap1 === void 0 && wrap2 === void 0) + return 0; + else if (wrap1 === void 0) + return -1; + else if (wrap2 === void 0) + return 1; + if (wrap1.type != wrap2.type) + return wrap1.type.localeCompare(wrap2.type); + if (wrap1.value === wrap2.value) + return 0; + switch (wrap1.type) { + case "string": + return wrap1.value.localeCompare(wrap2.value); + case "number": + if (wrap1.value < wrap2.value) + return -1; + else if (wrap1.value == wrap2.value) + return 0; + return 1; + case "null": + return 0; + case "boolean": + if (wrap1.value == wrap2.value) + return 0; + else + return wrap1.value ? 1 : -1; + case "link": + let link1 = wrap1.value; + let link2 = wrap2.value; + let normalize = linkNormalizer !== null && linkNormalizer !== void 0 ? linkNormalizer : (x) => x; + let pathCompare = normalize(link1.path).localeCompare(normalize(link2.path)); + if (pathCompare != 0) + return pathCompare; + let typeCompare = link1.type.localeCompare(link2.type); + if (typeCompare != 0) + return typeCompare; + if (link1.subpath && !link2.subpath) + return 1; + if (!link1.subpath && link2.subpath) + return -1; + if (!link1.subpath && !link2.subpath) + return 0; + return ((_a = link1.subpath) !== null && _a !== void 0 ? _a : "").localeCompare((_b = link2.subpath) !== null && _b !== void 0 ? _b : ""); + case "date": + return wrap1.value < wrap2.value ? -1 : wrap1.value.equals(wrap2.value) ? 0 : 1; + case "duration": + return wrap1.value < wrap2.value ? -1 : wrap1.value.equals(wrap2.value) ? 0 : 1; + case "array": + let f1 = wrap1.value; + let f2 = wrap2.value; + for (let index = 0; index < Math.min(f1.length, f2.length); index++) { + let comp = compareValue(f1[index], f2[index]); + if (comp != 0) + return comp; + } + return f1.length - f2.length; + case "object": + let o1 = wrap1.value; + let o2 = wrap2.value; + let k1 = Array.from(Object.keys(o1)); + let k2 = Array.from(Object.keys(o2)); + k1.sort(); + k2.sort(); + let keyCompare = compareValue(k1, k2); + if (keyCompare != 0) + return keyCompare; + for (let key of k1) { + let comp = compareValue(o1[key], o2[key]); + if (comp != 0) + return comp; + } + return 0; + case "widget": + case "html": + case "function": + return 0; + } + } + Values2.compareValue = compareValue; + function typeOf(val) { + var _a; + return (_a = wrapValue(val)) === null || _a === void 0 ? void 0 : _a.type; + } + Values2.typeOf = typeOf; + function isTruthy(field) { + let wrapped = wrapValue(field); + if (!wrapped) + return false; + switch (wrapped.type) { + case "number": + return wrapped.value != 0; + case "string": + return wrapped.value.length > 0; + case "boolean": + return wrapped.value; + case "link": + return !!wrapped.value.path; + case "date": + return wrapped.value.toMillis() != 0; + case "duration": + return wrapped.value.as("seconds") != 0; + case "object": + return Object.keys(wrapped.value).length > 0; + case "array": + return wrapped.value.length > 0; + case "null": + return false; + case "html": + case "widget": + case "function": + return true; + } + } + Values2.isTruthy = isTruthy; + function deepCopy(field) { + if (field === null || field === void 0) + return field; + if (Values2.isArray(field)) { + return [].concat(field.map((v) => deepCopy(v))); + } else if (Values2.isObject(field)) { + let result = {}; + for (let [key, value] of Object.entries(field)) + result[key] = deepCopy(value); + return result; + } else { + return field; + } + } + Values2.deepCopy = deepCopy; + function isString3(val) { + return typeof val == "string"; + } + Values2.isString = isString3; + function isNumber3(val) { + return typeof val == "number"; + } + Values2.isNumber = isNumber3; + function isDate3(val) { + return val instanceof DateTime2; + } + Values2.isDate = isDate3; + function isDuration(val) { + return val instanceof Duration2; + } + Values2.isDuration = isDuration; + function isNull(val) { + return val === null || val === void 0; + } + Values2.isNull = isNull; + function isArray(val) { + return Array.isArray(val); + } + Values2.isArray = isArray; + function isBoolean(val) { + return typeof val === "boolean"; + } + Values2.isBoolean = isBoolean; + function isLink(val) { + return val instanceof Link; + } + Values2.isLink = isLink; + function isWidget(val) { + return val instanceof Widget; + } + Values2.isWidget = isWidget; + function isHtml(val) { + if (typeof HTMLElement !== "undefined") { + return val instanceof HTMLElement; + } else { + return false; + } + } + Values2.isHtml = isHtml; + function isObject2(val) { + return typeof val == "object" && !isHtml(val) && !isWidget(val) && !isArray(val) && !isDuration(val) && !isDate3(val) && !isLink(val) && val !== void 0 && !isNull(val); + } + Values2.isObject = isObject2; + function isFunction(val) { + return typeof val == "function"; + } + Values2.isFunction = isFunction; + })(Values || (Values = {})); + var Groupings; + (function(Groupings2) { + function isElementGroup(entry) { + return Values.isObject(entry) && Object.keys(entry).length == 2 && "key" in entry && "rows" in entry; + } + Groupings2.isElementGroup = isElementGroup; + function isGrouping(entry) { + for (let element of entry) + if (!isElementGroup(element)) + return false; + return true; + } + Groupings2.isGrouping = isGrouping; + function count(elements) { + if (isGrouping(elements)) { + let result = 0; + for (let subgroup of elements) + result += count(subgroup.rows); + return result; + } else { + return elements.length; + } + } + Groupings2.count = count; + })(Groupings || (Groupings = {})); + var Link = class { + constructor(fields) { + Object.assign(this, fields); + } + static file(path, embed = false, display) { + return new Link({ + path, + embed, + display, + subpath: void 0, + type: "file" + }); + } + static infer(linkpath, embed = false, display) { + if (linkpath.includes("#^")) { + let split = linkpath.split("#^"); + return Link.block(split[0], split[1], embed, display); + } else if (linkpath.includes("#")) { + let split = linkpath.split("#"); + return Link.header(split[0], split[1], embed, display); + } else + return Link.file(linkpath, embed, display); + } + static header(path, header, embed, display) { + return new Link({ + path, + embed, + display, + subpath: normalizeHeaderForLink(header), + type: "header" + }); + } + static block(path, blockId, embed, display) { + return new Link({ + path, + embed, + display, + subpath: blockId, + type: "block" + }); + } + static fromObject(object) { + return new Link(object); + } + equals(other) { + if (other == void 0 || other == null) + return false; + return this.path == other.path && this.type == other.type && this.subpath == other.subpath; + } + toString() { + return this.markdown(); + } + toObject() { + return { path: this.path, type: this.type, subpath: this.subpath, display: this.display, embed: this.embed }; + } + withPath(path) { + return new Link(Object.assign({}, this, { path })); + } + withDisplay(display) { + return new Link(Object.assign({}, this, { display })); + } + withHeader(header) { + return Link.header(this.path, header, this.embed, this.display); + } + toFile() { + return Link.file(this.path, this.embed, this.display); + } + toEmbed() { + if (this.embed) { + return this; + } else { + let link = new Link(this); + link.embed = true; + return link; + } + } + fromEmbed() { + if (!this.embed) { + return this; + } else { + let link = new Link(this); + link.embed = false; + return link; + } + } + markdown() { + let result = (this.embed ? "!" : "") + "[[" + this.obsidianLink(); + if (this.display) { + result += "|" + this.display; + } else { + result += "|" + getFileTitle(this.path); + if (this.type == "header" || this.type == "block") + result += " > " + this.subpath; + } + result += "]]"; + return result; + } + obsidianLink() { + var _a, _b; + const escaped = this.path.replace("|", "\\|"); + if (this.type == "header") + return escaped + "#" + ((_a = this.subpath) === null || _a === void 0 ? void 0 : _a.replace("|", "\\|")); + if (this.type == "block") + return escaped + "#^" + ((_b = this.subpath) === null || _b === void 0 ? void 0 : _b.replace("|", "\\|")); + else + return escaped; + } + fileName() { + return getFileTitle(this.path).replace(".md", ""); + } + }; + var Widget = class { + constructor($widget) { + this.$widget = $widget; + } + }; + var ListPairWidget = class extends Widget { + constructor(key, value) { + super("dataview:list-pair"); + this.key = key; + this.value = value; + } + markdown() { + return `${Values.toString(this.key)}: ${Values.toString(this.value)}`; + } + }; + var ExternalLinkWidget = class extends Widget { + constructor(url, display) { + super("dataview:external-link"); + this.url = url; + this.display = display; + } + markdown() { + var _a; + return `[${(_a = this.display) !== null && _a !== void 0 ? _a : this.url}](${this.url})`; + } + }; + var Widgets; + (function(Widgets2) { + function listPair(key, value) { + return new ListPairWidget(key, value); + } + Widgets2.listPair = listPair; + function externalLink(url, display) { + return new ExternalLinkWidget(url, display); + } + Widgets2.externalLink = externalLink; + function isListPair(widget) { + return widget.$widget === "dataview:list-pair"; + } + Widgets2.isListPair = isListPair; + function isExternalLink(widget) { + return widget.$widget === "dataview:external-link"; + } + Widgets2.isExternalLink = isExternalLink; + function isBuiltin(widget) { + return isListPair(widget) || isExternalLink(widget); + } + Widgets2.isBuiltin = isBuiltin; + })(Widgets || (Widgets = {})); + var Fields; + (function(Fields2) { + function variable(name) { + return { type: "variable", name }; + } + Fields2.variable = variable; + function literal(value) { + return { type: "literal", value }; + } + Fields2.literal = literal; + function binaryOp(left2, op, right2) { + return { type: "binaryop", left: left2, op, right: right2 }; + } + Fields2.binaryOp = binaryOp; + function index(obj, index2) { + return { type: "index", object: obj, index: index2 }; + } + Fields2.index = index; + function indexVariable(name) { + let parts = name.split("."); + let result = Fields2.variable(parts[0]); + for (let index2 = 1; index2 < parts.length; index2++) { + result = Fields2.index(result, Fields2.literal(parts[index2])); + } + return result; + } + Fields2.indexVariable = indexVariable; + function lambda(args, value) { + return { type: "lambda", arguments: args, value }; + } + Fields2.lambda = lambda; + function func(func2, args) { + return { type: "function", func: func2, arguments: args }; + } + Fields2.func = func; + function list(values) { + return { type: "list", values }; + } + Fields2.list = list; + function object(values) { + return { type: "object", values }; + } + Fields2.object = object; + function negate(child) { + return { type: "negated", child }; + } + Fields2.negate = negate; + function isCompareOp(op) { + return op == "<=" || op == "<" || op == ">" || op == ">=" || op == "!=" || op == "="; + } + Fields2.isCompareOp = isCompareOp; + Fields2.NULL = Fields2.literal(null); + })(Fields || (Fields = {})); + var Sources; + (function(Sources2) { + function tag(tag2) { + return { type: "tag", tag: tag2 }; + } + Sources2.tag = tag; + function csv(path) { + return { type: "csv", path }; + } + Sources2.csv = csv; + function folder(prefix) { + return { type: "folder", folder: prefix }; + } + Sources2.folder = folder; + function link(file, incoming) { + return { type: "link", file, direction: incoming ? "incoming" : "outgoing" }; + } + Sources2.link = link; + function binaryOp(left2, op, right2) { + return { type: "binaryop", left: left2, op, right: right2 }; + } + Sources2.binaryOp = binaryOp; + function and(left2, right2) { + return { type: "binaryop", left: left2, op: "&", right: right2 }; + } + Sources2.and = and; + function or(left2, right2) { + return { type: "binaryop", left: left2, op: "|", right: right2 }; + } + Sources2.or = or; + function negate(child) { + return { type: "negate", child }; + } + Sources2.negate = negate; + function empty() { + return { type: "empty" }; + } + Sources2.empty = empty; + })(Sources || (Sources = {})); + var EMOJI_REGEX = new RegExp(emojiRegex(), ""); + var DURATION_TYPES = { + year: Duration2.fromObject({ years: 1 }), + years: Duration2.fromObject({ years: 1 }), + yr: Duration2.fromObject({ years: 1 }), + yrs: Duration2.fromObject({ years: 1 }), + month: Duration2.fromObject({ months: 1 }), + months: Duration2.fromObject({ months: 1 }), + mo: Duration2.fromObject({ months: 1 }), + mos: Duration2.fromObject({ months: 1 }), + week: Duration2.fromObject({ weeks: 1 }), + weeks: Duration2.fromObject({ weeks: 1 }), + wk: Duration2.fromObject({ weeks: 1 }), + wks: Duration2.fromObject({ weeks: 1 }), + w: Duration2.fromObject({ weeks: 1 }), + day: Duration2.fromObject({ days: 1 }), + days: Duration2.fromObject({ days: 1 }), + d: Duration2.fromObject({ days: 1 }), + hour: Duration2.fromObject({ hours: 1 }), + hours: Duration2.fromObject({ hours: 1 }), + hr: Duration2.fromObject({ hours: 1 }), + hrs: Duration2.fromObject({ hours: 1 }), + h: Duration2.fromObject({ hours: 1 }), + minute: Duration2.fromObject({ minutes: 1 }), + minutes: Duration2.fromObject({ minutes: 1 }), + min: Duration2.fromObject({ minutes: 1 }), + mins: Duration2.fromObject({ minutes: 1 }), + m: Duration2.fromObject({ minutes: 1 }), + second: Duration2.fromObject({ seconds: 1 }), + seconds: Duration2.fromObject({ seconds: 1 }), + sec: Duration2.fromObject({ seconds: 1 }), + secs: Duration2.fromObject({ seconds: 1 }), + s: Duration2.fromObject({ seconds: 1 }) + }; + var DATE_SHORTHANDS = { + now: () => DateTime2.local(), + today: () => DateTime2.local().startOf("day"), + yesterday: () => DateTime2.local().startOf("day").minus(Duration2.fromObject({ days: 1 })), + tomorrow: () => DateTime2.local().startOf("day").plus(Duration2.fromObject({ days: 1 })), + sow: () => DateTime2.local().startOf("week"), + "start-of-week": () => DateTime2.local().startOf("week"), + eow: () => DateTime2.local().endOf("week"), + "end-of-week": () => DateTime2.local().endOf("week"), + soy: () => DateTime2.local().startOf("year"), + "start-of-year": () => DateTime2.local().startOf("year"), + eoy: () => DateTime2.local().endOf("year"), + "end-of-year": () => DateTime2.local().endOf("year"), + som: () => DateTime2.local().startOf("month"), + "start-of-month": () => DateTime2.local().startOf("month"), + eom: () => DateTime2.local().endOf("month"), + "end-of-month": () => DateTime2.local().endOf("month") + }; + var KEYWORDS = ["FROM", "WHERE", "LIMIT", "GROUP", "FLATTEN"]; + function splitOnUnescapedPipe(link) { + let pipe = -1; + while ((pipe = link.indexOf("|", pipe + 1)) >= 0) { + if (pipe > 0 && link[pipe - 1] == "\\") + continue; + return [link.substring(0, pipe).replace(/\\\|/g, "|"), link.substring(pipe + 1)]; + } + return [link.replace(/\\\|/g, "|"), void 0]; + } + function parseInnerLink(rawlink) { + let [link, display] = splitOnUnescapedPipe(rawlink); + return Link.infer(link, false, display); + } + function createBinaryParser(child, sep, combine) { + return parsimmon_umd_min.exports.seqMap(child, parsimmon_umd_min.exports.seq(parsimmon_umd_min.exports.optWhitespace, sep, parsimmon_umd_min.exports.optWhitespace, child).many(), (first, rest) => { + if (rest.length == 0) + return first; + let node = combine(first, rest[0][1], rest[0][3]); + for (let index = 1; index < rest.length; index++) { + node = combine(node, rest[index][1], rest[index][3]); + } + return node; + }); + } + function chainOpt(base, ...funcs) { + return parsimmon_umd_min.exports.custom((success, failure) => { + return (input, i) => { + let result = base._(input, i); + if (!result.status) + return result; + for (let func of funcs) { + let next = func(result.value)._(input, result.index); + if (!next.status) + return result; + result = next; + } + return result; + }; + }); + } + var EXPRESSION = parsimmon_umd_min.exports.createLanguage({ + number: (q) => parsimmon_umd_min.exports.regexp(/-?[0-9]+(\.[0-9]+)?/).map((str) => Number.parseFloat(str)).desc("number"), + string: (q) => parsimmon_umd_min.exports.string('"').then(parsimmon_umd_min.exports.alt(q.escapeCharacter, parsimmon_umd_min.exports.noneOf('"\\')).atLeast(0).map((chars) => chars.join(""))).skip(parsimmon_umd_min.exports.string('"')).desc("string"), + escapeCharacter: (_) => parsimmon_umd_min.exports.string("\\").then(parsimmon_umd_min.exports.any).map((escaped) => { + if (escaped === '"') + return '"'; + if (escaped === "\\") + return "\\"; + else + return "\\" + escaped; + }), + bool: (_) => parsimmon_umd_min.exports.regexp(/true|false|True|False/).map((str) => str.toLowerCase() == "true").desc("boolean ('true' or 'false')"), + tag: (_) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("#"), parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.regexp(/[^\u2000-\u206F\u2E00-\u2E7F'!"#$%&()*+,.:;<=>?@^`{|}~\[\]\\\s]/).desc("text")).many(), (start2, rest) => start2 + rest.join("")).desc("tag ('#hello/stuff')"), + identifier: (_) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.regexp(/\p{Letter}/u), parsimmon_umd_min.exports.regexp(EMOJI_REGEX).desc("text")), parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.regexp(/[0-9\p{Letter}_-]/u), parsimmon_umd_min.exports.regexp(EMOJI_REGEX).desc("text")).many(), (first, rest) => first + rest.join("")).desc("variable identifier"), + link: (_) => parsimmon_umd_min.exports.regexp(/\[\[([^\[\]]*?)\]\]/u, 1).map((linkInner) => parseInnerLink(linkInner)).desc("file link"), + embedLink: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("!").atMost(1), q.link, (p, l3) => { + if (p.length > 0) + l3.embed = true; + return l3; + }).desc("file link"), + binaryPlusMinus: (_) => parsimmon_umd_min.exports.regexp(/\+|-/).map((str) => str).desc("'+' or '-'"), + binaryMulDiv: (_) => parsimmon_umd_min.exports.regexp(/\*|\/|%/).map((str) => str).desc("'*' or '/' or '%'"), + binaryCompareOp: (_) => parsimmon_umd_min.exports.regexp(/>=|<=|!=|>|<|=/).map((str) => str).desc("'>=' or '<=' or '!=' or '=' or '>' or '<'"), + binaryBooleanOp: (_) => parsimmon_umd_min.exports.regexp(/and|or|&|\|/i).map((str) => { + if (str.toLowerCase() == "and") + return "&"; + else if (str.toLowerCase() == "or") + return "|"; + else + return str; + }).desc("'and' or 'or'"), + rootDate: (_) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/\d{4}/), parsimmon_umd_min.exports.string("-"), parsimmon_umd_min.exports.regexp(/\d{2}/), (year, _2, month) => { + return DateTime2.fromObject({ year: Number.parseInt(year), month: Number.parseInt(month) }); + }).desc("date in format YYYY-MM[-DDTHH-MM-SS.MS]"), + dateShorthand: (_) => parsimmon_umd_min.exports.alt(...Object.keys(DATE_SHORTHANDS).sort((a, b) => b.length - a.length).map(parsimmon_umd_min.exports.string)), + date: (q) => chainOpt(q.rootDate, (ym) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("-"), parsimmon_umd_min.exports.regexp(/\d{2}/), (_, day) => ym.set({ day: Number.parseInt(day) })), (ymd) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("T"), parsimmon_umd_min.exports.regexp(/\d{2}/), (_, hour) => ymd.set({ hour: Number.parseInt(hour) })), (ymdh) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string(":"), parsimmon_umd_min.exports.regexp(/\d{2}/), (_, minute) => ymdh.set({ minute: Number.parseInt(minute) })), (ymdhm) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string(":"), parsimmon_umd_min.exports.regexp(/\d{2}/), (_, second) => ymdhm.set({ second: Number.parseInt(second) })), (ymdhms) => parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("."), parsimmon_umd_min.exports.regexp(/\d{3}/), (_, millisecond) => ymdhms.set({ millisecond: Number.parseInt(millisecond) })), parsimmon_umd_min.exports.succeed(ymdhms)), (dt) => parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("+").or(parsimmon_umd_min.exports.string("-")), parsimmon_umd_min.exports.regexp(/\d{1,2}(:\d{2})?/), (pm, hr) => dt.setZone("UTC" + pm + hr, { keepLocalTime: true })), parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("Z"), () => dt.setZone("utc", { keepLocalTime: true })), parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("["), parsimmon_umd_min.exports.regexp(/[0-9A-Za-z+-\/]+/u), parsimmon_umd_min.exports.string("]"), (_a, zone, _b) => dt.setZone(zone, { keepLocalTime: true })))).assert((dt) => dt.isValid, "valid date").desc("date in format YYYY-MM[-DDTHH-MM-SS.MS]"), + datePlus: (q) => parsimmon_umd_min.exports.alt(q.dateShorthand.map((d) => DATE_SHORTHANDS[d]()), q.date).desc("date in format YYYY-MM[-DDTHH-MM-SS.MS] or in shorthand"), + durationType: (_) => parsimmon_umd_min.exports.alt(...Object.keys(DURATION_TYPES).sort((a, b) => b.length - a.length).map(parsimmon_umd_min.exports.string)), + duration: (q) => parsimmon_umd_min.exports.seqMap(q.number, parsimmon_umd_min.exports.optWhitespace, q.durationType, (count, _, t) => DURATION_TYPES[t].mapUnits((x) => x * count)).sepBy1(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace).or(parsimmon_umd_min.exports.optWhitespace)).map((durations) => durations.reduce((p, c) => p.plus(c))).desc("duration like 4hr2min"), + rawNull: (_) => parsimmon_umd_min.exports.string("null"), + tagSource: (q) => q.tag.map((tag) => Sources.tag(tag)), + csvSource: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("csv(").skip(parsimmon_umd_min.exports.optWhitespace), q.string, parsimmon_umd_min.exports.string(")"), (_1, path, _2) => Sources.csv(path)), + linkIncomingSource: (q) => q.link.map((link) => Sources.link(link.path, true)), + linkOutgoingSource: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("outgoing(").skip(parsimmon_umd_min.exports.optWhitespace), q.link, parsimmon_umd_min.exports.string(")"), (_1, link, _2) => Sources.link(link.path, false)), + folderSource: (q) => q.string.map((str) => Sources.folder(str)), + parensSource: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("("), parsimmon_umd_min.exports.optWhitespace, q.source, parsimmon_umd_min.exports.optWhitespace, parsimmon_umd_min.exports.string(")"), (_1, _2, field, _3, _4) => field), + negateSource: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.string("-"), parsimmon_umd_min.exports.string("!")), q.atomSource, (_, source) => Sources.negate(source)), + atomSource: (q) => parsimmon_umd_min.exports.alt(q.parensSource, q.negateSource, q.linkOutgoingSource, q.linkIncomingSource, q.folderSource, q.tagSource, q.csvSource), + binaryOpSource: (q) => createBinaryParser(q.atomSource, q.binaryBooleanOp.map((s3) => s3), Sources.binaryOp), + source: (q) => q.binaryOpSource, + variableField: (q) => q.identifier.chain((r) => { + if (KEYWORDS.includes(r.toUpperCase())) { + return parsimmon_umd_min.exports.fail("Variable fields cannot be a keyword (" + KEYWORDS.join(" or ") + ")"); + } else { + return parsimmon_umd_min.exports.succeed(Fields.variable(r)); + } + }).desc("variable"), + numberField: (q) => q.number.map((val) => Fields.literal(val)).desc("number"), + stringField: (q) => q.string.map((val) => Fields.literal(val)).desc("string"), + boolField: (q) => q.bool.map((val) => Fields.literal(val)).desc("boolean"), + dateField: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("date("), parsimmon_umd_min.exports.optWhitespace, q.datePlus, parsimmon_umd_min.exports.optWhitespace, parsimmon_umd_min.exports.string(")"), (prefix, _1, date, _2, postfix) => Fields.literal(date)).desc("date"), + durationField: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("dur("), parsimmon_umd_min.exports.optWhitespace, q.duration, parsimmon_umd_min.exports.optWhitespace, parsimmon_umd_min.exports.string(")"), (prefix, _1, dur, _2, postfix) => Fields.literal(dur)).desc("duration"), + nullField: (q) => q.rawNull.map((_) => Fields.NULL), + linkField: (q) => q.link.map((f) => Fields.literal(f)), + listField: (q) => q.field.sepBy(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace)).wrap(parsimmon_umd_min.exports.string("[").skip(parsimmon_umd_min.exports.optWhitespace), parsimmon_umd_min.exports.optWhitespace.then(parsimmon_umd_min.exports.string("]"))).map((l3) => Fields.list(l3)).desc("list ('[1, 2, 3]')"), + objectField: (q) => parsimmon_umd_min.exports.seqMap(q.identifier.or(q.string), parsimmon_umd_min.exports.string(":").trim(parsimmon_umd_min.exports.optWhitespace), q.field, (name, _sep, value) => { + return { name, value }; + }).sepBy(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace)).wrap(parsimmon_umd_min.exports.string("{").skip(parsimmon_umd_min.exports.optWhitespace), parsimmon_umd_min.exports.optWhitespace.then(parsimmon_umd_min.exports.string("}"))).map((vals) => { + let res = {}; + for (let entry of vals) + res[entry.name] = entry.value; + return Fields.object(res); + }).desc("object ('{ a: 1, b: 2 }')"), + atomInlineField: (q) => parsimmon_umd_min.exports.alt(q.date, q.duration.map((d) => normalizeDuration(d)), q.string, q.tag, q.embedLink, q.bool, q.number, q.rawNull), + inlineFieldList: (q) => q.atomInlineField.sepBy(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace).lookahead(q.atomInlineField)), + inlineField: (q) => parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.seqMap(q.atomInlineField, parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace), q.inlineFieldList, (f, _s, l3) => [f].concat(l3)), q.atomInlineField), + atomField: (q) => parsimmon_umd_min.exports.alt(q.embedLink.map((l3) => Fields.literal(l3)), q.negatedField, q.linkField, q.listField, q.objectField, q.lambdaField, q.parensField, q.boolField, q.numberField, q.stringField, q.dateField, q.durationField, q.nullField, q.variableField), + indexField: (q) => parsimmon_umd_min.exports.seqMap(q.atomField, parsimmon_umd_min.exports.alt(q.dotPostfix, q.indexPostfix, q.functionPostfix).many(), (obj, postfixes) => { + let result = obj; + for (let post of postfixes) { + switch (post.type) { + case "dot": + result = Fields.index(result, Fields.literal(post.field)); + break; + case "index": + result = Fields.index(result, post.field); + break; + case "function": + result = Fields.func(result, post.fields); + break; + } + } + return result; + }), + negatedField: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("!"), q.indexField, (_, field) => Fields.negate(field)).desc("negated field"), + parensField: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("("), parsimmon_umd_min.exports.optWhitespace, q.field, parsimmon_umd_min.exports.optWhitespace, parsimmon_umd_min.exports.string(")"), (_1, _2, field, _3, _4) => field), + lambdaField: (q) => parsimmon_umd_min.exports.seqMap(q.identifier.sepBy(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace)).wrap(parsimmon_umd_min.exports.string("(").trim(parsimmon_umd_min.exports.optWhitespace), parsimmon_umd_min.exports.string(")").trim(parsimmon_umd_min.exports.optWhitespace)), parsimmon_umd_min.exports.string("=>").trim(parsimmon_umd_min.exports.optWhitespace), q.field, (ident, _ignore, value) => { + return { type: "lambda", arguments: ident, value }; + }), + dotPostfix: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("."), q.identifier, (_, field) => { + return { type: "dot", field }; + }), + indexPostfix: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("["), parsimmon_umd_min.exports.optWhitespace, q.field, parsimmon_umd_min.exports.optWhitespace, parsimmon_umd_min.exports.string("]"), (_, _2, field, _3, _4) => { + return { type: "index", field }; + }), + functionPostfix: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.string("("), parsimmon_umd_min.exports.optWhitespace, q.field.sepBy(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace)), parsimmon_umd_min.exports.optWhitespace, parsimmon_umd_min.exports.string(")"), (_, _1, fields, _2, _3) => { + return { type: "function", fields }; + }), + binaryMulDivField: (q) => createBinaryParser(q.indexField, q.binaryMulDiv, Fields.binaryOp), + binaryPlusMinusField: (q) => createBinaryParser(q.binaryMulDivField, q.binaryPlusMinus, Fields.binaryOp), + binaryCompareField: (q) => createBinaryParser(q.binaryPlusMinusField, q.binaryCompareOp, Fields.binaryOp), + binaryBooleanField: (q) => createBinaryParser(q.binaryCompareField, q.binaryBooleanOp, Fields.binaryOp), + binaryOpField: (q) => q.binaryBooleanField, + field: (q) => q.binaryOpField + }); + function parseField(text) { + try { + return Result.success(EXPRESSION.field.tryParse(text)); + } catch (error) { + return Result.failure("" + error); + } + } + var QueryFields; + (function(QueryFields2) { + function named(name, field) { + return { name, field }; + } + QueryFields2.named = named; + function sortBy(field, dir) { + return { field, direction: dir }; + } + QueryFields2.sortBy = sortBy; + })(QueryFields || (QueryFields = {})); + function captureRaw(base) { + return parsimmon_umd_min.exports.custom((success, failure) => { + return (input, i) => { + let result = base._(input, i); + if (!result.status) + return result; + return Object.assign({}, result, { value: [result.value, input.substring(i, result.index)] }); + }; + }); + } + function stripNewlines(text) { + return text.split(/[\r\n]+/).map((t) => t.trim()).join(""); + } + var QUERY_LANGUAGE = parsimmon_umd_min.exports.createLanguage({ + queryType: (q) => parsimmon_umd_min.exports.alt(parsimmon_umd_min.exports.regexp(/TABLE|LIST|TASK|CALENDAR/i)).map((str) => str.toLowerCase()).desc("query type ('TABLE', 'LIST', 'TASK', or 'CALENDAR')"), + explicitNamedField: (q) => parsimmon_umd_min.exports.seqMap(EXPRESSION.field.skip(parsimmon_umd_min.exports.whitespace), parsimmon_umd_min.exports.regexp(/AS/i).skip(parsimmon_umd_min.exports.whitespace), EXPRESSION.identifier.or(EXPRESSION.string), (field, _as, ident) => QueryFields.named(ident, field)), + namedField: (q) => parsimmon_umd_min.exports.alt(q.explicitNamedField, captureRaw(EXPRESSION.field).map(([value, text]) => QueryFields.named(stripNewlines(text), value))), + sortField: (q) => parsimmon_umd_min.exports.seqMap(EXPRESSION.field.skip(parsimmon_umd_min.exports.optWhitespace), parsimmon_umd_min.exports.regexp(/ASCENDING|DESCENDING|ASC|DESC/i).atMost(1), (field, dir) => { + let direction = dir.length == 0 ? "ascending" : dir[0].toLowerCase(); + if (direction == "desc") + direction = "descending"; + if (direction == "asc") + direction = "ascending"; + return { + field, + direction + }; + }), + headerClause: (q) => q.queryType.skip(parsimmon_umd_min.exports.whitespace).chain((qtype) => { + switch (qtype) { + case "table": + return parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/WITHOUT\s+ID/i).skip(parsimmon_umd_min.exports.optWhitespace).atMost(1), parsimmon_umd_min.exports.sepBy(q.namedField, parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace)), (withoutId, fields) => { + return { type: "table", fields, showId: withoutId.length == 0 }; + }); + case "list": + return parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/WITHOUT\s+ID/i).skip(parsimmon_umd_min.exports.optWhitespace).atMost(1), EXPRESSION.field.atMost(1), (withoutId, format2) => { + return { + type: "list", + format: format2.length == 1 ? format2[0] : void 0, + showId: withoutId.length == 0 + }; + }); + case "task": + return parsimmon_umd_min.exports.succeed({ type: "task" }); + case "calendar": + return parsimmon_umd_min.exports.seqMap(q.namedField, (field) => { + return { + type: "calendar", + showId: true, + field + }; + }); + default: + return parsimmon_umd_min.exports.fail(`Unrecognized query type '${qtype}'`); + } + }).desc("TABLE or LIST or TASK or CALENDAR"), + fromClause: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/FROM/i), parsimmon_umd_min.exports.whitespace, EXPRESSION.source, (_1, _2, source) => source), + whereClause: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/WHERE/i), parsimmon_umd_min.exports.whitespace, EXPRESSION.field, (where, _, field) => { + return { type: "where", clause: field }; + }).desc("WHERE "), + sortByClause: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/SORT/i), parsimmon_umd_min.exports.whitespace, q.sortField.sepBy1(parsimmon_umd_min.exports.string(",").trim(parsimmon_umd_min.exports.optWhitespace)), (sort, _1, fields) => { + return { type: "sort", fields }; + }).desc("SORT field [ASC/DESC]"), + limitClause: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/LIMIT/i), parsimmon_umd_min.exports.whitespace, EXPRESSION.field, (limit, _1, field) => { + return { type: "limit", amount: field }; + }).desc("LIMIT "), + flattenClause: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/FLATTEN/i).skip(parsimmon_umd_min.exports.whitespace), q.namedField, (_, field) => { + return { type: "flatten", field }; + }).desc("FLATTEN [AS ]"), + groupByClause: (q) => parsimmon_umd_min.exports.seqMap(parsimmon_umd_min.exports.regexp(/GROUP BY/i).skip(parsimmon_umd_min.exports.whitespace), q.namedField, (_, field) => { + return { type: "group", field }; + }).desc("GROUP BY [AS ]"), + clause: (q) => parsimmon_umd_min.exports.alt(q.fromClause, q.whereClause, q.sortByClause, q.limitClause, q.groupByClause, q.flattenClause), + query: (q) => parsimmon_umd_min.exports.seqMap(q.headerClause.trim(parsimmon_umd_min.exports.optWhitespace), q.fromClause.trim(parsimmon_umd_min.exports.optWhitespace).atMost(1), q.clause.trim(parsimmon_umd_min.exports.optWhitespace).many(), (header, from, clauses) => { + return { + header, + source: from.length == 0 ? Sources.folder("") : from[0], + operations: clauses, + settings: DEFAULT_QUERY_SETTINGS + }; + }) + }); + var getAPI2 = (app) => { + var _a; + if (app) + return (_a = app.plugins.plugins.dataview) === null || _a === void 0 ? void 0 : _a.api; + else + return window.DataviewAPI; + }; + var isPluginEnabled = (app) => app.plugins.enabledPlugins.has("dataview"); + exports.DATE_SHORTHANDS = DATE_SHORTHANDS; + exports.DURATION_TYPES = DURATION_TYPES; + exports.EXPRESSION = EXPRESSION; + exports.KEYWORDS = KEYWORDS; + exports.QUERY_LANGUAGE = QUERY_LANGUAGE; + exports.getAPI = getAPI2; + exports.isPluginEnabled = isPluginEnabled; + exports.parseField = parseField; + } +}); + +// node_modules/lz-string/libs/lz-string.js +var require_lz_string = __commonJS({ + "node_modules/lz-string/libs/lz-string.js"(exports, module2) { + var LZString2 = function() { + var f = String.fromCharCode; + var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$"; + var baseReverseDic = {}; + function getBaseValue(alphabet, character) { + if (!baseReverseDic[alphabet]) { + baseReverseDic[alphabet] = {}; + for (var i = 0; i < alphabet.length; i++) { + baseReverseDic[alphabet][alphabet.charAt(i)] = i; + } + } + return baseReverseDic[alphabet][character]; + } + var LZString3 = { + compressToBase64: function(input) { + if (input == null) + return ""; + var res = LZString3._compress(input, 6, function(a) { + return keyStrBase64.charAt(a); + }); + switch (res.length % 4) { + default: + case 0: + return res; + case 1: + return res + "==="; + case 2: + return res + "=="; + case 3: + return res + "="; + } + }, + decompressFromBase64: function(input) { + if (input == null) + return ""; + if (input == "") + return null; + return LZString3._decompress(input.length, 32, function(index) { + return getBaseValue(keyStrBase64, input.charAt(index)); + }); + }, + compressToUTF16: function(input) { + if (input == null) + return ""; + return LZString3._compress(input, 15, function(a) { + return f(a + 32); + }) + " "; + }, + decompressFromUTF16: function(compressed) { + if (compressed == null) + return ""; + if (compressed == "") + return null; + return LZString3._decompress(compressed.length, 16384, function(index) { + return compressed.charCodeAt(index) - 32; + }); + }, + compressToUint8Array: function(uncompressed) { + var compressed = LZString3.compress(uncompressed); + var buf = new Uint8Array(compressed.length * 2); + for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) { + var current_value = compressed.charCodeAt(i); + buf[i * 2] = current_value >>> 8; + buf[i * 2 + 1] = current_value % 256; + } + return buf; + }, + decompressFromUint8Array: function(compressed) { + if (compressed === null || compressed === void 0) { + return LZString3.decompress(compressed); + } else { + var buf = new Array(compressed.length / 2); + for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) { + buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1]; + } + var result = []; + buf.forEach(function(c) { + result.push(f(c)); + }); + return LZString3.decompress(result.join("")); + } + }, + compressToEncodedURIComponent: function(input) { + if (input == null) + return ""; + return LZString3._compress(input, 6, function(a) { + return keyStrUriSafe.charAt(a); + }); + }, + decompressFromEncodedURIComponent: function(input) { + if (input == null) + return ""; + if (input == "") + return null; + input = input.replace(/ /g, "+"); + return LZString3._decompress(input.length, 32, function(index) { + return getBaseValue(keyStrUriSafe, input.charAt(index)); + }); + }, + compress: function(uncompressed) { + return LZString3._compress(uncompressed, 16, function(a) { + return f(a); + }); + }, + _compress: function(uncompressed, bitsPerChar, getCharFromInt) { + if (uncompressed == null) + return ""; + var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii; + for (ii = 0; ii < uncompressed.length; ii += 1) { + context_c = uncompressed.charAt(ii); + if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) { + context_dictionary[context_c] = context_dictSize++; + context_dictionaryToCreate[context_c] = true; + } + context_wc = context_w + context_c; + if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) { + context_w = context_wc; + } else { + if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) { + if (context_w.charCodeAt(0) < 256) { + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + } + value = context_w.charCodeAt(0); + for (i = 0; i < 8; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + } else { + value = 1; + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1 | value; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = 0; + } + value = context_w.charCodeAt(0); + for (i = 0; i < 16; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + } + context_enlargeIn--; + if (context_enlargeIn == 0) { + context_enlargeIn = Math.pow(2, context_numBits); + context_numBits++; + } + delete context_dictionaryToCreate[context_w]; + } else { + value = context_dictionary[context_w]; + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + } + context_enlargeIn--; + if (context_enlargeIn == 0) { + context_enlargeIn = Math.pow(2, context_numBits); + context_numBits++; + } + context_dictionary[context_wc] = context_dictSize++; + context_w = String(context_c); + } + } + if (context_w !== "") { + if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) { + if (context_w.charCodeAt(0) < 256) { + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + } + value = context_w.charCodeAt(0); + for (i = 0; i < 8; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + } else { + value = 1; + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1 | value; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = 0; + } + value = context_w.charCodeAt(0); + for (i = 0; i < 16; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + } + context_enlargeIn--; + if (context_enlargeIn == 0) { + context_enlargeIn = Math.pow(2, context_numBits); + context_numBits++; + } + delete context_dictionaryToCreate[context_w]; + } else { + value = context_dictionary[context_w]; + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + } + context_enlargeIn--; + if (context_enlargeIn == 0) { + context_enlargeIn = Math.pow(2, context_numBits); + context_numBits++; + } + } + value = 2; + for (i = 0; i < context_numBits; i++) { + context_data_val = context_data_val << 1 | value & 1; + if (context_data_position == bitsPerChar - 1) { + context_data_position = 0; + context_data.push(getCharFromInt(context_data_val)); + context_data_val = 0; + } else { + context_data_position++; + } + value = value >> 1; + } + while (true) { + context_data_val = context_data_val << 1; + if (context_data_position == bitsPerChar - 1) { + context_data.push(getCharFromInt(context_data_val)); + break; + } else + context_data_position++; + } + return context_data.join(""); + }, + decompress: function(compressed) { + if (compressed == null) + return ""; + if (compressed == "") + return null; + return LZString3._decompress(compressed.length, 32768, function(index) { + return compressed.charCodeAt(index); + }); + }, + _decompress: function(length, resetValue, getNextValue) { + var dictionary = [], next, enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i, w, bits, resb, maxpower, power, c, data = { val: getNextValue(0), position: resetValue, index: 1 }; + for (i = 0; i < 3; i += 1) { + dictionary[i] = i; + } + bits = 0; + maxpower = Math.pow(2, 2); + power = 1; + while (power != maxpower) { + resb = data.val & data.position; + data.position >>= 1; + if (data.position == 0) { + data.position = resetValue; + data.val = getNextValue(data.index++); + } + bits |= (resb > 0 ? 1 : 0) * power; + power <<= 1; + } + switch (next = bits) { + case 0: + bits = 0; + maxpower = Math.pow(2, 8); + power = 1; + while (power != maxpower) { + resb = data.val & data.position; + data.position >>= 1; + if (data.position == 0) { + data.position = resetValue; + data.val = getNextValue(data.index++); + } + bits |= (resb > 0 ? 1 : 0) * power; + power <<= 1; + } + c = f(bits); + break; + case 1: + bits = 0; + maxpower = Math.pow(2, 16); + power = 1; + while (power != maxpower) { + resb = data.val & data.position; + data.position >>= 1; + if (data.position == 0) { + data.position = resetValue; + data.val = getNextValue(data.index++); + } + bits |= (resb > 0 ? 1 : 0) * power; + power <<= 1; + } + c = f(bits); + break; + case 2: + return ""; + } + dictionary[3] = c; + w = c; + result.push(c); + while (true) { + if (data.index > length) { + return ""; + } + bits = 0; + maxpower = Math.pow(2, numBits); + power = 1; + while (power != maxpower) { + resb = data.val & data.position; + data.position >>= 1; + if (data.position == 0) { + data.position = resetValue; + data.val = getNextValue(data.index++); + } + bits |= (resb > 0 ? 1 : 0) * power; + power <<= 1; + } + switch (c = bits) { + case 0: + bits = 0; + maxpower = Math.pow(2, 8); + power = 1; + while (power != maxpower) { + resb = data.val & data.position; + data.position >>= 1; + if (data.position == 0) { + data.position = resetValue; + data.val = getNextValue(data.index++); + } + bits |= (resb > 0 ? 1 : 0) * power; + power <<= 1; + } + dictionary[dictSize++] = f(bits); + c = dictSize - 1; + enlargeIn--; + break; + case 1: + bits = 0; + maxpower = Math.pow(2, 16); + power = 1; + while (power != maxpower) { + resb = data.val & data.position; + data.position >>= 1; + if (data.position == 0) { + data.position = resetValue; + data.val = getNextValue(data.index++); + } + bits |= (resb > 0 ? 1 : 0) * power; + power <<= 1; + } + dictionary[dictSize++] = f(bits); + c = dictSize - 1; + enlargeIn--; + break; + case 2: + return result.join(""); + } + if (enlargeIn == 0) { + enlargeIn = Math.pow(2, numBits); + numBits++; + } + if (dictionary[c]) { + entry = dictionary[c]; + } else { + if (c === dictSize) { + entry = w + w.charAt(0); + } else { + return null; + } + } + result.push(entry); + dictionary[dictSize++] = w + entry.charAt(0); + enlargeIn--; + w = entry; + if (enlargeIn == 0) { + enlargeIn = Math.pow(2, numBits); + numBits++; + } + } + } + }; + return LZString3; + }(); + if (typeof define === "function" && define.amd) { + define(function() { + return LZString2; + }); + } else if (typeof module2 !== "undefined" && module2 != null) { + module2.exports = LZString2; + } + } +}); + +// node_modules/axios/lib/helpers/bind.js +var require_bind = __commonJS({ + "node_modules/axios/lib/helpers/bind.js"(exports, module2) { + "use strict"; + module2.exports = function bind(fn2, thisArg) { + return function wrap() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + return fn2.apply(thisArg, args); + }; + }; + } +}); + +// node_modules/axios/lib/utils.js +var require_utils = __commonJS({ + "node_modules/axios/lib/utils.js"(exports, module2) { + "use strict"; + var bind = require_bind(); + var toString = Object.prototype.toString; + function isArray(val) { + return Array.isArray(val); + } + function isUndefined2(val) { + return typeof val === "undefined"; + } + function isBuffer(val) { + return val !== null && !isUndefined2(val) && val.constructor !== null && !isUndefined2(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val); + } + function isArrayBuffer(val) { + return toString.call(val) === "[object ArrayBuffer]"; + } + function isFormData(val) { + return toString.call(val) === "[object FormData]"; + } + function isArrayBufferView(val) { + var result; + if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) { + result = ArrayBuffer.isView(val); + } else { + result = val && val.buffer && isArrayBuffer(val.buffer); + } + return result; + } + function isString2(val) { + return typeof val === "string"; + } + function isNumber2(val) { + return typeof val === "number"; + } + function isObject2(val) { + return val !== null && typeof val === "object"; + } + function isPlainObject2(val) { + if (toString.call(val) !== "[object Object]") { + return false; + } + var prototype = Object.getPrototypeOf(val); + return prototype === null || prototype === Object.prototype; + } + function isDate2(val) { + return toString.call(val) === "[object Date]"; + } + function isFile(val) { + return toString.call(val) === "[object File]"; + } + function isBlob(val) { + return toString.call(val) === "[object Blob]"; + } + function isFunction(val) { + return toString.call(val) === "[object Function]"; + } + function isStream(val) { + return isObject2(val) && isFunction(val.pipe); + } + function isURLSearchParams(val) { + return toString.call(val) === "[object URLSearchParams]"; + } + function trim(str) { + return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, ""); + } + function isStandardBrowserEnv() { + if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) { + return false; + } + return typeof window !== "undefined" && typeof document !== "undefined"; + } + function forEach(obj, fn2) { + if (obj === null || typeof obj === "undefined") { + return; + } + if (typeof obj !== "object") { + obj = [obj]; + } + if (isArray(obj)) { + for (var i = 0, l2 = obj.length; i < l2; i++) { + fn2.call(null, obj[i], i, obj); + } + } else { + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + fn2.call(null, obj[key], key, obj); + } + } + } + } + function merge2() { + var result = {}; + function assignValue(val, key) { + if (isPlainObject2(result[key]) && isPlainObject2(val)) { + result[key] = merge2(result[key], val); + } else if (isPlainObject2(val)) { + result[key] = merge2({}, val); + } else if (isArray(val)) { + result[key] = val.slice(); + } else { + result[key] = val; + } + } + for (var i = 0, l2 = arguments.length; i < l2; i++) { + forEach(arguments[i], assignValue); + } + return result; + } + function extend(a, b, thisArg) { + forEach(b, function assignValue(val, key) { + if (thisArg && typeof val === "function") { + a[key] = bind(val, thisArg); + } else { + a[key] = val; + } + }); + return a; + } + function stripBOM(content) { + if (content.charCodeAt(0) === 65279) { + content = content.slice(1); + } + return content; + } + module2.exports = { + isArray, + isArrayBuffer, + isBuffer, + isFormData, + isArrayBufferView, + isString: isString2, + isNumber: isNumber2, + isObject: isObject2, + isPlainObject: isPlainObject2, + isUndefined: isUndefined2, + isDate: isDate2, + isFile, + isBlob, + isFunction, + isStream, + isURLSearchParams, + isStandardBrowserEnv, + forEach, + merge: merge2, + extend, + trim, + stripBOM + }; + } +}); + +// node_modules/axios/lib/helpers/buildURL.js +var require_buildURL = __commonJS({ + "node_modules/axios/lib/helpers/buildURL.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + function encode2(val) { + return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]"); + } + module2.exports = function buildURL(url, params, paramsSerializer) { + if (!params) { + return url; + } + var serializedParams; + if (paramsSerializer) { + serializedParams = paramsSerializer(params); + } else if (utils.isURLSearchParams(params)) { + serializedParams = params.toString(); + } else { + var parts = []; + utils.forEach(params, function serialize(val, key) { + if (val === null || typeof val === "undefined") { + return; + } + if (utils.isArray(val)) { + key = key + "[]"; + } else { + val = [val]; + } + utils.forEach(val, function parseValue(v) { + if (utils.isDate(v)) { + v = v.toISOString(); + } else if (utils.isObject(v)) { + v = JSON.stringify(v); + } + parts.push(encode2(key) + "=" + encode2(v)); + }); + }); + serializedParams = parts.join("&"); + } + if (serializedParams) { + var hashmarkIndex = url.indexOf("#"); + if (hashmarkIndex !== -1) { + url = url.slice(0, hashmarkIndex); + } + url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams; + } + return url; + }; + } +}); + +// node_modules/axios/lib/core/InterceptorManager.js +var require_InterceptorManager = __commonJS({ + "node_modules/axios/lib/core/InterceptorManager.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + function InterceptorManager() { + this.handlers = []; + } + InterceptorManager.prototype.use = function use(fulfilled, rejected, options) { + this.handlers.push({ + fulfilled, + rejected, + synchronous: options ? options.synchronous : false, + runWhen: options ? options.runWhen : null + }); + return this.handlers.length - 1; + }; + InterceptorManager.prototype.eject = function eject(id) { + if (this.handlers[id]) { + this.handlers[id] = null; + } + }; + InterceptorManager.prototype.forEach = function forEach(fn2) { + utils.forEach(this.handlers, function forEachHandler(h) { + if (h !== null) { + fn2(h); + } + }); + }; + module2.exports = InterceptorManager; + } +}); + +// node_modules/axios/lib/helpers/normalizeHeaderName.js +var require_normalizeHeaderName = __commonJS({ + "node_modules/axios/lib/helpers/normalizeHeaderName.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + module2.exports = function normalizeHeaderName(headers, normalizedName) { + utils.forEach(headers, function processHeader(value, name) { + if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { + headers[normalizedName] = value; + delete headers[name]; + } + }); + }; + } +}); + +// node_modules/axios/lib/core/enhanceError.js +var require_enhanceError = __commonJS({ + "node_modules/axios/lib/core/enhanceError.js"(exports, module2) { + "use strict"; + module2.exports = function enhanceError(error, config, code, request2, response) { + error.config = config; + if (code) { + error.code = code; + } + error.request = request2; + error.response = response; + error.isAxiosError = true; + error.toJSON = function toJSON() { + return { + message: this.message, + name: this.name, + description: this.description, + number: this.number, + fileName: this.fileName, + lineNumber: this.lineNumber, + columnNumber: this.columnNumber, + stack: this.stack, + config: this.config, + code: this.code, + status: this.response && this.response.status ? this.response.status : null + }; + }; + return error; + }; + } +}); + +// node_modules/axios/lib/defaults/transitional.js +var require_transitional = __commonJS({ + "node_modules/axios/lib/defaults/transitional.js"(exports, module2) { + "use strict"; + module2.exports = { + silentJSONParsing: true, + forcedJSONParsing: true, + clarifyTimeoutError: false + }; + } +}); + +// node_modules/axios/lib/core/createError.js +var require_createError = __commonJS({ + "node_modules/axios/lib/core/createError.js"(exports, module2) { + "use strict"; + var enhanceError = require_enhanceError(); + module2.exports = function createError(message, config, code, request2, response) { + var error = new Error(message); + return enhanceError(error, config, code, request2, response); + }; + } +}); + +// node_modules/axios/lib/core/settle.js +var require_settle = __commonJS({ + "node_modules/axios/lib/core/settle.js"(exports, module2) { + "use strict"; + var createError = require_createError(); + module2.exports = function settle(resolve, reject, response) { + var validateStatus = response.config.validateStatus; + if (!response.status || !validateStatus || validateStatus(response.status)) { + resolve(response); + } else { + reject(createError("Request failed with status code " + response.status, response.config, null, response.request, response)); + } + }; + } +}); + +// node_modules/axios/lib/helpers/cookies.js +var require_cookies = __commonJS({ + "node_modules/axios/lib/helpers/cookies.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + module2.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() { + return { + write: function write2(name, value, expires, path, domain, secure) { + var cookie = []; + cookie.push(name + "=" + encodeURIComponent(value)); + if (utils.isNumber(expires)) { + cookie.push("expires=" + new Date(expires).toGMTString()); + } + if (utils.isString(path)) { + cookie.push("path=" + path); + } + if (utils.isString(domain)) { + cookie.push("domain=" + domain); + } + if (secure === true) { + cookie.push("secure"); + } + document.cookie = cookie.join("; "); + }, + read: function read2(name) { + var match2 = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)")); + return match2 ? decodeURIComponent(match2[3]) : null; + }, + remove: function remove(name) { + this.write(name, "", Date.now() - 864e5); + } + }; + }() : function nonStandardBrowserEnv() { + return { + write: function write2() { + }, + read: function read2() { + return null; + }, + remove: function remove() { + } + }; + }(); + } +}); + +// node_modules/axios/lib/helpers/isAbsoluteURL.js +var require_isAbsoluteURL = __commonJS({ + "node_modules/axios/lib/helpers/isAbsoluteURL.js"(exports, module2) { + "use strict"; + module2.exports = function isAbsoluteURL(url) { + return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url); + }; + } +}); + +// node_modules/axios/lib/helpers/combineURLs.js +var require_combineURLs = __commonJS({ + "node_modules/axios/lib/helpers/combineURLs.js"(exports, module2) { + "use strict"; + module2.exports = function combineURLs(baseURL, relativeURL) { + return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL; + }; + } +}); + +// node_modules/axios/lib/core/buildFullPath.js +var require_buildFullPath = __commonJS({ + "node_modules/axios/lib/core/buildFullPath.js"(exports, module2) { + "use strict"; + var isAbsoluteURL = require_isAbsoluteURL(); + var combineURLs = require_combineURLs(); + module2.exports = function buildFullPath(baseURL, requestedURL) { + if (baseURL && !isAbsoluteURL(requestedURL)) { + return combineURLs(baseURL, requestedURL); + } + return requestedURL; + }; + } +}); + +// node_modules/axios/lib/helpers/parseHeaders.js +var require_parseHeaders = __commonJS({ + "node_modules/axios/lib/helpers/parseHeaders.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var ignoreDuplicateOf = [ + "age", + "authorization", + "content-length", + "content-type", + "etag", + "expires", + "from", + "host", + "if-modified-since", + "if-unmodified-since", + "last-modified", + "location", + "max-forwards", + "proxy-authorization", + "referer", + "retry-after", + "user-agent" + ]; + module2.exports = function parseHeaders(headers) { + var parsed = {}; + var key; + var val; + var i; + if (!headers) { + return parsed; + } + utils.forEach(headers.split("\n"), function parser(line) { + i = line.indexOf(":"); + key = utils.trim(line.substr(0, i)).toLowerCase(); + val = utils.trim(line.substr(i + 1)); + if (key) { + if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) { + return; + } + if (key === "set-cookie") { + parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]); + } else { + parsed[key] = parsed[key] ? parsed[key] + ", " + val : val; + } + } + }); + return parsed; + }; + } +}); + +// node_modules/axios/lib/helpers/isURLSameOrigin.js +var require_isURLSameOrigin = __commonJS({ + "node_modules/axios/lib/helpers/isURLSameOrigin.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + module2.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() { + var msie = /(msie|trident)/i.test(navigator.userAgent); + var urlParsingNode = document.createElement("a"); + var originURL; + function resolveURL(url) { + var href = url; + if (msie) { + urlParsingNode.setAttribute("href", href); + href = urlParsingNode.href; + } + urlParsingNode.setAttribute("href", href); + return { + href: urlParsingNode.href, + protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "", + host: urlParsingNode.host, + search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "", + hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "", + hostname: urlParsingNode.hostname, + port: urlParsingNode.port, + pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname + }; + } + originURL = resolveURL(window.location.href); + return function isURLSameOrigin(requestURL) { + var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL; + return parsed.protocol === originURL.protocol && parsed.host === originURL.host; + }; + }() : function nonStandardBrowserEnv() { + return function isURLSameOrigin() { + return true; + }; + }(); + } +}); + +// node_modules/axios/lib/cancel/Cancel.js +var require_Cancel = __commonJS({ + "node_modules/axios/lib/cancel/Cancel.js"(exports, module2) { + "use strict"; + function Cancel(message) { + this.message = message; + } + Cancel.prototype.toString = function toString() { + return "Cancel" + (this.message ? ": " + this.message : ""); + }; + Cancel.prototype.__CANCEL__ = true; + module2.exports = Cancel; + } +}); + +// node_modules/axios/lib/adapters/xhr.js +var require_xhr = __commonJS({ + "node_modules/axios/lib/adapters/xhr.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var settle = require_settle(); + var cookies = require_cookies(); + var buildURL = require_buildURL(); + var buildFullPath = require_buildFullPath(); + var parseHeaders = require_parseHeaders(); + var isURLSameOrigin = require_isURLSameOrigin(); + var createError = require_createError(); + var transitionalDefaults = require_transitional(); + var Cancel = require_Cancel(); + module2.exports = function xhrAdapter(config) { + return new Promise(function dispatchXhrRequest(resolve, reject) { + var requestData = config.data; + var requestHeaders = config.headers; + var responseType = config.responseType; + var onCanceled; + function done() { + if (config.cancelToken) { + config.cancelToken.unsubscribe(onCanceled); + } + if (config.signal) { + config.signal.removeEventListener("abort", onCanceled); + } + } + if (utils.isFormData(requestData)) { + delete requestHeaders["Content-Type"]; + } + var request2 = new XMLHttpRequest(); + if (config.auth) { + var username = config.auth.username || ""; + var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : ""; + requestHeaders.Authorization = "Basic " + btoa(username + ":" + password); + } + var fullPath = buildFullPath(config.baseURL, config.url); + request2.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true); + request2.timeout = config.timeout; + function onloadend() { + if (!request2) { + return; + } + var responseHeaders = "getAllResponseHeaders" in request2 ? parseHeaders(request2.getAllResponseHeaders()) : null; + var responseData = !responseType || responseType === "text" || responseType === "json" ? request2.responseText : request2.response; + var response = { + data: responseData, + status: request2.status, + statusText: request2.statusText, + headers: responseHeaders, + config, + request: request2 + }; + settle(function _resolve(value) { + resolve(value); + done(); + }, function _reject(err) { + reject(err); + done(); + }, response); + request2 = null; + } + if ("onloadend" in request2) { + request2.onloadend = onloadend; + } else { + request2.onreadystatechange = function handleLoad() { + if (!request2 || request2.readyState !== 4) { + return; + } + if (request2.status === 0 && !(request2.responseURL && request2.responseURL.indexOf("file:") === 0)) { + return; + } + setTimeout(onloadend); + }; + } + request2.onabort = function handleAbort() { + if (!request2) { + return; + } + reject(createError("Request aborted", config, "ECONNABORTED", request2)); + request2 = null; + }; + request2.onerror = function handleError() { + reject(createError("Network Error", config, null, request2)); + request2 = null; + }; + request2.ontimeout = function handleTimeout() { + var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded"; + var transitional = config.transitional || transitionalDefaults; + if (config.timeoutErrorMessage) { + timeoutErrorMessage = config.timeoutErrorMessage; + } + reject(createError(timeoutErrorMessage, config, transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request2)); + request2 = null; + }; + if (utils.isStandardBrowserEnv()) { + var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0; + if (xsrfValue) { + requestHeaders[config.xsrfHeaderName] = xsrfValue; + } + } + if ("setRequestHeader" in request2) { + utils.forEach(requestHeaders, function setRequestHeader(val, key) { + if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") { + delete requestHeaders[key]; + } else { + request2.setRequestHeader(key, val); + } + }); + } + if (!utils.isUndefined(config.withCredentials)) { + request2.withCredentials = !!config.withCredentials; + } + if (responseType && responseType !== "json") { + request2.responseType = config.responseType; + } + if (typeof config.onDownloadProgress === "function") { + request2.addEventListener("progress", config.onDownloadProgress); + } + if (typeof config.onUploadProgress === "function" && request2.upload) { + request2.upload.addEventListener("progress", config.onUploadProgress); + } + if (config.cancelToken || config.signal) { + onCanceled = function(cancel) { + if (!request2) { + return; + } + reject(!cancel || cancel && cancel.type ? new Cancel("canceled") : cancel); + request2.abort(); + request2 = null; + }; + config.cancelToken && config.cancelToken.subscribe(onCanceled); + if (config.signal) { + config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled); + } + } + if (!requestData) { + requestData = null; + } + request2.send(requestData); + }); + }; + } +}); + +// node_modules/axios/lib/defaults/index.js +var require_defaults = __commonJS({ + "node_modules/axios/lib/defaults/index.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var normalizeHeaderName = require_normalizeHeaderName(); + var enhanceError = require_enhanceError(); + var transitionalDefaults = require_transitional(); + var DEFAULT_CONTENT_TYPE = { + "Content-Type": "application/x-www-form-urlencoded" + }; + function setContentTypeIfUnset(headers, value) { + if (!utils.isUndefined(headers) && utils.isUndefined(headers["Content-Type"])) { + headers["Content-Type"] = value; + } + } + function getDefaultAdapter() { + var adapter; + if (typeof XMLHttpRequest !== "undefined") { + adapter = require_xhr(); + } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") { + adapter = require_xhr(); + } + return adapter; + } + function stringifySafely(rawValue, parser, encoder) { + if (utils.isString(rawValue)) { + try { + (parser || JSON.parse)(rawValue); + return utils.trim(rawValue); + } catch (e) { + if (e.name !== "SyntaxError") { + throw e; + } + } + } + return (encoder || JSON.stringify)(rawValue); + } + var defaults = { + transitional: transitionalDefaults, + adapter: getDefaultAdapter(), + transformRequest: [function transformRequest(data, headers) { + normalizeHeaderName(headers, "Accept"); + normalizeHeaderName(headers, "Content-Type"); + if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) { + return data; + } + if (utils.isArrayBufferView(data)) { + return data.buffer; + } + if (utils.isURLSearchParams(data)) { + setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8"); + return data.toString(); + } + if (utils.isObject(data) || headers && headers["Content-Type"] === "application/json") { + setContentTypeIfUnset(headers, "application/json"); + return stringifySafely(data); + } + return data; + }], + transformResponse: [function transformResponse(data) { + var transitional = this.transitional || defaults.transitional; + var silentJSONParsing = transitional && transitional.silentJSONParsing; + var forcedJSONParsing = transitional && transitional.forcedJSONParsing; + var strictJSONParsing = !silentJSONParsing && this.responseType === "json"; + if (strictJSONParsing || forcedJSONParsing && utils.isString(data) && data.length) { + try { + return JSON.parse(data); + } catch (e) { + if (strictJSONParsing) { + if (e.name === "SyntaxError") { + throw enhanceError(e, this, "E_JSON_PARSE"); + } + throw e; + } + } + } + return data; + }], + timeout: 0, + xsrfCookieName: "XSRF-TOKEN", + xsrfHeaderName: "X-XSRF-TOKEN", + maxContentLength: -1, + maxBodyLength: -1, + validateStatus: function validateStatus(status) { + return status >= 200 && status < 300; + }, + headers: { + common: { + "Accept": "application/json, text/plain, */*" + } + } + }; + utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) { + defaults.headers[method] = {}; + }); + utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) { + defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); + }); + module2.exports = defaults; + } +}); + +// node_modules/axios/lib/core/transformData.js +var require_transformData = __commonJS({ + "node_modules/axios/lib/core/transformData.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var defaults = require_defaults(); + module2.exports = function transformData(data, headers, fns) { + var context = this || defaults; + utils.forEach(fns, function transform(fn2) { + data = fn2.call(context, data, headers); + }); + return data; + }; + } +}); + +// node_modules/axios/lib/cancel/isCancel.js +var require_isCancel = __commonJS({ + "node_modules/axios/lib/cancel/isCancel.js"(exports, module2) { + "use strict"; + module2.exports = function isCancel(value) { + return !!(value && value.__CANCEL__); + }; + } +}); + +// node_modules/axios/lib/core/dispatchRequest.js +var require_dispatchRequest = __commonJS({ + "node_modules/axios/lib/core/dispatchRequest.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var transformData = require_transformData(); + var isCancel = require_isCancel(); + var defaults = require_defaults(); + var Cancel = require_Cancel(); + function throwIfCancellationRequested(config) { + if (config.cancelToken) { + config.cancelToken.throwIfRequested(); + } + if (config.signal && config.signal.aborted) { + throw new Cancel("canceled"); + } + } + module2.exports = function dispatchRequest(config) { + throwIfCancellationRequested(config); + config.headers = config.headers || {}; + config.data = transformData.call(config, config.data, config.headers, config.transformRequest); + config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers); + utils.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) { + delete config.headers[method]; + }); + var adapter = config.adapter || defaults.adapter; + return adapter(config).then(function onAdapterResolution(response) { + throwIfCancellationRequested(config); + response.data = transformData.call(config, response.data, response.headers, config.transformResponse); + return response; + }, function onAdapterRejection(reason) { + if (!isCancel(reason)) { + throwIfCancellationRequested(config); + if (reason && reason.response) { + reason.response.data = transformData.call(config, reason.response.data, reason.response.headers, config.transformResponse); + } + } + return Promise.reject(reason); + }); + }; + } +}); + +// node_modules/axios/lib/core/mergeConfig.js +var require_mergeConfig = __commonJS({ + "node_modules/axios/lib/core/mergeConfig.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + module2.exports = function mergeConfig(config1, config2) { + config2 = config2 || {}; + var config = {}; + function getMergedValue(target, source) { + if (utils.isPlainObject(target) && utils.isPlainObject(source)) { + return utils.merge(target, source); + } else if (utils.isPlainObject(source)) { + return utils.merge({}, source); + } else if (utils.isArray(source)) { + return source.slice(); + } + return source; + } + function mergeDeepProperties(prop) { + if (!utils.isUndefined(config2[prop])) { + return getMergedValue(config1[prop], config2[prop]); + } else if (!utils.isUndefined(config1[prop])) { + return getMergedValue(void 0, config1[prop]); + } + } + function valueFromConfig2(prop) { + if (!utils.isUndefined(config2[prop])) { + return getMergedValue(void 0, config2[prop]); + } + } + function defaultToConfig2(prop) { + if (!utils.isUndefined(config2[prop])) { + return getMergedValue(void 0, config2[prop]); + } else if (!utils.isUndefined(config1[prop])) { + return getMergedValue(void 0, config1[prop]); + } + } + function mergeDirectKeys(prop) { + if (prop in config2) { + return getMergedValue(config1[prop], config2[prop]); + } else if (prop in config1) { + return getMergedValue(void 0, config1[prop]); + } + } + var mergeMap = { + "url": valueFromConfig2, + "method": valueFromConfig2, + "data": valueFromConfig2, + "baseURL": defaultToConfig2, + "transformRequest": defaultToConfig2, + "transformResponse": defaultToConfig2, + "paramsSerializer": defaultToConfig2, + "timeout": defaultToConfig2, + "timeoutMessage": defaultToConfig2, + "withCredentials": defaultToConfig2, + "adapter": defaultToConfig2, + "responseType": defaultToConfig2, + "xsrfCookieName": defaultToConfig2, + "xsrfHeaderName": defaultToConfig2, + "onUploadProgress": defaultToConfig2, + "onDownloadProgress": defaultToConfig2, + "decompress": defaultToConfig2, + "maxContentLength": defaultToConfig2, + "maxBodyLength": defaultToConfig2, + "transport": defaultToConfig2, + "httpAgent": defaultToConfig2, + "httpsAgent": defaultToConfig2, + "cancelToken": defaultToConfig2, + "socketPath": defaultToConfig2, + "responseEncoding": defaultToConfig2, + "validateStatus": mergeDirectKeys + }; + utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) { + var merge2 = mergeMap[prop] || mergeDeepProperties; + var configValue = merge2(prop); + utils.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue); + }); + return config; + }; + } +}); + +// node_modules/axios/lib/env/data.js +var require_data = __commonJS({ + "node_modules/axios/lib/env/data.js"(exports, module2) { + module2.exports = { + "version": "0.26.1" + }; + } +}); + +// node_modules/axios/lib/helpers/validator.js +var require_validator = __commonJS({ + "node_modules/axios/lib/helpers/validator.js"(exports, module2) { + "use strict"; + var VERSION6 = require_data().version; + var validators = {}; + ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) { + validators[type] = function validator(thing) { + return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type; + }; + }); + var deprecatedWarnings = {}; + validators.transitional = function transitional(validator, version2, message) { + function formatMessage(opt, desc) { + return "[Axios v" + VERSION6 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : ""); + } + return function(value, opt, opts) { + if (validator === false) { + throw new Error(formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : ""))); + } + if (version2 && !deprecatedWarnings[opt]) { + deprecatedWarnings[opt] = true; + console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future")); + } + return validator ? validator(value, opt, opts) : true; + }; + }; + function assertOptions(options, schema, allowUnknown) { + if (typeof options !== "object") { + throw new TypeError("options must be an object"); + } + var keys = Object.keys(options); + var i = keys.length; + while (i-- > 0) { + var opt = keys[i]; + var validator = schema[opt]; + if (validator) { + var value = options[opt]; + var result = value === void 0 || validator(value, opt, options); + if (result !== true) { + throw new TypeError("option " + opt + " must be " + result); + } + continue; + } + if (allowUnknown !== true) { + throw Error("Unknown option " + opt); + } + } + } + module2.exports = { + assertOptions, + validators + }; + } +}); + +// node_modules/axios/lib/core/Axios.js +var require_Axios = __commonJS({ + "node_modules/axios/lib/core/Axios.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var buildURL = require_buildURL(); + var InterceptorManager = require_InterceptorManager(); + var dispatchRequest = require_dispatchRequest(); + var mergeConfig = require_mergeConfig(); + var validator = require_validator(); + var validators = validator.validators; + function Axios(instanceConfig) { + this.defaults = instanceConfig; + this.interceptors = { + request: new InterceptorManager(), + response: new InterceptorManager() + }; + } + Axios.prototype.request = function request2(configOrUrl, config) { + if (typeof configOrUrl === "string") { + config = config || {}; + config.url = configOrUrl; + } else { + config = configOrUrl || {}; + } + config = mergeConfig(this.defaults, config); + if (config.method) { + config.method = config.method.toLowerCase(); + } else if (this.defaults.method) { + config.method = this.defaults.method.toLowerCase(); + } else { + config.method = "get"; + } + var transitional = config.transitional; + if (transitional !== void 0) { + validator.assertOptions(transitional, { + silentJSONParsing: validators.transitional(validators.boolean), + forcedJSONParsing: validators.transitional(validators.boolean), + clarifyTimeoutError: validators.transitional(validators.boolean) + }, false); + } + var requestInterceptorChain = []; + var synchronousRequestInterceptors = true; + this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { + if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) { + return; + } + synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous; + requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected); + }); + var responseInterceptorChain = []; + this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { + responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected); + }); + var promise; + if (!synchronousRequestInterceptors) { + var chain = [dispatchRequest, void 0]; + Array.prototype.unshift.apply(chain, requestInterceptorChain); + chain = chain.concat(responseInterceptorChain); + promise = Promise.resolve(config); + while (chain.length) { + promise = promise.then(chain.shift(), chain.shift()); + } + return promise; + } + var newConfig = config; + while (requestInterceptorChain.length) { + var onFulfilled = requestInterceptorChain.shift(); + var onRejected = requestInterceptorChain.shift(); + try { + newConfig = onFulfilled(newConfig); + } catch (error) { + onRejected(error); + break; + } + } + try { + promise = dispatchRequest(newConfig); + } catch (error) { + return Promise.reject(error); + } + while (responseInterceptorChain.length) { + promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift()); + } + return promise; + }; + Axios.prototype.getUri = function getUri(config) { + config = mergeConfig(this.defaults, config); + return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, ""); + }; + utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) { + Axios.prototype[method] = function(url, config) { + return this.request(mergeConfig(config || {}, { + method, + url, + data: (config || {}).data + })); + }; + }); + utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) { + Axios.prototype[method] = function(url, data, config) { + return this.request(mergeConfig(config || {}, { + method, + url, + data + })); + }; + }); + module2.exports = Axios; + } +}); + +// node_modules/axios/lib/cancel/CancelToken.js +var require_CancelToken = __commonJS({ + "node_modules/axios/lib/cancel/CancelToken.js"(exports, module2) { + "use strict"; + var Cancel = require_Cancel(); + function CancelToken(executor) { + if (typeof executor !== "function") { + throw new TypeError("executor must be a function."); + } + var resolvePromise; + this.promise = new Promise(function promiseExecutor(resolve) { + resolvePromise = resolve; + }); + var token = this; + this.promise.then(function(cancel) { + if (!token._listeners) + return; + var i; + var l2 = token._listeners.length; + for (i = 0; i < l2; i++) { + token._listeners[i](cancel); + } + token._listeners = null; + }); + this.promise.then = function(onfulfilled) { + var _resolve; + var promise = new Promise(function(resolve) { + token.subscribe(resolve); + _resolve = resolve; + }).then(onfulfilled); + promise.cancel = function reject() { + token.unsubscribe(_resolve); + }; + return promise; + }; + executor(function cancel(message) { + if (token.reason) { + return; + } + token.reason = new Cancel(message); + resolvePromise(token.reason); + }); + } + CancelToken.prototype.throwIfRequested = function throwIfRequested() { + if (this.reason) { + throw this.reason; + } + }; + CancelToken.prototype.subscribe = function subscribe(listener) { + if (this.reason) { + listener(this.reason); + return; + } + if (this._listeners) { + this._listeners.push(listener); + } else { + this._listeners = [listener]; + } + }; + CancelToken.prototype.unsubscribe = function unsubscribe(listener) { + if (!this._listeners) { + return; + } + var index = this._listeners.indexOf(listener); + if (index !== -1) { + this._listeners.splice(index, 1); + } + }; + CancelToken.source = function source() { + var cancel; + var token = new CancelToken(function executor(c) { + cancel = c; + }); + return { + token, + cancel + }; + }; + module2.exports = CancelToken; + } +}); + +// node_modules/axios/lib/helpers/spread.js +var require_spread = __commonJS({ + "node_modules/axios/lib/helpers/spread.js"(exports, module2) { + "use strict"; + module2.exports = function spread(callback) { + return function wrap(arr) { + return callback.apply(null, arr); + }; + }; + } +}); + +// node_modules/axios/lib/helpers/isAxiosError.js +var require_isAxiosError = __commonJS({ + "node_modules/axios/lib/helpers/isAxiosError.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + module2.exports = function isAxiosError(payload) { + return utils.isObject(payload) && payload.isAxiosError === true; + }; + } +}); + +// node_modules/axios/lib/axios.js +var require_axios = __commonJS({ + "node_modules/axios/lib/axios.js"(exports, module2) { + "use strict"; + var utils = require_utils(); + var bind = require_bind(); + var Axios = require_Axios(); + var mergeConfig = require_mergeConfig(); + var defaults = require_defaults(); + function createInstance(defaultConfig) { + var context = new Axios(defaultConfig); + var instance = bind(Axios.prototype.request, context); + utils.extend(instance, Axios.prototype, context); + utils.extend(instance, context); + instance.create = function create(instanceConfig) { + return createInstance(mergeConfig(defaultConfig, instanceConfig)); + }; + return instance; + } + var axios2 = createInstance(defaults); + axios2.Axios = Axios; + axios2.Cancel = require_Cancel(); + axios2.CancelToken = require_CancelToken(); + axios2.isCancel = require_isCancel(); + axios2.VERSION = require_data().version; + axios2.all = function all(promises) { + return Promise.all(promises); + }; + axios2.spread = require_spread(); + axios2.isAxiosError = require_isAxiosError(); + module2.exports = axios2; + module2.exports.default = axios2; + } +}); + +// node_modules/axios/index.js +var require_axios2 = __commonJS({ + "node_modules/axios/index.js"(exports, module2) { + module2.exports = require_axios(); + } +}); + +// main.ts +__export(exports, { + default: () => DigitalGarden +}); +var import_obsidian9 = __toModule(require("obsidian")); + +// node_modules/luxon/src/errors.js +var LuxonError = class extends Error { +}; +var InvalidDateTimeError = class extends LuxonError { + constructor(reason) { + super(`Invalid DateTime: ${reason.toMessage()}`); + } +}; +var InvalidIntervalError = class extends LuxonError { + constructor(reason) { + super(`Invalid Interval: ${reason.toMessage()}`); + } +}; +var InvalidDurationError = class extends LuxonError { + constructor(reason) { + super(`Invalid Duration: ${reason.toMessage()}`); + } +}; +var ConflictingSpecificationError = class extends LuxonError { +}; +var InvalidUnitError = class extends LuxonError { + constructor(unit) { + super(`Invalid unit ${unit}`); + } +}; +var InvalidArgumentError = class extends LuxonError { +}; +var ZoneIsAbstractError = class extends LuxonError { + constructor() { + super("Zone is an abstract class"); + } +}; + +// node_modules/luxon/src/impl/formats.js +var n = "numeric"; +var s = "short"; +var l = "long"; +var DATE_SHORT = { + year: n, + month: n, + day: n +}; +var DATE_MED = { + year: n, + month: s, + day: n +}; +var DATE_MED_WITH_WEEKDAY = { + year: n, + month: s, + day: n, + weekday: s +}; +var DATE_FULL = { + year: n, + month: l, + day: n +}; +var DATE_HUGE = { + year: n, + month: l, + day: n, + weekday: l +}; +var TIME_SIMPLE = { + hour: n, + minute: n +}; +var TIME_WITH_SECONDS = { + hour: n, + minute: n, + second: n +}; +var TIME_WITH_SHORT_OFFSET = { + hour: n, + minute: n, + second: n, + timeZoneName: s +}; +var TIME_WITH_LONG_OFFSET = { + hour: n, + minute: n, + second: n, + timeZoneName: l +}; +var TIME_24_SIMPLE = { + hour: n, + minute: n, + hourCycle: "h23" +}; +var TIME_24_WITH_SECONDS = { + hour: n, + minute: n, + second: n, + hourCycle: "h23" +}; +var TIME_24_WITH_SHORT_OFFSET = { + hour: n, + minute: n, + second: n, + hourCycle: "h23", + timeZoneName: s +}; +var TIME_24_WITH_LONG_OFFSET = { + hour: n, + minute: n, + second: n, + hourCycle: "h23", + timeZoneName: l +}; +var DATETIME_SHORT = { + year: n, + month: n, + day: n, + hour: n, + minute: n +}; +var DATETIME_SHORT_WITH_SECONDS = { + year: n, + month: n, + day: n, + hour: n, + minute: n, + second: n +}; +var DATETIME_MED = { + year: n, + month: s, + day: n, + hour: n, + minute: n +}; +var DATETIME_MED_WITH_SECONDS = { + year: n, + month: s, + day: n, + hour: n, + minute: n, + second: n +}; +var DATETIME_MED_WITH_WEEKDAY = { + year: n, + month: s, + day: n, + weekday: s, + hour: n, + minute: n +}; +var DATETIME_FULL = { + year: n, + month: l, + day: n, + hour: n, + minute: n, + timeZoneName: s +}; +var DATETIME_FULL_WITH_SECONDS = { + year: n, + month: l, + day: n, + hour: n, + minute: n, + second: n, + timeZoneName: s +}; +var DATETIME_HUGE = { + year: n, + month: l, + day: n, + weekday: l, + hour: n, + minute: n, + timeZoneName: l +}; +var DATETIME_HUGE_WITH_SECONDS = { + year: n, + month: l, + day: n, + weekday: l, + hour: n, + minute: n, + second: n, + timeZoneName: l +}; + +// node_modules/luxon/src/zone.js +var Zone = class { + get type() { + throw new ZoneIsAbstractError(); + } + get name() { + throw new ZoneIsAbstractError(); + } + get ianaName() { + return this.name; + } + get isUniversal() { + throw new ZoneIsAbstractError(); + } + offsetName(ts, opts) { + throw new ZoneIsAbstractError(); + } + formatOffset(ts, format2) { + throw new ZoneIsAbstractError(); + } + offset(ts) { + throw new ZoneIsAbstractError(); + } + equals(otherZone) { + throw new ZoneIsAbstractError(); + } + get isValid() { + throw new ZoneIsAbstractError(); + } +}; + +// node_modules/luxon/src/zones/systemZone.js +var singleton = null; +var SystemZone = class extends Zone { + static get instance() { + if (singleton === null) { + singleton = new SystemZone(); + } + return singleton; + } + get type() { + return "system"; + } + get name() { + return new Intl.DateTimeFormat().resolvedOptions().timeZone; + } + get isUniversal() { + return false; + } + offsetName(ts, { format: format2, locale }) { + return parseZoneInfo(ts, format2, locale); + } + formatOffset(ts, format2) { + return formatOffset(this.offset(ts), format2); + } + offset(ts) { + return -new Date(ts).getTimezoneOffset(); + } + equals(otherZone) { + return otherZone.type === "system"; + } + get isValid() { + return true; + } +}; + +// node_modules/luxon/src/zones/IANAZone.js +var dtfCache = {}; +function makeDTF(zone) { + if (!dtfCache[zone]) { + dtfCache[zone] = new Intl.DateTimeFormat("en-US", { + hour12: false, + timeZone: zone, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + era: "short" + }); + } + return dtfCache[zone]; +} +var typeToPos = { + year: 0, + month: 1, + day: 2, + era: 3, + hour: 4, + minute: 5, + second: 6 +}; +function hackyOffset(dtf, date) { + const formatted = dtf.format(date).replace(/\u200E/g, ""), parsed = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(formatted), [, fMonth, fDay, fYear, fadOrBc, fHour, fMinute, fSecond] = parsed; + return [fYear, fMonth, fDay, fadOrBc, fHour, fMinute, fSecond]; +} +function partsOffset(dtf, date) { + const formatted = dtf.formatToParts(date); + const filled = []; + for (let i = 0; i < formatted.length; i++) { + const { type, value } = formatted[i]; + const pos = typeToPos[type]; + if (type === "era") { + filled[pos] = value; + } else if (!isUndefined(pos)) { + filled[pos] = parseInt(value, 10); + } + } + return filled; +} +var ianaZoneCache = {}; +var IANAZone = class extends Zone { + static create(name) { + if (!ianaZoneCache[name]) { + ianaZoneCache[name] = new IANAZone(name); + } + return ianaZoneCache[name]; + } + static resetCache() { + ianaZoneCache = {}; + dtfCache = {}; + } + static isValidSpecifier(s2) { + return this.isValidZone(s2); + } + static isValidZone(zone) { + if (!zone) { + return false; + } + try { + new Intl.DateTimeFormat("en-US", { timeZone: zone }).format(); + return true; + } catch (e) { + return false; + } + } + constructor(name) { + super(); + this.zoneName = name; + this.valid = IANAZone.isValidZone(name); + } + get type() { + return "iana"; + } + get name() { + return this.zoneName; + } + get isUniversal() { + return false; + } + offsetName(ts, { format: format2, locale }) { + return parseZoneInfo(ts, format2, locale, this.name); + } + formatOffset(ts, format2) { + return formatOffset(this.offset(ts), format2); + } + offset(ts) { + const date = new Date(ts); + if (isNaN(date)) + return NaN; + const dtf = makeDTF(this.name); + let [year, month, day, adOrBc, hour, minute, second] = dtf.formatToParts ? partsOffset(dtf, date) : hackyOffset(dtf, date); + if (adOrBc === "BC") { + year = -Math.abs(year) + 1; + } + const adjustedHour = hour === 24 ? 0 : hour; + const asUTC = objToLocalTS({ + year, + month, + day, + hour: adjustedHour, + minute, + second, + millisecond: 0 + }); + let asTS = +date; + const over = asTS % 1e3; + asTS -= over >= 0 ? over : 1e3 + over; + return (asUTC - asTS) / (60 * 1e3); + } + equals(otherZone) { + return otherZone.type === "iana" && otherZone.name === this.name; + } + get isValid() { + return this.valid; + } +}; + +// node_modules/luxon/src/impl/locale.js +var intlLFCache = {}; +function getCachedLF(locString, opts = {}) { + const key = JSON.stringify([locString, opts]); + let dtf = intlLFCache[key]; + if (!dtf) { + dtf = new Intl.ListFormat(locString, opts); + intlLFCache[key] = dtf; + } + return dtf; +} +var intlDTCache = {}; +function getCachedDTF(locString, opts = {}) { + const key = JSON.stringify([locString, opts]); + let dtf = intlDTCache[key]; + if (!dtf) { + dtf = new Intl.DateTimeFormat(locString, opts); + intlDTCache[key] = dtf; + } + return dtf; +} +var intlNumCache = {}; +function getCachedINF(locString, opts = {}) { + const key = JSON.stringify([locString, opts]); + let inf = intlNumCache[key]; + if (!inf) { + inf = new Intl.NumberFormat(locString, opts); + intlNumCache[key] = inf; + } + return inf; +} +var intlRelCache = {}; +function getCachedRTF(locString, opts = {}) { + const _a = opts, { base } = _a, cacheKeyOpts = __objRest(_a, ["base"]); + const key = JSON.stringify([locString, cacheKeyOpts]); + let inf = intlRelCache[key]; + if (!inf) { + inf = new Intl.RelativeTimeFormat(locString, opts); + intlRelCache[key] = inf; + } + return inf; +} +var sysLocaleCache = null; +function systemLocale() { + if (sysLocaleCache) { + return sysLocaleCache; + } else { + sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale; + return sysLocaleCache; + } +} +function parseLocaleString(localeStr) { + const xIndex = localeStr.indexOf("-x-"); + if (xIndex !== -1) { + localeStr = localeStr.substring(0, xIndex); + } + const uIndex = localeStr.indexOf("-u-"); + if (uIndex === -1) { + return [localeStr]; + } else { + let options; + let selectedStr; + try { + options = getCachedDTF(localeStr).resolvedOptions(); + selectedStr = localeStr; + } catch (e) { + const smaller = localeStr.substring(0, uIndex); + options = getCachedDTF(smaller).resolvedOptions(); + selectedStr = smaller; + } + const { numberingSystem, calendar } = options; + return [selectedStr, numberingSystem, calendar]; + } +} +function intlConfigString(localeStr, numberingSystem, outputCalendar) { + if (outputCalendar || numberingSystem) { + if (!localeStr.includes("-u-")) { + localeStr += "-u"; + } + if (outputCalendar) { + localeStr += `-ca-${outputCalendar}`; + } + if (numberingSystem) { + localeStr += `-nu-${numberingSystem}`; + } + return localeStr; + } else { + return localeStr; + } +} +function mapMonths(f) { + const ms = []; + for (let i = 1; i <= 12; i++) { + const dt = DateTime.utc(2016, i, 1); + ms.push(f(dt)); + } + return ms; +} +function mapWeekdays(f) { + const ms = []; + for (let i = 1; i <= 7; i++) { + const dt = DateTime.utc(2016, 11, 13 + i); + ms.push(f(dt)); + } + return ms; +} +function listStuff(loc, length, defaultOK, englishFn, intlFn) { + const mode = loc.listingMode(defaultOK); + if (mode === "error") { + return null; + } else if (mode === "en") { + return englishFn(length); + } else { + return intlFn(length); + } +} +function supportsFastNumbers(loc) { + if (loc.numberingSystem && loc.numberingSystem !== "latn") { + return false; + } else { + return loc.numberingSystem === "latn" || !loc.locale || loc.locale.startsWith("en") || new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn"; + } +} +var PolyNumberFormatter = class { + constructor(intl, forceSimple, opts) { + this.padTo = opts.padTo || 0; + this.floor = opts.floor || false; + const _a = opts, { padTo, floor } = _a, otherOpts = __objRest(_a, ["padTo", "floor"]); + if (!forceSimple || Object.keys(otherOpts).length > 0) { + const intlOpts = __spreadValues({ useGrouping: false }, opts); + if (opts.padTo > 0) + intlOpts.minimumIntegerDigits = opts.padTo; + this.inf = getCachedINF(intl, intlOpts); + } + } + format(i) { + if (this.inf) { + const fixed = this.floor ? Math.floor(i) : i; + return this.inf.format(fixed); + } else { + const fixed = this.floor ? Math.floor(i) : roundTo(i, 3); + return padStart(fixed, this.padTo); + } + } +}; +var PolyDateFormatter = class { + constructor(dt, intl, opts) { + this.opts = opts; + this.originalZone = void 0; + let z = void 0; + if (this.opts.timeZone) { + this.dt = dt; + } else if (dt.zone.type === "fixed") { + const gmtOffset = -1 * (dt.offset / 60); + const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`; + if (dt.offset !== 0 && IANAZone.create(offsetZ).valid) { + z = offsetZ; + this.dt = dt; + } else { + z = "UTC"; + this.dt = dt.offset === 0 ? dt : dt.setZone("UTC").plus({ minutes: dt.offset }); + this.originalZone = dt.zone; + } + } else if (dt.zone.type === "system") { + this.dt = dt; + } else if (dt.zone.type === "iana") { + this.dt = dt; + z = dt.zone.name; + } else { + z = "UTC"; + this.dt = dt.setZone("UTC").plus({ minutes: dt.offset }); + this.originalZone = dt.zone; + } + const intlOpts = __spreadValues({}, this.opts); + intlOpts.timeZone = intlOpts.timeZone || z; + this.dtf = getCachedDTF(intl, intlOpts); + } + format() { + if (this.originalZone) { + return this.formatToParts().map(({ value }) => value).join(""); + } + return this.dtf.format(this.dt.toJSDate()); + } + formatToParts() { + const parts = this.dtf.formatToParts(this.dt.toJSDate()); + if (this.originalZone) { + return parts.map((part) => { + if (part.type === "timeZoneName") { + const offsetName = this.originalZone.offsetName(this.dt.ts, { + locale: this.dt.locale, + format: this.opts.timeZoneName + }); + return __spreadProps(__spreadValues({}, part), { + value: offsetName + }); + } else { + return part; + } + }); + } + return parts; + } + resolvedOptions() { + return this.dtf.resolvedOptions(); + } +}; +var PolyRelFormatter = class { + constructor(intl, isEnglish, opts) { + this.opts = __spreadValues({ style: "long" }, opts); + if (!isEnglish && hasRelative()) { + this.rtf = getCachedRTF(intl, opts); + } + } + format(count, unit) { + if (this.rtf) { + return this.rtf.format(count, unit); + } else { + return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long"); + } + } + formatToParts(count, unit) { + if (this.rtf) { + return this.rtf.formatToParts(count, unit); + } else { + return []; + } + } +}; +var Locale = class { + static fromOpts(opts) { + return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN); + } + static create(locale, numberingSystem, outputCalendar, defaultToEN = false) { + const specifiedLocale = locale || Settings.defaultLocale; + const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale()); + const numberingSystemR = numberingSystem || Settings.defaultNumberingSystem; + const outputCalendarR = outputCalendar || Settings.defaultOutputCalendar; + return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale); + } + static resetCache() { + sysLocaleCache = null; + intlDTCache = {}; + intlNumCache = {}; + intlRelCache = {}; + } + static fromObject({ locale, numberingSystem, outputCalendar } = {}) { + return Locale.create(locale, numberingSystem, outputCalendar); + } + constructor(locale, numbering, outputCalendar, specifiedLocale) { + const [parsedLocale, parsedNumberingSystem, parsedOutputCalendar] = parseLocaleString(locale); + this.locale = parsedLocale; + this.numberingSystem = numbering || parsedNumberingSystem || null; + this.outputCalendar = outputCalendar || parsedOutputCalendar || null; + this.intl = intlConfigString(this.locale, this.numberingSystem, this.outputCalendar); + this.weekdaysCache = { format: {}, standalone: {} }; + this.monthsCache = { format: {}, standalone: {} }; + this.meridiemCache = null; + this.eraCache = {}; + this.specifiedLocale = specifiedLocale; + this.fastNumbersCached = null; + } + get fastNumbers() { + if (this.fastNumbersCached == null) { + this.fastNumbersCached = supportsFastNumbers(this); + } + return this.fastNumbersCached; + } + listingMode() { + const isActuallyEn = this.isEnglish(); + const hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory"); + return isActuallyEn && hasNoWeirdness ? "en" : "intl"; + } + clone(alts) { + if (!alts || Object.getOwnPropertyNames(alts).length === 0) { + return this; + } else { + return Locale.create(alts.locale || this.specifiedLocale, alts.numberingSystem || this.numberingSystem, alts.outputCalendar || this.outputCalendar, alts.defaultToEN || false); + } + } + redefaultToEN(alts = {}) { + return this.clone(__spreadProps(__spreadValues({}, alts), { defaultToEN: true })); + } + redefaultToSystem(alts = {}) { + return this.clone(__spreadProps(__spreadValues({}, alts), { defaultToEN: false })); + } + months(length, format2 = false, defaultOK = true) { + return listStuff(this, length, defaultOK, months, () => { + const intl = format2 ? { month: length, day: "numeric" } : { month: length }, formatStr = format2 ? "format" : "standalone"; + if (!this.monthsCache[formatStr][length]) { + this.monthsCache[formatStr][length] = mapMonths((dt) => this.extract(dt, intl, "month")); + } + return this.monthsCache[formatStr][length]; + }); + } + weekdays(length, format2 = false, defaultOK = true) { + return listStuff(this, length, defaultOK, weekdays, () => { + const intl = format2 ? { weekday: length, year: "numeric", month: "long", day: "numeric" } : { weekday: length }, formatStr = format2 ? "format" : "standalone"; + if (!this.weekdaysCache[formatStr][length]) { + this.weekdaysCache[formatStr][length] = mapWeekdays((dt) => this.extract(dt, intl, "weekday")); + } + return this.weekdaysCache[formatStr][length]; + }); + } + meridiems(defaultOK = true) { + return listStuff(this, void 0, defaultOK, () => meridiems, () => { + if (!this.meridiemCache) { + const intl = { hour: "numeric", hourCycle: "h12" }; + this.meridiemCache = [DateTime.utc(2016, 11, 13, 9), DateTime.utc(2016, 11, 13, 19)].map((dt) => this.extract(dt, intl, "dayperiod")); + } + return this.meridiemCache; + }); + } + eras(length, defaultOK = true) { + return listStuff(this, length, defaultOK, eras, () => { + const intl = { era: length }; + if (!this.eraCache[length]) { + this.eraCache[length] = [DateTime.utc(-40, 1, 1), DateTime.utc(2017, 1, 1)].map((dt) => this.extract(dt, intl, "era")); + } + return this.eraCache[length]; + }); + } + extract(dt, intlOpts, field) { + const df = this.dtFormatter(dt, intlOpts), results = df.formatToParts(), matching = results.find((m) => m.type.toLowerCase() === field); + return matching ? matching.value : null; + } + numberFormatter(opts = {}) { + return new PolyNumberFormatter(this.intl, opts.forceSimple || this.fastNumbers, opts); + } + dtFormatter(dt, intlOpts = {}) { + return new PolyDateFormatter(dt, this.intl, intlOpts); + } + relFormatter(opts = {}) { + return new PolyRelFormatter(this.intl, this.isEnglish(), opts); + } + listFormatter(opts = {}) { + return getCachedLF(this.intl, opts); + } + isEnglish() { + return this.locale === "en" || this.locale.toLowerCase() === "en-us" || new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us"); + } + equals(other) { + return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar; + } +}; + +// node_modules/luxon/src/zones/fixedOffsetZone.js +var singleton2 = null; +var FixedOffsetZone = class extends Zone { + static get utcInstance() { + if (singleton2 === null) { + singleton2 = new FixedOffsetZone(0); + } + return singleton2; + } + static instance(offset3) { + return offset3 === 0 ? FixedOffsetZone.utcInstance : new FixedOffsetZone(offset3); + } + static parseSpecifier(s2) { + if (s2) { + const r = s2.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i); + if (r) { + return new FixedOffsetZone(signedOffset(r[1], r[2])); + } + } + return null; + } + constructor(offset3) { + super(); + this.fixed = offset3; + } + get type() { + return "fixed"; + } + get name() { + return this.fixed === 0 ? "UTC" : `UTC${formatOffset(this.fixed, "narrow")}`; + } + get ianaName() { + if (this.fixed === 0) { + return "Etc/UTC"; + } else { + return `Etc/GMT${formatOffset(-this.fixed, "narrow")}`; + } + } + offsetName() { + return this.name; + } + formatOffset(ts, format2) { + return formatOffset(this.fixed, format2); + } + get isUniversal() { + return true; + } + offset() { + return this.fixed; + } + equals(otherZone) { + return otherZone.type === "fixed" && otherZone.fixed === this.fixed; + } + get isValid() { + return true; + } +}; + +// node_modules/luxon/src/zones/invalidZone.js +var InvalidZone = class extends Zone { + constructor(zoneName) { + super(); + this.zoneName = zoneName; + } + get type() { + return "invalid"; + } + get name() { + return this.zoneName; + } + get isUniversal() { + return false; + } + offsetName() { + return null; + } + formatOffset() { + return ""; + } + offset() { + return NaN; + } + equals() { + return false; + } + get isValid() { + return false; + } +}; + +// node_modules/luxon/src/impl/zoneUtil.js +function normalizeZone(input, defaultZone2) { + let offset3; + if (isUndefined(input) || input === null) { + return defaultZone2; + } else if (input instanceof Zone) { + return input; + } else if (isString(input)) { + const lowered = input.toLowerCase(); + if (lowered === "default") + return defaultZone2; + else if (lowered === "local" || lowered === "system") + return SystemZone.instance; + else if (lowered === "utc" || lowered === "gmt") + return FixedOffsetZone.utcInstance; + else + return FixedOffsetZone.parseSpecifier(lowered) || IANAZone.create(input); + } else if (isNumber(input)) { + return FixedOffsetZone.instance(input); + } else if (typeof input === "object" && input.offset && typeof input.offset === "number") { + return input; + } else { + return new InvalidZone(input); + } +} + +// node_modules/luxon/src/settings.js +var now = () => Date.now(); +var defaultZone = "system"; +var defaultLocale = null; +var defaultNumberingSystem = null; +var defaultOutputCalendar = null; +var twoDigitCutoffYear = 60; +var throwOnInvalid; +var Settings = class { + static get now() { + return now; + } + static set now(n2) { + now = n2; + } + static set defaultZone(zone) { + defaultZone = zone; + } + static get defaultZone() { + return normalizeZone(defaultZone, SystemZone.instance); + } + static get defaultLocale() { + return defaultLocale; + } + static set defaultLocale(locale) { + defaultLocale = locale; + } + static get defaultNumberingSystem() { + return defaultNumberingSystem; + } + static set defaultNumberingSystem(numberingSystem) { + defaultNumberingSystem = numberingSystem; + } + static get defaultOutputCalendar() { + return defaultOutputCalendar; + } + static set defaultOutputCalendar(outputCalendar) { + defaultOutputCalendar = outputCalendar; + } + static get twoDigitCutoffYear() { + return twoDigitCutoffYear; + } + static set twoDigitCutoffYear(cutoffYear) { + twoDigitCutoffYear = cutoffYear % 100; + } + static get throwOnInvalid() { + return throwOnInvalid; + } + static set throwOnInvalid(t) { + throwOnInvalid = t; + } + static resetCaches() { + Locale.resetCache(); + IANAZone.resetCache(); + } +}; + +// node_modules/luxon/src/impl/util.js +function isUndefined(o) { + return typeof o === "undefined"; +} +function isNumber(o) { + return typeof o === "number"; +} +function isInteger(o) { + return typeof o === "number" && o % 1 === 0; +} +function isString(o) { + return typeof o === "string"; +} +function isDate(o) { + return Object.prototype.toString.call(o) === "[object Date]"; +} +function hasRelative() { + try { + return typeof Intl !== "undefined" && !!Intl.RelativeTimeFormat; + } catch (e) { + return false; + } +} +function maybeArray(thing) { + return Array.isArray(thing) ? thing : [thing]; +} +function bestBy(arr, by, compare) { + if (arr.length === 0) { + return void 0; + } + return arr.reduce((best, next) => { + const pair = [by(next), next]; + if (!best) { + return pair; + } else if (compare(best[0], pair[0]) === best[0]) { + return best; + } else { + return pair; + } + }, null)[1]; +} +function pick(obj, keys) { + return keys.reduce((a, k) => { + a[k] = obj[k]; + return a; + }, {}); +} +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} +function integerBetween(thing, bottom2, top2) { + return isInteger(thing) && thing >= bottom2 && thing <= top2; +} +function floorMod(x, n2) { + return x - n2 * Math.floor(x / n2); +} +function padStart(input, n2 = 2) { + const isNeg = input < 0; + let padded; + if (isNeg) { + padded = "-" + ("" + -input).padStart(n2, "0"); + } else { + padded = ("" + input).padStart(n2, "0"); + } + return padded; +} +function parseInteger(string) { + if (isUndefined(string) || string === null || string === "") { + return void 0; + } else { + return parseInt(string, 10); + } +} +function parseFloating(string) { + if (isUndefined(string) || string === null || string === "") { + return void 0; + } else { + return parseFloat(string); + } +} +function parseMillis(fraction) { + if (isUndefined(fraction) || fraction === null || fraction === "") { + return void 0; + } else { + const f = parseFloat("0." + fraction) * 1e3; + return Math.floor(f); + } +} +function roundTo(number, digits, towardZero = false) { + const factor = 10 ** digits, rounder = towardZero ? Math.trunc : Math.round; + return rounder(number * factor) / factor; +} +function isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); +} +function daysInYear(year) { + return isLeapYear(year) ? 366 : 365; +} +function daysInMonth(year, month) { + const modMonth = floorMod(month - 1, 12) + 1, modYear = year + (month - modMonth) / 12; + if (modMonth === 2) { + return isLeapYear(modYear) ? 29 : 28; + } else { + return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1]; + } +} +function objToLocalTS(obj) { + let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond); + if (obj.year < 100 && obj.year >= 0) { + d = new Date(d); + d.setUTCFullYear(obj.year, obj.month - 1, obj.day); + } + return +d; +} +function weeksInWeekYear(weekYear) { + const p1 = (weekYear + Math.floor(weekYear / 4) - Math.floor(weekYear / 100) + Math.floor(weekYear / 400)) % 7, last = weekYear - 1, p2 = (last + Math.floor(last / 4) - Math.floor(last / 100) + Math.floor(last / 400)) % 7; + return p1 === 4 || p2 === 3 ? 53 : 52; +} +function untruncateYear(year) { + if (year > 99) { + return year; + } else + return year > Settings.twoDigitCutoffYear ? 1900 + year : 2e3 + year; +} +function parseZoneInfo(ts, offsetFormat, locale, timeZone = null) { + const date = new Date(ts), intlOpts = { + hourCycle: "h23", + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit" + }; + if (timeZone) { + intlOpts.timeZone = timeZone; + } + const modified = __spreadValues({ timeZoneName: offsetFormat }, intlOpts); + const parsed = new Intl.DateTimeFormat(locale, modified).formatToParts(date).find((m) => m.type.toLowerCase() === "timezonename"); + return parsed ? parsed.value : null; +} +function signedOffset(offHourStr, offMinuteStr) { + let offHour = parseInt(offHourStr, 10); + if (Number.isNaN(offHour)) { + offHour = 0; + } + const offMin = parseInt(offMinuteStr, 10) || 0, offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin; + return offHour * 60 + offMinSigned; +} +function asNumber(value) { + const numericValue = Number(value); + if (typeof value === "boolean" || value === "" || Number.isNaN(numericValue)) + throw new InvalidArgumentError(`Invalid unit value ${value}`); + return numericValue; +} +function normalizeObject(obj, normalizer) { + const normalized = {}; + for (const u in obj) { + if (hasOwnProperty(obj, u)) { + const v = obj[u]; + if (v === void 0 || v === null) + continue; + normalized[normalizer(u)] = asNumber(v); + } + } + return normalized; +} +function formatOffset(offset3, format2) { + const hours = Math.trunc(Math.abs(offset3 / 60)), minutes = Math.trunc(Math.abs(offset3 % 60)), sign = offset3 >= 0 ? "+" : "-"; + switch (format2) { + case "short": + return `${sign}${padStart(hours, 2)}:${padStart(minutes, 2)}`; + case "narrow": + return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ""}`; + case "techie": + return `${sign}${padStart(hours, 2)}${padStart(minutes, 2)}`; + default: + throw new RangeError(`Value format ${format2} is out of range for property format`); + } +} +function timeObject(obj) { + return pick(obj, ["hour", "minute", "second", "millisecond"]); +} + +// node_modules/luxon/src/impl/english.js +var monthsLong = [ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December" +]; +var monthsShort = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" +]; +var monthsNarrow = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"]; +function months(length) { + switch (length) { + case "narrow": + return [...monthsNarrow]; + case "short": + return [...monthsShort]; + case "long": + return [...monthsLong]; + case "numeric": + return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"]; + case "2-digit": + return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"]; + default: + return null; + } +} +var weekdaysLong = [ + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday", + "Sunday" +]; +var weekdaysShort = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]; +var weekdaysNarrow = ["M", "T", "W", "T", "F", "S", "S"]; +function weekdays(length) { + switch (length) { + case "narrow": + return [...weekdaysNarrow]; + case "short": + return [...weekdaysShort]; + case "long": + return [...weekdaysLong]; + case "numeric": + return ["1", "2", "3", "4", "5", "6", "7"]; + default: + return null; + } +} +var meridiems = ["AM", "PM"]; +var erasLong = ["Before Christ", "Anno Domini"]; +var erasShort = ["BC", "AD"]; +var erasNarrow = ["B", "A"]; +function eras(length) { + switch (length) { + case "narrow": + return [...erasNarrow]; + case "short": + return [...erasShort]; + case "long": + return [...erasLong]; + default: + return null; + } +} +function meridiemForDateTime(dt) { + return meridiems[dt.hour < 12 ? 0 : 1]; +} +function weekdayForDateTime(dt, length) { + return weekdays(length)[dt.weekday - 1]; +} +function monthForDateTime(dt, length) { + return months(length)[dt.month - 1]; +} +function eraForDateTime(dt, length) { + return eras(length)[dt.year < 0 ? 0 : 1]; +} +function formatRelativeTime(unit, count, numeric = "always", narrow = false) { + const units = { + years: ["year", "yr."], + quarters: ["quarter", "qtr."], + months: ["month", "mo."], + weeks: ["week", "wk."], + days: ["day", "day", "days"], + hours: ["hour", "hr."], + minutes: ["minute", "min."], + seconds: ["second", "sec."] + }; + const lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1; + if (numeric === "auto" && lastable) { + const isDay = unit === "days"; + switch (count) { + case 1: + return isDay ? "tomorrow" : `next ${units[unit][0]}`; + case -1: + return isDay ? "yesterday" : `last ${units[unit][0]}`; + case 0: + return isDay ? "today" : `this ${units[unit][0]}`; + default: + } + } + const isInPast = Object.is(count, -0) || count < 0, fmtValue = Math.abs(count), singular = fmtValue === 1, lilUnits = units[unit], fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit; + return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`; +} + +// node_modules/luxon/src/impl/formatter.js +function stringifyTokens(splits, tokenToString) { + let s2 = ""; + for (const token of splits) { + if (token.literal) { + s2 += token.val; + } else { + s2 += tokenToString(token.val); + } + } + return s2; +} +var macroTokenToFormatOpts = { + D: DATE_SHORT, + DD: DATE_MED, + DDD: DATE_FULL, + DDDD: DATE_HUGE, + t: TIME_SIMPLE, + tt: TIME_WITH_SECONDS, + ttt: TIME_WITH_SHORT_OFFSET, + tttt: TIME_WITH_LONG_OFFSET, + T: TIME_24_SIMPLE, + TT: TIME_24_WITH_SECONDS, + TTT: TIME_24_WITH_SHORT_OFFSET, + TTTT: TIME_24_WITH_LONG_OFFSET, + f: DATETIME_SHORT, + ff: DATETIME_MED, + fff: DATETIME_FULL, + ffff: DATETIME_HUGE, + F: DATETIME_SHORT_WITH_SECONDS, + FF: DATETIME_MED_WITH_SECONDS, + FFF: DATETIME_FULL_WITH_SECONDS, + FFFF: DATETIME_HUGE_WITH_SECONDS +}; +var Formatter = class { + static create(locale, opts = {}) { + return new Formatter(locale, opts); + } + static parseFormat(fmt) { + let current = null, currentFull = "", bracketed = false; + const splits = []; + for (let i = 0; i < fmt.length; i++) { + const c = fmt.charAt(i); + if (c === "'") { + if (currentFull.length > 0) { + splits.push({ literal: bracketed || /^\s+$/.test(currentFull), val: currentFull }); + } + current = null; + currentFull = ""; + bracketed = !bracketed; + } else if (bracketed) { + currentFull += c; + } else if (c === current) { + currentFull += c; + } else { + if (currentFull.length > 0) { + splits.push({ literal: /^\s+$/.test(currentFull), val: currentFull }); + } + currentFull = c; + current = c; + } + } + if (currentFull.length > 0) { + splits.push({ literal: bracketed || /^\s+$/.test(currentFull), val: currentFull }); + } + return splits; + } + static macroTokenToFormatOpts(token) { + return macroTokenToFormatOpts[token]; + } + constructor(locale, formatOpts) { + this.opts = formatOpts; + this.loc = locale; + this.systemLoc = null; + } + formatWithSystemDefault(dt, opts) { + if (this.systemLoc === null) { + this.systemLoc = this.loc.redefaultToSystem(); + } + const df = this.systemLoc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.format(); + } + formatDateTime(dt, opts = {}) { + const df = this.loc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.format(); + } + formatDateTimeParts(dt, opts = {}) { + const df = this.loc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.formatToParts(); + } + formatInterval(interval, opts = {}) { + const df = this.loc.dtFormatter(interval.start, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.dtf.formatRange(interval.start.toJSDate(), interval.end.toJSDate()); + } + resolvedOptions(dt, opts = {}) { + const df = this.loc.dtFormatter(dt, __spreadValues(__spreadValues({}, this.opts), opts)); + return df.resolvedOptions(); + } + num(n2, p = 0) { + if (this.opts.forceSimple) { + return padStart(n2, p); + } + const opts = __spreadValues({}, this.opts); + if (p > 0) { + opts.padTo = p; + } + return this.loc.numberFormatter(opts).format(n2); + } + formatDateTimeFromString(dt, fmt) { + const knownEnglish = this.loc.listingMode() === "en", useDateTimeFormatter = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory", string = (opts, extract) => this.loc.extract(dt, opts, extract), formatOffset2 = (opts) => { + if (dt.isOffsetFixed && dt.offset === 0 && opts.allowZ) { + return "Z"; + } + return dt.isValid ? dt.zone.formatOffset(dt.ts, opts.format) : ""; + }, meridiem = () => knownEnglish ? meridiemForDateTime(dt) : string({ hour: "numeric", hourCycle: "h12" }, "dayperiod"), month = (length, standalone) => knownEnglish ? monthForDateTime(dt, length) : string(standalone ? { month: length } : { month: length, day: "numeric" }, "month"), weekday = (length, standalone) => knownEnglish ? weekdayForDateTime(dt, length) : string(standalone ? { weekday: length } : { weekday: length, month: "long", day: "numeric" }, "weekday"), maybeMacro = (token) => { + const formatOpts = Formatter.macroTokenToFormatOpts(token); + if (formatOpts) { + return this.formatWithSystemDefault(dt, formatOpts); + } else { + return token; + } + }, era = (length) => knownEnglish ? eraForDateTime(dt, length) : string({ era: length }, "era"), tokenToString = (token) => { + switch (token) { + case "S": + return this.num(dt.millisecond); + case "u": + case "SSS": + return this.num(dt.millisecond, 3); + case "s": + return this.num(dt.second); + case "ss": + return this.num(dt.second, 2); + case "uu": + return this.num(Math.floor(dt.millisecond / 10), 2); + case "uuu": + return this.num(Math.floor(dt.millisecond / 100)); + case "m": + return this.num(dt.minute); + case "mm": + return this.num(dt.minute, 2); + case "h": + return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12); + case "hh": + return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12, 2); + case "H": + return this.num(dt.hour); + case "HH": + return this.num(dt.hour, 2); + case "Z": + return formatOffset2({ format: "narrow", allowZ: this.opts.allowZ }); + case "ZZ": + return formatOffset2({ format: "short", allowZ: this.opts.allowZ }); + case "ZZZ": + return formatOffset2({ format: "techie", allowZ: this.opts.allowZ }); + case "ZZZZ": + return dt.zone.offsetName(dt.ts, { format: "short", locale: this.loc.locale }); + case "ZZZZZ": + return dt.zone.offsetName(dt.ts, { format: "long", locale: this.loc.locale }); + case "z": + return dt.zoneName; + case "a": + return meridiem(); + case "d": + return useDateTimeFormatter ? string({ day: "numeric" }, "day") : this.num(dt.day); + case "dd": + return useDateTimeFormatter ? string({ day: "2-digit" }, "day") : this.num(dt.day, 2); + case "c": + return this.num(dt.weekday); + case "ccc": + return weekday("short", true); + case "cccc": + return weekday("long", true); + case "ccccc": + return weekday("narrow", true); + case "E": + return this.num(dt.weekday); + case "EEE": + return weekday("short", false); + case "EEEE": + return weekday("long", false); + case "EEEEE": + return weekday("narrow", false); + case "L": + return useDateTimeFormatter ? string({ month: "numeric", day: "numeric" }, "month") : this.num(dt.month); + case "LL": + return useDateTimeFormatter ? string({ month: "2-digit", day: "numeric" }, "month") : this.num(dt.month, 2); + case "LLL": + return month("short", true); + case "LLLL": + return month("long", true); + case "LLLLL": + return month("narrow", true); + case "M": + return useDateTimeFormatter ? string({ month: "numeric" }, "month") : this.num(dt.month); + case "MM": + return useDateTimeFormatter ? string({ month: "2-digit" }, "month") : this.num(dt.month, 2); + case "MMM": + return month("short", false); + case "MMMM": + return month("long", false); + case "MMMMM": + return month("narrow", false); + case "y": + return useDateTimeFormatter ? string({ year: "numeric" }, "year") : this.num(dt.year); + case "yy": + return useDateTimeFormatter ? string({ year: "2-digit" }, "year") : this.num(dt.year.toString().slice(-2), 2); + case "yyyy": + return useDateTimeFormatter ? string({ year: "numeric" }, "year") : this.num(dt.year, 4); + case "yyyyyy": + return useDateTimeFormatter ? string({ year: "numeric" }, "year") : this.num(dt.year, 6); + case "G": + return era("short"); + case "GG": + return era("long"); + case "GGGGG": + return era("narrow"); + case "kk": + return this.num(dt.weekYear.toString().slice(-2), 2); + case "kkkk": + return this.num(dt.weekYear, 4); + case "W": + return this.num(dt.weekNumber); + case "WW": + return this.num(dt.weekNumber, 2); + case "o": + return this.num(dt.ordinal); + case "ooo": + return this.num(dt.ordinal, 3); + case "q": + return this.num(dt.quarter); + case "qq": + return this.num(dt.quarter, 2); + case "X": + return this.num(Math.floor(dt.ts / 1e3)); + case "x": + return this.num(dt.ts); + default: + return maybeMacro(token); + } + }; + return stringifyTokens(Formatter.parseFormat(fmt), tokenToString); + } + formatDurationFromString(dur, fmt) { + const tokenToField = (token) => { + switch (token[0]) { + case "S": + return "millisecond"; + case "s": + return "second"; + case "m": + return "minute"; + case "h": + return "hour"; + case "d": + return "day"; + case "w": + return "week"; + case "M": + return "month"; + case "y": + return "year"; + default: + return null; + } + }, tokenToString = (lildur) => (token) => { + const mapped = tokenToField(token); + if (mapped) { + return this.num(lildur.get(mapped), token.length); + } else { + return token; + } + }, tokens = Formatter.parseFormat(fmt), realTokens = tokens.reduce((found, { literal, val }) => literal ? found : found.concat(val), []), collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter((t) => t)); + return stringifyTokens(tokens, tokenToString(collapsed)); + } +}; + +// node_modules/luxon/src/impl/invalid.js +var Invalid = class { + constructor(reason, explanation) { + this.reason = reason; + this.explanation = explanation; + } + toMessage() { + if (this.explanation) { + return `${this.reason}: ${this.explanation}`; + } else { + return this.reason; + } + } +}; + +// node_modules/luxon/src/impl/regexParser.js +var ianaRegex = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/; +function combineRegexes(...regexes) { + const full = regexes.reduce((f, r) => f + r.source, ""); + return RegExp(`^${full}$`); +} +function combineExtractors(...extractors) { + return (m) => extractors.reduce(([mergedVals, mergedZone, cursor], ex) => { + const [val, zone, next] = ex(m, cursor); + return [__spreadValues(__spreadValues({}, mergedVals), val), zone || mergedZone, next]; + }, [{}, null, 1]).slice(0, 2); +} +function parse(s2, ...patterns) { + if (s2 == null) { + return [null, null]; + } + for (const [regex, extractor] of patterns) { + const m = regex.exec(s2); + if (m) { + return extractor(m); + } + } + return [null, null]; +} +function simpleParse(...keys) { + return (match2, cursor) => { + const ret = {}; + let i; + for (i = 0; i < keys.length; i++) { + ret[keys[i]] = parseInteger(match2[cursor + i]); + } + return [ret, null, cursor + i]; + }; +} +var offsetRegex = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/; +var isoExtendedZone = `(?:${offsetRegex.source}?(?:\\[(${ianaRegex.source})\\])?)?`; +var isoTimeBaseRegex = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/; +var isoTimeRegex = RegExp(`${isoTimeBaseRegex.source}${isoExtendedZone}`); +var isoTimeExtensionRegex = RegExp(`(?:T${isoTimeRegex.source})?`); +var isoYmdRegex = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/; +var isoWeekRegex = /(\d{4})-?W(\d\d)(?:-?(\d))?/; +var isoOrdinalRegex = /(\d{4})-?(\d{3})/; +var extractISOWeekData = simpleParse("weekYear", "weekNumber", "weekDay"); +var extractISOOrdinalData = simpleParse("year", "ordinal"); +var sqlYmdRegex = /(\d{4})-(\d\d)-(\d\d)/; +var sqlTimeRegex = RegExp(`${isoTimeBaseRegex.source} ?(?:${offsetRegex.source}|(${ianaRegex.source}))?`); +var sqlTimeExtensionRegex = RegExp(`(?: ${sqlTimeRegex.source})?`); +function int(match2, pos, fallback) { + const m = match2[pos]; + return isUndefined(m) ? fallback : parseInteger(m); +} +function extractISOYmd(match2, cursor) { + const item = { + year: int(match2, cursor), + month: int(match2, cursor + 1, 1), + day: int(match2, cursor + 2, 1) + }; + return [item, null, cursor + 3]; +} +function extractISOTime(match2, cursor) { + const item = { + hours: int(match2, cursor, 0), + minutes: int(match2, cursor + 1, 0), + seconds: int(match2, cursor + 2, 0), + milliseconds: parseMillis(match2[cursor + 3]) + }; + return [item, null, cursor + 4]; +} +function extractISOOffset(match2, cursor) { + const local = !match2[cursor] && !match2[cursor + 1], fullOffset = signedOffset(match2[cursor + 1], match2[cursor + 2]), zone = local ? null : FixedOffsetZone.instance(fullOffset); + return [{}, zone, cursor + 3]; +} +function extractIANAZone(match2, cursor) { + const zone = match2[cursor] ? IANAZone.create(match2[cursor]) : null; + return [{}, zone, cursor + 1]; +} +var isoTimeOnly = RegExp(`^T?${isoTimeBaseRegex.source}$`); +var isoDuration = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/; +function extractISODuration(match2) { + const [s2, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] = match2; + const hasNegativePrefix = s2[0] === "-"; + const negativeSeconds = secondStr && secondStr[0] === "-"; + const maybeNegate = (num, force = false) => num !== void 0 && (force || num && hasNegativePrefix) ? -num : num; + return [ + { + years: maybeNegate(parseFloating(yearStr)), + months: maybeNegate(parseFloating(monthStr)), + weeks: maybeNegate(parseFloating(weekStr)), + days: maybeNegate(parseFloating(dayStr)), + hours: maybeNegate(parseFloating(hourStr)), + minutes: maybeNegate(parseFloating(minuteStr)), + seconds: maybeNegate(parseFloating(secondStr), secondStr === "-0"), + milliseconds: maybeNegate(parseMillis(millisecondsStr), negativeSeconds) + } + ]; +} +var obsOffsets = { + GMT: 0, + EDT: -4 * 60, + EST: -5 * 60, + CDT: -5 * 60, + CST: -6 * 60, + MDT: -6 * 60, + MST: -7 * 60, + PDT: -7 * 60, + PST: -8 * 60 +}; +function fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { + const result = { + year: yearStr.length === 2 ? untruncateYear(parseInteger(yearStr)) : parseInteger(yearStr), + month: monthsShort.indexOf(monthStr) + 1, + day: parseInteger(dayStr), + hour: parseInteger(hourStr), + minute: parseInteger(minuteStr) + }; + if (secondStr) + result.second = parseInteger(secondStr); + if (weekdayStr) { + result.weekday = weekdayStr.length > 3 ? weekdaysLong.indexOf(weekdayStr) + 1 : weekdaysShort.indexOf(weekdayStr) + 1; + } + return result; +} +var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/; +function extractRFC2822(match2) { + const [ + , + weekdayStr, + dayStr, + monthStr, + yearStr, + hourStr, + minuteStr, + secondStr, + obsOffset, + milOffset, + offHourStr, + offMinuteStr + ] = match2, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr); + let offset3; + if (obsOffset) { + offset3 = obsOffsets[obsOffset]; + } else if (milOffset) { + offset3 = 0; + } else { + offset3 = signedOffset(offHourStr, offMinuteStr); + } + return [result, new FixedOffsetZone(offset3)]; +} +function preprocessRFC2822(s2) { + return s2.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim(); +} +var rfc1123 = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/; +var rfc850 = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/; +var ascii = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/; +function extractRFC1123Or850(match2) { + const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr] = match2, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr); + return [result, FixedOffsetZone.utcInstance]; +} +function extractASCII(match2) { + const [, weekdayStr, monthStr, dayStr, hourStr, minuteStr, secondStr, yearStr] = match2, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr); + return [result, FixedOffsetZone.utcInstance]; +} +var isoYmdWithTimeExtensionRegex = combineRegexes(isoYmdRegex, isoTimeExtensionRegex); +var isoWeekWithTimeExtensionRegex = combineRegexes(isoWeekRegex, isoTimeExtensionRegex); +var isoOrdinalWithTimeExtensionRegex = combineRegexes(isoOrdinalRegex, isoTimeExtensionRegex); +var isoTimeCombinedRegex = combineRegexes(isoTimeRegex); +var extractISOYmdTimeAndOffset = combineExtractors(extractISOYmd, extractISOTime, extractISOOffset, extractIANAZone); +var extractISOWeekTimeAndOffset = combineExtractors(extractISOWeekData, extractISOTime, extractISOOffset, extractIANAZone); +var extractISOOrdinalDateAndTime = combineExtractors(extractISOOrdinalData, extractISOTime, extractISOOffset, extractIANAZone); +var extractISOTimeAndOffset = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone); +function parseISODate(s2) { + return parse(s2, [isoYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [isoWeekWithTimeExtensionRegex, extractISOWeekTimeAndOffset], [isoOrdinalWithTimeExtensionRegex, extractISOOrdinalDateAndTime], [isoTimeCombinedRegex, extractISOTimeAndOffset]); +} +function parseRFC2822Date(s2) { + return parse(preprocessRFC2822(s2), [rfc2822, extractRFC2822]); +} +function parseHTTPDate(s2) { + return parse(s2, [rfc1123, extractRFC1123Or850], [rfc850, extractRFC1123Or850], [ascii, extractASCII]); +} +function parseISODuration(s2) { + return parse(s2, [isoDuration, extractISODuration]); +} +var extractISOTimeOnly = combineExtractors(extractISOTime); +function parseISOTimeOnly(s2) { + return parse(s2, [isoTimeOnly, extractISOTimeOnly]); +} +var sqlYmdWithTimeExtensionRegex = combineRegexes(sqlYmdRegex, sqlTimeExtensionRegex); +var sqlTimeCombinedRegex = combineRegexes(sqlTimeRegex); +var extractISOTimeOffsetAndIANAZone = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone); +function parseSQL(s2) { + return parse(s2, [sqlYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [sqlTimeCombinedRegex, extractISOTimeOffsetAndIANAZone]); +} + +// node_modules/luxon/src/duration.js +var INVALID = "Invalid Duration"; +var lowOrderMatrix = { + weeks: { + days: 7, + hours: 7 * 24, + minutes: 7 * 24 * 60, + seconds: 7 * 24 * 60 * 60, + milliseconds: 7 * 24 * 60 * 60 * 1e3 + }, + days: { + hours: 24, + minutes: 24 * 60, + seconds: 24 * 60 * 60, + milliseconds: 24 * 60 * 60 * 1e3 + }, + hours: { minutes: 60, seconds: 60 * 60, milliseconds: 60 * 60 * 1e3 }, + minutes: { seconds: 60, milliseconds: 60 * 1e3 }, + seconds: { milliseconds: 1e3 } +}; +var casualMatrix = __spreadValues({ + years: { + quarters: 4, + months: 12, + weeks: 52, + days: 365, + hours: 365 * 24, + minutes: 365 * 24 * 60, + seconds: 365 * 24 * 60 * 60, + milliseconds: 365 * 24 * 60 * 60 * 1e3 + }, + quarters: { + months: 3, + weeks: 13, + days: 91, + hours: 91 * 24, + minutes: 91 * 24 * 60, + seconds: 91 * 24 * 60 * 60, + milliseconds: 91 * 24 * 60 * 60 * 1e3 + }, + months: { + weeks: 4, + days: 30, + hours: 30 * 24, + minutes: 30 * 24 * 60, + seconds: 30 * 24 * 60 * 60, + milliseconds: 30 * 24 * 60 * 60 * 1e3 + } +}, lowOrderMatrix); +var daysInYearAccurate = 146097 / 400; +var daysInMonthAccurate = 146097 / 4800; +var accurateMatrix = __spreadValues({ + years: { + quarters: 4, + months: 12, + weeks: daysInYearAccurate / 7, + days: daysInYearAccurate, + hours: daysInYearAccurate * 24, + minutes: daysInYearAccurate * 24 * 60, + seconds: daysInYearAccurate * 24 * 60 * 60, + milliseconds: daysInYearAccurate * 24 * 60 * 60 * 1e3 + }, + quarters: { + months: 3, + weeks: daysInYearAccurate / 28, + days: daysInYearAccurate / 4, + hours: daysInYearAccurate * 24 / 4, + minutes: daysInYearAccurate * 24 * 60 / 4, + seconds: daysInYearAccurate * 24 * 60 * 60 / 4, + milliseconds: daysInYearAccurate * 24 * 60 * 60 * 1e3 / 4 + }, + months: { + weeks: daysInMonthAccurate / 7, + days: daysInMonthAccurate, + hours: daysInMonthAccurate * 24, + minutes: daysInMonthAccurate * 24 * 60, + seconds: daysInMonthAccurate * 24 * 60 * 60, + milliseconds: daysInMonthAccurate * 24 * 60 * 60 * 1e3 + } +}, lowOrderMatrix); +var orderedUnits = [ + "years", + "quarters", + "months", + "weeks", + "days", + "hours", + "minutes", + "seconds", + "milliseconds" +]; +var reverseUnits = orderedUnits.slice(0).reverse(); +function clone(dur, alts, clear = false) { + const conf = { + values: clear ? alts.values : __spreadValues(__spreadValues({}, dur.values), alts.values || {}), + loc: dur.loc.clone(alts.loc), + conversionAccuracy: alts.conversionAccuracy || dur.conversionAccuracy, + matrix: alts.matrix || dur.matrix + }; + return new Duration(conf); +} +function antiTrunc(n2) { + return n2 < 0 ? Math.floor(n2) : Math.ceil(n2); +} +function convert(matrix, fromMap, fromUnit, toMap, toUnit) { + const conv = matrix[toUnit][fromUnit], raw = fromMap[fromUnit] / conv, sameSign = Math.sign(raw) === Math.sign(toMap[toUnit]), added = !sameSign && toMap[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc(raw) : Math.trunc(raw); + toMap[toUnit] += added; + fromMap[fromUnit] -= added * conv; +} +function normalizeValues(matrix, vals) { + reverseUnits.reduce((previous, current) => { + if (!isUndefined(vals[current])) { + if (previous) { + convert(matrix, vals, previous, vals, current); + } + return current; + } else { + return previous; + } + }, null); +} +function removeZeroes(vals) { + const newVals = {}; + for (const [key, value] of Object.entries(vals)) { + if (value !== 0) { + newVals[key] = value; + } + } + return newVals; +} +var Duration = class { + constructor(config) { + const accurate = config.conversionAccuracy === "longterm" || false; + let matrix = accurate ? accurateMatrix : casualMatrix; + if (config.matrix) { + matrix = config.matrix; + } + this.values = config.values; + this.loc = config.loc || Locale.create(); + this.conversionAccuracy = accurate ? "longterm" : "casual"; + this.invalid = config.invalid || null; + this.matrix = matrix; + this.isLuxonDuration = true; + } + static fromMillis(count, opts) { + return Duration.fromObject({ milliseconds: count }, opts); + } + static fromObject(obj, opts = {}) { + if (obj == null || typeof obj !== "object") { + throw new InvalidArgumentError(`Duration.fromObject: argument expected to be an object, got ${obj === null ? "null" : typeof obj}`); + } + return new Duration({ + values: normalizeObject(obj, Duration.normalizeUnit), + loc: Locale.fromObject(opts), + conversionAccuracy: opts.conversionAccuracy, + matrix: opts.matrix + }); + } + static fromDurationLike(durationLike) { + if (isNumber(durationLike)) { + return Duration.fromMillis(durationLike); + } else if (Duration.isDuration(durationLike)) { + return durationLike; + } else if (typeof durationLike === "object") { + return Duration.fromObject(durationLike); + } else { + throw new InvalidArgumentError(`Unknown duration argument ${durationLike} of type ${typeof durationLike}`); + } + } + static fromISO(text, opts) { + const [parsed] = parseISODuration(text); + if (parsed) { + return Duration.fromObject(parsed, opts); + } else { + return Duration.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`); + } + } + static fromISOTime(text, opts) { + const [parsed] = parseISOTimeOnly(text); + if (parsed) { + return Duration.fromObject(parsed, opts); + } else { + return Duration.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`); + } + } + static invalid(reason, explanation = null) { + if (!reason) { + throw new InvalidArgumentError("need to specify a reason the Duration is invalid"); + } + const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation); + if (Settings.throwOnInvalid) { + throw new InvalidDurationError(invalid); + } else { + return new Duration({ invalid }); + } + } + static normalizeUnit(unit) { + const normalized = { + year: "years", + years: "years", + quarter: "quarters", + quarters: "quarters", + month: "months", + months: "months", + week: "weeks", + weeks: "weeks", + day: "days", + days: "days", + hour: "hours", + hours: "hours", + minute: "minutes", + minutes: "minutes", + second: "seconds", + seconds: "seconds", + millisecond: "milliseconds", + milliseconds: "milliseconds" + }[unit ? unit.toLowerCase() : unit]; + if (!normalized) + throw new InvalidUnitError(unit); + return normalized; + } + static isDuration(o) { + return o && o.isLuxonDuration || false; + } + get locale() { + return this.isValid ? this.loc.locale : null; + } + get numberingSystem() { + return this.isValid ? this.loc.numberingSystem : null; + } + toFormat(fmt, opts = {}) { + const fmtOpts = __spreadProps(__spreadValues({}, opts), { + floor: opts.round !== false && opts.floor !== false + }); + return this.isValid ? Formatter.create(this.loc, fmtOpts).formatDurationFromString(this, fmt) : INVALID; + } + toHuman(opts = {}) { + const l2 = orderedUnits.map((unit) => { + const val = this.values[unit]; + if (isUndefined(val)) { + return null; + } + return this.loc.numberFormatter(__spreadProps(__spreadValues({ style: "unit", unitDisplay: "long" }, opts), { unit: unit.slice(0, -1) })).format(val); + }).filter((n2) => n2); + return this.loc.listFormatter(__spreadValues({ type: "conjunction", style: opts.listStyle || "narrow" }, opts)).format(l2); + } + toObject() { + if (!this.isValid) + return {}; + return __spreadValues({}, this.values); + } + toISO() { + if (!this.isValid) + return null; + let s2 = "P"; + if (this.years !== 0) + s2 += this.years + "Y"; + if (this.months !== 0 || this.quarters !== 0) + s2 += this.months + this.quarters * 3 + "M"; + if (this.weeks !== 0) + s2 += this.weeks + "W"; + if (this.days !== 0) + s2 += this.days + "D"; + if (this.hours !== 0 || this.minutes !== 0 || this.seconds !== 0 || this.milliseconds !== 0) + s2 += "T"; + if (this.hours !== 0) + s2 += this.hours + "H"; + if (this.minutes !== 0) + s2 += this.minutes + "M"; + if (this.seconds !== 0 || this.milliseconds !== 0) + s2 += roundTo(this.seconds + this.milliseconds / 1e3, 3) + "S"; + if (s2 === "P") + s2 += "T0S"; + return s2; + } + toISOTime(opts = {}) { + if (!this.isValid) + return null; + const millis = this.toMillis(); + if (millis < 0 || millis >= 864e5) + return null; + opts = __spreadValues({ + suppressMilliseconds: false, + suppressSeconds: false, + includePrefix: false, + format: "extended" + }, opts); + const value = this.shiftTo("hours", "minutes", "seconds", "milliseconds"); + let fmt = opts.format === "basic" ? "hhmm" : "hh:mm"; + if (!opts.suppressSeconds || value.seconds !== 0 || value.milliseconds !== 0) { + fmt += opts.format === "basic" ? "ss" : ":ss"; + if (!opts.suppressMilliseconds || value.milliseconds !== 0) { + fmt += ".SSS"; + } + } + let str = value.toFormat(fmt); + if (opts.includePrefix) { + str = "T" + str; + } + return str; + } + toJSON() { + return this.toISO(); + } + toString() { + return this.toISO(); + } + toMillis() { + return this.as("milliseconds"); + } + valueOf() { + return this.toMillis(); + } + plus(duration) { + if (!this.isValid) + return this; + const dur = Duration.fromDurationLike(duration), result = {}; + for (const k of orderedUnits) { + if (hasOwnProperty(dur.values, k) || hasOwnProperty(this.values, k)) { + result[k] = dur.get(k) + this.get(k); + } + } + return clone(this, { values: result }, true); + } + minus(duration) { + if (!this.isValid) + return this; + const dur = Duration.fromDurationLike(duration); + return this.plus(dur.negate()); + } + mapUnits(fn2) { + if (!this.isValid) + return this; + const result = {}; + for (const k of Object.keys(this.values)) { + result[k] = asNumber(fn2(this.values[k], k)); + } + return clone(this, { values: result }, true); + } + get(unit) { + return this[Duration.normalizeUnit(unit)]; + } + set(values) { + if (!this.isValid) + return this; + const mixed = __spreadValues(__spreadValues({}, this.values), normalizeObject(values, Duration.normalizeUnit)); + return clone(this, { values: mixed }); + } + reconfigure({ locale, numberingSystem, conversionAccuracy, matrix } = {}) { + const loc = this.loc.clone({ locale, numberingSystem }); + const opts = { loc, matrix, conversionAccuracy }; + return clone(this, opts); + } + as(unit) { + return this.isValid ? this.shiftTo(unit).get(unit) : NaN; + } + normalize() { + if (!this.isValid) + return this; + const vals = this.toObject(); + normalizeValues(this.matrix, vals); + return clone(this, { values: vals }, true); + } + rescale() { + if (!this.isValid) + return this; + const vals = removeZeroes(this.normalize().shiftToAll().toObject()); + return clone(this, { values: vals }, true); + } + shiftTo(...units) { + if (!this.isValid) + return this; + if (units.length === 0) { + return this; + } + units = units.map((u) => Duration.normalizeUnit(u)); + const built = {}, accumulated = {}, vals = this.toObject(); + let lastUnit; + for (const k of orderedUnits) { + if (units.indexOf(k) >= 0) { + lastUnit = k; + let own = 0; + for (const ak in accumulated) { + own += this.matrix[ak][k] * accumulated[ak]; + accumulated[ak] = 0; + } + if (isNumber(vals[k])) { + own += vals[k]; + } + const i = Math.trunc(own); + built[k] = i; + accumulated[k] = (own * 1e3 - i * 1e3) / 1e3; + for (const down in vals) { + if (orderedUnits.indexOf(down) > orderedUnits.indexOf(k)) { + convert(this.matrix, vals, down, built, k); + } + } + } else if (isNumber(vals[k])) { + accumulated[k] = vals[k]; + } + } + for (const key in accumulated) { + if (accumulated[key] !== 0) { + built[lastUnit] += key === lastUnit ? accumulated[key] : accumulated[key] / this.matrix[lastUnit][key]; + } + } + return clone(this, { values: built }, true).normalize(); + } + shiftToAll() { + if (!this.isValid) + return this; + return this.shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds"); + } + negate() { + if (!this.isValid) + return this; + const negated = {}; + for (const k of Object.keys(this.values)) { + negated[k] = this.values[k] === 0 ? 0 : -this.values[k]; + } + return clone(this, { values: negated }, true); + } + get years() { + return this.isValid ? this.values.years || 0 : NaN; + } + get quarters() { + return this.isValid ? this.values.quarters || 0 : NaN; + } + get months() { + return this.isValid ? this.values.months || 0 : NaN; + } + get weeks() { + return this.isValid ? this.values.weeks || 0 : NaN; + } + get days() { + return this.isValid ? this.values.days || 0 : NaN; + } + get hours() { + return this.isValid ? this.values.hours || 0 : NaN; + } + get minutes() { + return this.isValid ? this.values.minutes || 0 : NaN; + } + get seconds() { + return this.isValid ? this.values.seconds || 0 : NaN; + } + get milliseconds() { + return this.isValid ? this.values.milliseconds || 0 : NaN; + } + get isValid() { + return this.invalid === null; + } + get invalidReason() { + return this.invalid ? this.invalid.reason : null; + } + get invalidExplanation() { + return this.invalid ? this.invalid.explanation : null; + } + equals(other) { + if (!this.isValid || !other.isValid) { + return false; + } + if (!this.loc.equals(other.loc)) { + return false; + } + function eq(v1, v2) { + if (v1 === void 0 || v1 === 0) + return v2 === void 0 || v2 === 0; + return v1 === v2; + } + for (const u of orderedUnits) { + if (!eq(this.values[u], other.values[u])) { + return false; + } + } + return true; + } +}; + +// node_modules/luxon/src/interval.js +var INVALID2 = "Invalid Interval"; +function validateStartEnd(start2, end2) { + if (!start2 || !start2.isValid) { + return Interval.invalid("missing or invalid start"); + } else if (!end2 || !end2.isValid) { + return Interval.invalid("missing or invalid end"); + } else if (end2 < start2) { + return Interval.invalid("end before start", `The end of an interval must be after its start, but you had start=${start2.toISO()} and end=${end2.toISO()}`); + } else { + return null; + } +} +var Interval = class { + constructor(config) { + this.s = config.start; + this.e = config.end; + this.invalid = config.invalid || null; + this.isLuxonInterval = true; + } + static invalid(reason, explanation = null) { + if (!reason) { + throw new InvalidArgumentError("need to specify a reason the Interval is invalid"); + } + const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation); + if (Settings.throwOnInvalid) { + throw new InvalidIntervalError(invalid); + } else { + return new Interval({ invalid }); + } + } + static fromDateTimes(start2, end2) { + const builtStart = friendlyDateTime(start2), builtEnd = friendlyDateTime(end2); + const validateError = validateStartEnd(builtStart, builtEnd); + if (validateError == null) { + return new Interval({ + start: builtStart, + end: builtEnd + }); + } else { + return validateError; + } + } + static after(start2, duration) { + const dur = Duration.fromDurationLike(duration), dt = friendlyDateTime(start2); + return Interval.fromDateTimes(dt, dt.plus(dur)); + } + static before(end2, duration) { + const dur = Duration.fromDurationLike(duration), dt = friendlyDateTime(end2); + return Interval.fromDateTimes(dt.minus(dur), dt); + } + static fromISO(text, opts) { + const [s2, e] = (text || "").split("/", 2); + if (s2 && e) { + let start2, startIsValid; + try { + start2 = DateTime.fromISO(s2, opts); + startIsValid = start2.isValid; + } catch (e2) { + startIsValid = false; + } + let end2, endIsValid; + try { + end2 = DateTime.fromISO(e, opts); + endIsValid = end2.isValid; + } catch (e2) { + endIsValid = false; + } + if (startIsValid && endIsValid) { + return Interval.fromDateTimes(start2, end2); + } + if (startIsValid) { + const dur = Duration.fromISO(e, opts); + if (dur.isValid) { + return Interval.after(start2, dur); + } + } else if (endIsValid) { + const dur = Duration.fromISO(s2, opts); + if (dur.isValid) { + return Interval.before(end2, dur); + } + } + } + return Interval.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`); + } + static isInterval(o) { + return o && o.isLuxonInterval || false; + } + get start() { + return this.isValid ? this.s : null; + } + get end() { + return this.isValid ? this.e : null; + } + get isValid() { + return this.invalidReason === null; + } + get invalidReason() { + return this.invalid ? this.invalid.reason : null; + } + get invalidExplanation() { + return this.invalid ? this.invalid.explanation : null; + } + length(unit = "milliseconds") { + return this.isValid ? this.toDuration(...[unit]).get(unit) : NaN; + } + count(unit = "milliseconds") { + if (!this.isValid) + return NaN; + const start2 = this.start.startOf(unit), end2 = this.end.startOf(unit); + return Math.floor(end2.diff(start2, unit).get(unit)) + (end2.valueOf() !== this.end.valueOf()); + } + hasSame(unit) { + return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false; + } + isEmpty() { + return this.s.valueOf() === this.e.valueOf(); + } + isAfter(dateTime) { + if (!this.isValid) + return false; + return this.s > dateTime; + } + isBefore(dateTime) { + if (!this.isValid) + return false; + return this.e <= dateTime; + } + contains(dateTime) { + if (!this.isValid) + return false; + return this.s <= dateTime && this.e > dateTime; + } + set({ start: start2, end: end2 } = {}) { + if (!this.isValid) + return this; + return Interval.fromDateTimes(start2 || this.s, end2 || this.e); + } + splitAt(...dateTimes) { + if (!this.isValid) + return []; + const sorted = dateTimes.map(friendlyDateTime).filter((d) => this.contains(d)).sort(), results = []; + let { s: s2 } = this, i = 0; + while (s2 < this.e) { + const added = sorted[i] || this.e, next = +added > +this.e ? this.e : added; + results.push(Interval.fromDateTimes(s2, next)); + s2 = next; + i += 1; + } + return results; + } + splitBy(duration) { + const dur = Duration.fromDurationLike(duration); + if (!this.isValid || !dur.isValid || dur.as("milliseconds") === 0) { + return []; + } + let { s: s2 } = this, idx = 1, next; + const results = []; + while (s2 < this.e) { + const added = this.start.plus(dur.mapUnits((x) => x * idx)); + next = +added > +this.e ? this.e : added; + results.push(Interval.fromDateTimes(s2, next)); + s2 = next; + idx += 1; + } + return results; + } + divideEqually(numberOfParts) { + if (!this.isValid) + return []; + return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts); + } + overlaps(other) { + return this.e > other.s && this.s < other.e; + } + abutsStart(other) { + if (!this.isValid) + return false; + return +this.e === +other.s; + } + abutsEnd(other) { + if (!this.isValid) + return false; + return +other.e === +this.s; + } + engulfs(other) { + if (!this.isValid) + return false; + return this.s <= other.s && this.e >= other.e; + } + equals(other) { + if (!this.isValid || !other.isValid) { + return false; + } + return this.s.equals(other.s) && this.e.equals(other.e); + } + intersection(other) { + if (!this.isValid) + return this; + const s2 = this.s > other.s ? this.s : other.s, e = this.e < other.e ? this.e : other.e; + if (s2 >= e) { + return null; + } else { + return Interval.fromDateTimes(s2, e); + } + } + union(other) { + if (!this.isValid) + return this; + const s2 = this.s < other.s ? this.s : other.s, e = this.e > other.e ? this.e : other.e; + return Interval.fromDateTimes(s2, e); + } + static merge(intervals) { + const [found, final] = intervals.sort((a, b) => a.s - b.s).reduce(([sofar, current], item) => { + if (!current) { + return [sofar, item]; + } else if (current.overlaps(item) || current.abutsStart(item)) { + return [sofar, current.union(item)]; + } else { + return [sofar.concat([current]), item]; + } + }, [[], null]); + if (final) { + found.push(final); + } + return found; + } + static xor(intervals) { + let start2 = null, currentCount = 0; + const results = [], ends = intervals.map((i) => [ + { time: i.s, type: "s" }, + { time: i.e, type: "e" } + ]), flattened = Array.prototype.concat(...ends), arr = flattened.sort((a, b) => a.time - b.time); + for (const i of arr) { + currentCount += i.type === "s" ? 1 : -1; + if (currentCount === 1) { + start2 = i.time; + } else { + if (start2 && +start2 !== +i.time) { + results.push(Interval.fromDateTimes(start2, i.time)); + } + start2 = null; + } + } + return Interval.merge(results); + } + difference(...intervals) { + return Interval.xor([this].concat(intervals)).map((i) => this.intersection(i)).filter((i) => i && !i.isEmpty()); + } + toString() { + if (!this.isValid) + return INVALID2; + return `[${this.s.toISO()} \u2013 ${this.e.toISO()})`; + } + toLocaleString(formatOpts = DATE_SHORT, opts = {}) { + return this.isValid ? Formatter.create(this.s.loc.clone(opts), formatOpts).formatInterval(this) : INVALID2; + } + toISO(opts) { + if (!this.isValid) + return INVALID2; + return `${this.s.toISO(opts)}/${this.e.toISO(opts)}`; + } + toISODate() { + if (!this.isValid) + return INVALID2; + return `${this.s.toISODate()}/${this.e.toISODate()}`; + } + toISOTime(opts) { + if (!this.isValid) + return INVALID2; + return `${this.s.toISOTime(opts)}/${this.e.toISOTime(opts)}`; + } + toFormat(dateFormat, { separator = " \u2013 " } = {}) { + if (!this.isValid) + return INVALID2; + return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`; + } + toDuration(unit, opts) { + if (!this.isValid) { + return Duration.invalid(this.invalidReason); + } + return this.e.diff(this.s, unit, opts); + } + mapEndpoints(mapFn) { + return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e)); + } +}; + +// node_modules/luxon/src/info.js +var Info = class { + static hasDST(zone = Settings.defaultZone) { + const proto = DateTime.now().setZone(zone).set({ month: 12 }); + return !zone.isUniversal && proto.offset !== proto.set({ month: 6 }).offset; + } + static isValidIANAZone(zone) { + return IANAZone.isValidZone(zone); + } + static normalizeZone(input) { + return normalizeZone(input, Settings.defaultZone); + } + static months(length = "long", { locale = null, numberingSystem = null, locObj = null, outputCalendar = "gregory" } = {}) { + return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length); + } + static monthsFormat(length = "long", { locale = null, numberingSystem = null, locObj = null, outputCalendar = "gregory" } = {}) { + return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length, true); + } + static weekdays(length = "long", { locale = null, numberingSystem = null, locObj = null } = {}) { + return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length); + } + static weekdaysFormat(length = "long", { locale = null, numberingSystem = null, locObj = null } = {}) { + return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length, true); + } + static meridiems({ locale = null } = {}) { + return Locale.create(locale).meridiems(); + } + static eras(length = "short", { locale = null } = {}) { + return Locale.create(locale, null, "gregory").eras(length); + } + static features() { + return { relative: hasRelative() }; + } +}; + +// node_modules/luxon/src/impl/diff.js +function dayDiff(earlier, later) { + const utcDayStart = (dt) => dt.toUTC(0, { keepLocalTime: true }).startOf("day").valueOf(), ms = utcDayStart(later) - utcDayStart(earlier); + return Math.floor(Duration.fromMillis(ms).as("days")); +} +function highOrderDiffs(cursor, later, units) { + const differs = [ + ["years", (a, b) => b.year - a.year], + ["quarters", (a, b) => b.quarter - a.quarter + (b.year - a.year) * 4], + ["months", (a, b) => b.month - a.month + (b.year - a.year) * 12], + [ + "weeks", + (a, b) => { + const days = dayDiff(a, b); + return (days - days % 7) / 7; + } + ], + ["days", dayDiff] + ]; + const results = {}; + const earlier = cursor; + let lowestOrder, highWater; + for (const [unit, differ] of differs) { + if (units.indexOf(unit) >= 0) { + lowestOrder = unit; + results[unit] = differ(cursor, later); + highWater = earlier.plus(results); + if (highWater > later) { + results[unit]--; + cursor = earlier.plus(results); + } else { + cursor = highWater; + } + } + } + return [cursor, results, highWater, lowestOrder]; +} +function diff_default(earlier, later, units, opts) { + let [cursor, results, highWater, lowestOrder] = highOrderDiffs(earlier, later, units); + const remainingMillis = later - cursor; + const lowerOrderUnits = units.filter((u) => ["hours", "minutes", "seconds", "milliseconds"].indexOf(u) >= 0); + if (lowerOrderUnits.length === 0) { + if (highWater < later) { + highWater = cursor.plus({ [lowestOrder]: 1 }); + } + if (highWater !== cursor) { + results[lowestOrder] = (results[lowestOrder] || 0) + remainingMillis / (highWater - cursor); + } + } + const duration = Duration.fromObject(results, opts); + if (lowerOrderUnits.length > 0) { + return Duration.fromMillis(remainingMillis, opts).shiftTo(...lowerOrderUnits).plus(duration); + } else { + return duration; + } +} + +// node_modules/luxon/src/impl/digits.js +var numberingSystems = { + arab: "[\u0660-\u0669]", + arabext: "[\u06F0-\u06F9]", + bali: "[\u1B50-\u1B59]", + beng: "[\u09E6-\u09EF]", + deva: "[\u0966-\u096F]", + fullwide: "[\uFF10-\uFF19]", + gujr: "[\u0AE6-\u0AEF]", + hanidec: "[\u3007|\u4E00|\u4E8C|\u4E09|\u56DB|\u4E94|\u516D|\u4E03|\u516B|\u4E5D]", + khmr: "[\u17E0-\u17E9]", + knda: "[\u0CE6-\u0CEF]", + laoo: "[\u0ED0-\u0ED9]", + limb: "[\u1946-\u194F]", + mlym: "[\u0D66-\u0D6F]", + mong: "[\u1810-\u1819]", + mymr: "[\u1040-\u1049]", + orya: "[\u0B66-\u0B6F]", + tamldec: "[\u0BE6-\u0BEF]", + telu: "[\u0C66-\u0C6F]", + thai: "[\u0E50-\u0E59]", + tibt: "[\u0F20-\u0F29]", + latn: "\\d" +}; +var numberingSystemsUTF16 = { + arab: [1632, 1641], + arabext: [1776, 1785], + bali: [6992, 7001], + beng: [2534, 2543], + deva: [2406, 2415], + fullwide: [65296, 65303], + gujr: [2790, 2799], + khmr: [6112, 6121], + knda: [3302, 3311], + laoo: [3792, 3801], + limb: [6470, 6479], + mlym: [3430, 3439], + mong: [6160, 6169], + mymr: [4160, 4169], + orya: [2918, 2927], + tamldec: [3046, 3055], + telu: [3174, 3183], + thai: [3664, 3673], + tibt: [3872, 3881] +}; +var hanidecChars = numberingSystems.hanidec.replace(/[\[|\]]/g, "").split(""); +function parseDigits(str) { + let value = parseInt(str, 10); + if (isNaN(value)) { + value = ""; + for (let i = 0; i < str.length; i++) { + const code = str.charCodeAt(i); + if (str[i].search(numberingSystems.hanidec) !== -1) { + value += hanidecChars.indexOf(str[i]); + } else { + for (const key in numberingSystemsUTF16) { + const [min2, max2] = numberingSystemsUTF16[key]; + if (code >= min2 && code <= max2) { + value += code - min2; + } + } + } + } + return parseInt(value, 10); + } else { + return value; + } +} +function digitRegex({ numberingSystem }, append = "") { + return new RegExp(`${numberingSystems[numberingSystem || "latn"]}${append}`); +} + +// node_modules/luxon/src/impl/tokenParser.js +var MISSING_FTP = "missing Intl.DateTimeFormat.formatToParts support"; +function intUnit(regex, post = (i) => i) { + return { regex, deser: ([s2]) => post(parseDigits(s2)) }; +} +var NBSP = String.fromCharCode(160); +var spaceOrNBSP = `[ ${NBSP}]`; +var spaceOrNBSPRegExp = new RegExp(spaceOrNBSP, "g"); +function fixListRegex(s2) { + return s2.replace(/\./g, "\\.?").replace(spaceOrNBSPRegExp, spaceOrNBSP); +} +function stripInsensitivities(s2) { + return s2.replace(/\./g, "").replace(spaceOrNBSPRegExp, " ").toLowerCase(); +} +function oneOf(strings, startIndex) { + if (strings === null) { + return null; + } else { + return { + regex: RegExp(strings.map(fixListRegex).join("|")), + deser: ([s2]) => strings.findIndex((i) => stripInsensitivities(s2) === stripInsensitivities(i)) + startIndex + }; + } +} +function offset(regex, groups) { + return { regex, deser: ([, h, m]) => signedOffset(h, m), groups }; +} +function simple(regex) { + return { regex, deser: ([s2]) => s2 }; +} +function escapeToken(value) { + return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"); +} +function unitForToken(token, loc) { + const one = digitRegex(loc), two = digitRegex(loc, "{2}"), three = digitRegex(loc, "{3}"), four = digitRegex(loc, "{4}"), six = digitRegex(loc, "{6}"), oneOrTwo = digitRegex(loc, "{1,2}"), oneToThree = digitRegex(loc, "{1,3}"), oneToSix = digitRegex(loc, "{1,6}"), oneToNine = digitRegex(loc, "{1,9}"), twoToFour = digitRegex(loc, "{2,4}"), fourToSix = digitRegex(loc, "{4,6}"), literal = (t) => ({ regex: RegExp(escapeToken(t.val)), deser: ([s2]) => s2, literal: true }), unitate = (t) => { + if (token.literal) { + return literal(t); + } + switch (t.val) { + case "G": + return oneOf(loc.eras("short", false), 0); + case "GG": + return oneOf(loc.eras("long", false), 0); + case "y": + return intUnit(oneToSix); + case "yy": + return intUnit(twoToFour, untruncateYear); + case "yyyy": + return intUnit(four); + case "yyyyy": + return intUnit(fourToSix); + case "yyyyyy": + return intUnit(six); + case "M": + return intUnit(oneOrTwo); + case "MM": + return intUnit(two); + case "MMM": + return oneOf(loc.months("short", true, false), 1); + case "MMMM": + return oneOf(loc.months("long", true, false), 1); + case "L": + return intUnit(oneOrTwo); + case "LL": + return intUnit(two); + case "LLL": + return oneOf(loc.months("short", false, false), 1); + case "LLLL": + return oneOf(loc.months("long", false, false), 1); + case "d": + return intUnit(oneOrTwo); + case "dd": + return intUnit(two); + case "o": + return intUnit(oneToThree); + case "ooo": + return intUnit(three); + case "HH": + return intUnit(two); + case "H": + return intUnit(oneOrTwo); + case "hh": + return intUnit(two); + case "h": + return intUnit(oneOrTwo); + case "mm": + return intUnit(two); + case "m": + return intUnit(oneOrTwo); + case "q": + return intUnit(oneOrTwo); + case "qq": + return intUnit(two); + case "s": + return intUnit(oneOrTwo); + case "ss": + return intUnit(two); + case "S": + return intUnit(oneToThree); + case "SSS": + return intUnit(three); + case "u": + return simple(oneToNine); + case "uu": + return simple(oneOrTwo); + case "uuu": + return intUnit(one); + case "a": + return oneOf(loc.meridiems(), 0); + case "kkkk": + return intUnit(four); + case "kk": + return intUnit(twoToFour, untruncateYear); + case "W": + return intUnit(oneOrTwo); + case "WW": + return intUnit(two); + case "E": + case "c": + return intUnit(one); + case "EEE": + return oneOf(loc.weekdays("short", false, false), 1); + case "EEEE": + return oneOf(loc.weekdays("long", false, false), 1); + case "ccc": + return oneOf(loc.weekdays("short", true, false), 1); + case "cccc": + return oneOf(loc.weekdays("long", true, false), 1); + case "Z": + case "ZZ": + return offset(new RegExp(`([+-]${oneOrTwo.source})(?::(${two.source}))?`), 2); + case "ZZZ": + return offset(new RegExp(`([+-]${oneOrTwo.source})(${two.source})?`), 2); + case "z": + return simple(/[a-z_+-/]{1,256}?/i); + case " ": + return simple(/[^\S\n\r]/); + default: + return literal(t); + } + }; + const unit = unitate(token) || { + invalidReason: MISSING_FTP + }; + unit.token = token; + return unit; +} +var partTypeStyleToTokenVal = { + year: { + "2-digit": "yy", + numeric: "yyyyy" + }, + month: { + numeric: "M", + "2-digit": "MM", + short: "MMM", + long: "MMMM" + }, + day: { + numeric: "d", + "2-digit": "dd" + }, + weekday: { + short: "EEE", + long: "EEEE" + }, + dayperiod: "a", + dayPeriod: "a", + hour: { + numeric: "h", + "2-digit": "hh" + }, + minute: { + numeric: "m", + "2-digit": "mm" + }, + second: { + numeric: "s", + "2-digit": "ss" + }, + timeZoneName: { + long: "ZZZZZ", + short: "ZZZ" + } +}; +function tokenForPart(part, formatOpts) { + const { type, value } = part; + if (type === "literal") { + const isSpace = /^\s+$/.test(value); + return { + literal: !isSpace, + val: isSpace ? " " : value + }; + } + const style = formatOpts[type]; + let val = partTypeStyleToTokenVal[type]; + if (typeof val === "object") { + val = val[style]; + } + if (val) { + return { + literal: false, + val + }; + } + return void 0; +} +function buildRegex(units) { + const re = units.map((u) => u.regex).reduce((f, r) => `${f}(${r.source})`, ""); + return [`^${re}$`, units]; +} +function match(input, regex, handlers) { + const matches = input.match(regex); + if (matches) { + const all = {}; + let matchIndex = 1; + for (const i in handlers) { + if (hasOwnProperty(handlers, i)) { + const h = handlers[i], groups = h.groups ? h.groups + 1 : 1; + if (!h.literal && h.token) { + all[h.token.val[0]] = h.deser(matches.slice(matchIndex, matchIndex + groups)); + } + matchIndex += groups; + } + } + return [matches, all]; + } else { + return [matches, {}]; + } +} +function dateTimeFromMatches(matches) { + const toField = (token) => { + switch (token) { + case "S": + return "millisecond"; + case "s": + return "second"; + case "m": + return "minute"; + case "h": + case "H": + return "hour"; + case "d": + return "day"; + case "o": + return "ordinal"; + case "L": + case "M": + return "month"; + case "y": + return "year"; + case "E": + case "c": + return "weekday"; + case "W": + return "weekNumber"; + case "k": + return "weekYear"; + case "q": + return "quarter"; + default: + return null; + } + }; + let zone = null; + let specificOffset; + if (!isUndefined(matches.z)) { + zone = IANAZone.create(matches.z); + } + if (!isUndefined(matches.Z)) { + if (!zone) { + zone = new FixedOffsetZone(matches.Z); + } + specificOffset = matches.Z; + } + if (!isUndefined(matches.q)) { + matches.M = (matches.q - 1) * 3 + 1; + } + if (!isUndefined(matches.h)) { + if (matches.h < 12 && matches.a === 1) { + matches.h += 12; + } else if (matches.h === 12 && matches.a === 0) { + matches.h = 0; + } + } + if (matches.G === 0 && matches.y) { + matches.y = -matches.y; + } + if (!isUndefined(matches.u)) { + matches.S = parseMillis(matches.u); + } + const vals = Object.keys(matches).reduce((r, k) => { + const f = toField(k); + if (f) { + r[f] = matches[k]; + } + return r; + }, {}); + return [vals, zone, specificOffset]; +} +var dummyDateTimeCache = null; +function getDummyDateTime() { + if (!dummyDateTimeCache) { + dummyDateTimeCache = DateTime.fromMillis(1555555555555); + } + return dummyDateTimeCache; +} +function maybeExpandMacroToken(token, locale) { + if (token.literal) { + return token; + } + const formatOpts = Formatter.macroTokenToFormatOpts(token.val); + const tokens = formatOptsToTokens(formatOpts, locale); + if (tokens == null || tokens.includes(void 0)) { + return token; + } + return tokens; +} +function expandMacroTokens(tokens, locale) { + return Array.prototype.concat(...tokens.map((t) => maybeExpandMacroToken(t, locale))); +} +function explainFromTokens(locale, input, format2) { + const tokens = expandMacroTokens(Formatter.parseFormat(format2), locale), units = tokens.map((t) => unitForToken(t, locale)), disqualifyingUnit = units.find((t) => t.invalidReason); + if (disqualifyingUnit) { + return { input, tokens, invalidReason: disqualifyingUnit.invalidReason }; + } else { + const [regexString, handlers] = buildRegex(units), regex = RegExp(regexString, "i"), [rawMatches, matches] = match(input, regex, handlers), [result, zone, specificOffset] = matches ? dateTimeFromMatches(matches) : [null, null, void 0]; + if (hasOwnProperty(matches, "a") && hasOwnProperty(matches, "H")) { + throw new ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format"); + } + return { input, tokens, regex, rawMatches, matches, result, zone, specificOffset }; + } +} +function parseFromTokens(locale, input, format2) { + const { result, zone, specificOffset, invalidReason } = explainFromTokens(locale, input, format2); + return [result, zone, specificOffset, invalidReason]; +} +function formatOptsToTokens(formatOpts, locale) { + if (!formatOpts) { + return null; + } + const formatter = Formatter.create(locale, formatOpts); + const parts = formatter.formatDateTimeParts(getDummyDateTime()); + return parts.map((p) => tokenForPart(p, formatOpts)); +} + +// node_modules/luxon/src/impl/conversions.js +var nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; +var leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]; +function unitOutOfRange(unit, value) { + return new Invalid("unit out of range", `you specified ${value} (of type ${typeof value}) as a ${unit}, which is invalid`); +} +function dayOfWeek(year, month, day) { + const d = new Date(Date.UTC(year, month - 1, day)); + if (year < 100 && year >= 0) { + d.setUTCFullYear(d.getUTCFullYear() - 1900); + } + const js = d.getUTCDay(); + return js === 0 ? 7 : js; +} +function computeOrdinal(year, month, day) { + return day + (isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1]; +} +function uncomputeOrdinal(year, ordinal) { + const table = isLeapYear(year) ? leapLadder : nonLeapLadder, month0 = table.findIndex((i) => i < ordinal), day = ordinal - table[month0]; + return { month: month0 + 1, day }; +} +function gregorianToWeek(gregObj) { + const { year, month, day } = gregObj, ordinal = computeOrdinal(year, month, day), weekday = dayOfWeek(year, month, day); + let weekNumber = Math.floor((ordinal - weekday + 10) / 7), weekYear; + if (weekNumber < 1) { + weekYear = year - 1; + weekNumber = weeksInWeekYear(weekYear); + } else if (weekNumber > weeksInWeekYear(year)) { + weekYear = year + 1; + weekNumber = 1; + } else { + weekYear = year; + } + return __spreadValues({ weekYear, weekNumber, weekday }, timeObject(gregObj)); +} +function weekToGregorian(weekData) { + const { weekYear, weekNumber, weekday } = weekData, weekdayOfJan4 = dayOfWeek(weekYear, 1, 4), yearInDays = daysInYear(weekYear); + let ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 3, year; + if (ordinal < 1) { + year = weekYear - 1; + ordinal += daysInYear(year); + } else if (ordinal > yearInDays) { + year = weekYear + 1; + ordinal -= daysInYear(weekYear); + } else { + year = weekYear; + } + const { month, day } = uncomputeOrdinal(year, ordinal); + return __spreadValues({ year, month, day }, timeObject(weekData)); +} +function gregorianToOrdinal(gregData) { + const { year, month, day } = gregData; + const ordinal = computeOrdinal(year, month, day); + return __spreadValues({ year, ordinal }, timeObject(gregData)); +} +function ordinalToGregorian(ordinalData) { + const { year, ordinal } = ordinalData; + const { month, day } = uncomputeOrdinal(year, ordinal); + return __spreadValues({ year, month, day }, timeObject(ordinalData)); +} +function hasInvalidWeekData(obj) { + const validYear = isInteger(obj.weekYear), validWeek = integerBetween(obj.weekNumber, 1, weeksInWeekYear(obj.weekYear)), validWeekday = integerBetween(obj.weekday, 1, 7); + if (!validYear) { + return unitOutOfRange("weekYear", obj.weekYear); + } else if (!validWeek) { + return unitOutOfRange("week", obj.week); + } else if (!validWeekday) { + return unitOutOfRange("weekday", obj.weekday); + } else + return false; +} +function hasInvalidOrdinalData(obj) { + const validYear = isInteger(obj.year), validOrdinal = integerBetween(obj.ordinal, 1, daysInYear(obj.year)); + if (!validYear) { + return unitOutOfRange("year", obj.year); + } else if (!validOrdinal) { + return unitOutOfRange("ordinal", obj.ordinal); + } else + return false; +} +function hasInvalidGregorianData(obj) { + const validYear = isInteger(obj.year), validMonth = integerBetween(obj.month, 1, 12), validDay = integerBetween(obj.day, 1, daysInMonth(obj.year, obj.month)); + if (!validYear) { + return unitOutOfRange("year", obj.year); + } else if (!validMonth) { + return unitOutOfRange("month", obj.month); + } else if (!validDay) { + return unitOutOfRange("day", obj.day); + } else + return false; +} +function hasInvalidTimeData(obj) { + const { hour, minute, second, millisecond } = obj; + const validHour = integerBetween(hour, 0, 23) || hour === 24 && minute === 0 && second === 0 && millisecond === 0, validMinute = integerBetween(minute, 0, 59), validSecond = integerBetween(second, 0, 59), validMillisecond = integerBetween(millisecond, 0, 999); + if (!validHour) { + return unitOutOfRange("hour", hour); + } else if (!validMinute) { + return unitOutOfRange("minute", minute); + } else if (!validSecond) { + return unitOutOfRange("second", second); + } else if (!validMillisecond) { + return unitOutOfRange("millisecond", millisecond); + } else + return false; +} + +// node_modules/luxon/src/datetime.js +var INVALID3 = "Invalid DateTime"; +var MAX_DATE = 864e13; +function unsupportedZone(zone) { + return new Invalid("unsupported zone", `the zone "${zone.name}" is not supported`); +} +function possiblyCachedWeekData(dt) { + if (dt.weekData === null) { + dt.weekData = gregorianToWeek(dt.c); + } + return dt.weekData; +} +function clone2(inst, alts) { + const current = { + ts: inst.ts, + zone: inst.zone, + c: inst.c, + o: inst.o, + loc: inst.loc, + invalid: inst.invalid + }; + return new DateTime(__spreadProps(__spreadValues(__spreadValues({}, current), alts), { old: current })); +} +function fixOffset(localTS, o, tz) { + let utcGuess = localTS - o * 60 * 1e3; + const o2 = tz.offset(utcGuess); + if (o === o2) { + return [utcGuess, o]; + } + utcGuess -= (o2 - o) * 60 * 1e3; + const o3 = tz.offset(utcGuess); + if (o2 === o3) { + return [utcGuess, o2]; + } + return [localTS - Math.min(o2, o3) * 60 * 1e3, Math.max(o2, o3)]; +} +function tsToObj(ts, offset3) { + ts += offset3 * 60 * 1e3; + const d = new Date(ts); + return { + year: d.getUTCFullYear(), + month: d.getUTCMonth() + 1, + day: d.getUTCDate(), + hour: d.getUTCHours(), + minute: d.getUTCMinutes(), + second: d.getUTCSeconds(), + millisecond: d.getUTCMilliseconds() + }; +} +function objToTS(obj, offset3, zone) { + return fixOffset(objToLocalTS(obj), offset3, zone); +} +function adjustTime(inst, dur) { + const oPre = inst.o, year = inst.c.year + Math.trunc(dur.years), month = inst.c.month + Math.trunc(dur.months) + Math.trunc(dur.quarters) * 3, c = __spreadProps(__spreadValues({}, inst.c), { + year, + month, + day: Math.min(inst.c.day, daysInMonth(year, month)) + Math.trunc(dur.days) + Math.trunc(dur.weeks) * 7 + }), millisToAdd = Duration.fromObject({ + years: dur.years - Math.trunc(dur.years), + quarters: dur.quarters - Math.trunc(dur.quarters), + months: dur.months - Math.trunc(dur.months), + weeks: dur.weeks - Math.trunc(dur.weeks), + days: dur.days - Math.trunc(dur.days), + hours: dur.hours, + minutes: dur.minutes, + seconds: dur.seconds, + milliseconds: dur.milliseconds + }).as("milliseconds"), localTS = objToLocalTS(c); + let [ts, o] = fixOffset(localTS, oPre, inst.zone); + if (millisToAdd !== 0) { + ts += millisToAdd; + o = inst.zone.offset(ts); + } + return { ts, o }; +} +function parseDataToDateTime(parsed, parsedZone, opts, format2, text, specificOffset) { + const { setZone, zone } = opts; + if (parsed && Object.keys(parsed).length !== 0 || parsedZone) { + const interpretationZone = parsedZone || zone, inst = DateTime.fromObject(parsed, __spreadProps(__spreadValues({}, opts), { + zone: interpretationZone, + specificOffset + })); + return setZone ? inst : inst.setZone(zone); + } else { + return DateTime.invalid(new Invalid("unparsable", `the input "${text}" can't be parsed as ${format2}`)); + } +} +function toTechFormat(dt, format2, allowZ = true) { + return dt.isValid ? Formatter.create(Locale.create("en-US"), { + allowZ, + forceSimple: true + }).formatDateTimeFromString(dt, format2) : null; +} +function toISODate(o, extended) { + const longFormat = o.c.year > 9999 || o.c.year < 0; + let c = ""; + if (longFormat && o.c.year >= 0) + c += "+"; + c += padStart(o.c.year, longFormat ? 6 : 4); + if (extended) { + c += "-"; + c += padStart(o.c.month); + c += "-"; + c += padStart(o.c.day); + } else { + c += padStart(o.c.month); + c += padStart(o.c.day); + } + return c; +} +function toISOTime(o, extended, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone) { + let c = padStart(o.c.hour); + if (extended) { + c += ":"; + c += padStart(o.c.minute); + if (o.c.second !== 0 || !suppressSeconds) { + c += ":"; + } + } else { + c += padStart(o.c.minute); + } + if (o.c.second !== 0 || !suppressSeconds) { + c += padStart(o.c.second); + if (o.c.millisecond !== 0 || !suppressMilliseconds) { + c += "."; + c += padStart(o.c.millisecond, 3); + } + } + if (includeOffset) { + if (o.isOffsetFixed && o.offset === 0 && !extendedZone) { + c += "Z"; + } else if (o.o < 0) { + c += "-"; + c += padStart(Math.trunc(-o.o / 60)); + c += ":"; + c += padStart(Math.trunc(-o.o % 60)); + } else { + c += "+"; + c += padStart(Math.trunc(o.o / 60)); + c += ":"; + c += padStart(Math.trunc(o.o % 60)); + } + } + if (extendedZone) { + c += "[" + o.zone.ianaName + "]"; + } + return c; +} +var defaultUnitValues = { + month: 1, + day: 1, + hour: 0, + minute: 0, + second: 0, + millisecond: 0 +}; +var defaultWeekUnitValues = { + weekNumber: 1, + weekday: 1, + hour: 0, + minute: 0, + second: 0, + millisecond: 0 +}; +var defaultOrdinalUnitValues = { + ordinal: 1, + hour: 0, + minute: 0, + second: 0, + millisecond: 0 +}; +var orderedUnits2 = ["year", "month", "day", "hour", "minute", "second", "millisecond"]; +var orderedWeekUnits = [ + "weekYear", + "weekNumber", + "weekday", + "hour", + "minute", + "second", + "millisecond" +]; +var orderedOrdinalUnits = ["year", "ordinal", "hour", "minute", "second", "millisecond"]; +function normalizeUnit(unit) { + const normalized = { + year: "year", + years: "year", + month: "month", + months: "month", + day: "day", + days: "day", + hour: "hour", + hours: "hour", + minute: "minute", + minutes: "minute", + quarter: "quarter", + quarters: "quarter", + second: "second", + seconds: "second", + millisecond: "millisecond", + milliseconds: "millisecond", + weekday: "weekday", + weekdays: "weekday", + weeknumber: "weekNumber", + weeksnumber: "weekNumber", + weeknumbers: "weekNumber", + weekyear: "weekYear", + weekyears: "weekYear", + ordinal: "ordinal" + }[unit.toLowerCase()]; + if (!normalized) + throw new InvalidUnitError(unit); + return normalized; +} +function quickDT(obj, opts) { + const zone = normalizeZone(opts.zone, Settings.defaultZone), loc = Locale.fromObject(opts), tsNow = Settings.now(); + let ts, o; + if (!isUndefined(obj.year)) { + for (const u of orderedUnits2) { + if (isUndefined(obj[u])) { + obj[u] = defaultUnitValues[u]; + } + } + const invalid = hasInvalidGregorianData(obj) || hasInvalidTimeData(obj); + if (invalid) { + return DateTime.invalid(invalid); + } + const offsetProvis = zone.offset(tsNow); + [ts, o] = objToTS(obj, offsetProvis, zone); + } else { + ts = tsNow; + } + return new DateTime({ ts, zone, loc, o }); +} +function diffRelative(start2, end2, opts) { + const round2 = isUndefined(opts.round) ? true : opts.round, format2 = (c, unit) => { + c = roundTo(c, round2 || opts.calendary ? 0 : 2, true); + const formatter = end2.loc.clone(opts).relFormatter(opts); + return formatter.format(c, unit); + }, differ = (unit) => { + if (opts.calendary) { + if (!end2.hasSame(start2, unit)) { + return end2.startOf(unit).diff(start2.startOf(unit), unit).get(unit); + } else + return 0; + } else { + return end2.diff(start2, unit).get(unit); + } + }; + if (opts.unit) { + return format2(differ(opts.unit), opts.unit); + } + for (const unit of opts.units) { + const count = differ(unit); + if (Math.abs(count) >= 1) { + return format2(count, unit); + } + } + return format2(start2 > end2 ? -0 : 0, opts.units[opts.units.length - 1]); +} +function lastOpts(argList) { + let opts = {}, args; + if (argList.length > 0 && typeof argList[argList.length - 1] === "object") { + opts = argList[argList.length - 1]; + args = Array.from(argList).slice(0, argList.length - 1); + } else { + args = Array.from(argList); + } + return [opts, args]; +} +var DateTime = class { + constructor(config) { + const zone = config.zone || Settings.defaultZone; + let invalid = config.invalid || (Number.isNaN(config.ts) ? new Invalid("invalid input") : null) || (!zone.isValid ? unsupportedZone(zone) : null); + this.ts = isUndefined(config.ts) ? Settings.now() : config.ts; + let c = null, o = null; + if (!invalid) { + const unchanged = config.old && config.old.ts === this.ts && config.old.zone.equals(zone); + if (unchanged) { + [c, o] = [config.old.c, config.old.o]; + } else { + const ot = zone.offset(this.ts); + c = tsToObj(this.ts, ot); + invalid = Number.isNaN(c.year) ? new Invalid("invalid input") : null; + c = invalid ? null : c; + o = invalid ? null : ot; + } + } + this._zone = zone; + this.loc = config.loc || Locale.create(); + this.invalid = invalid; + this.weekData = null; + this.c = c; + this.o = o; + this.isLuxonDateTime = true; + } + static now() { + return new DateTime({}); + } + static local() { + const [opts, args] = lastOpts(arguments), [year, month, day, hour, minute, second, millisecond] = args; + return quickDT({ year, month, day, hour, minute, second, millisecond }, opts); + } + static utc() { + const [opts, args] = lastOpts(arguments), [year, month, day, hour, minute, second, millisecond] = args; + opts.zone = FixedOffsetZone.utcInstance; + return quickDT({ year, month, day, hour, minute, second, millisecond }, opts); + } + static fromJSDate(date, options = {}) { + const ts = isDate(date) ? date.valueOf() : NaN; + if (Number.isNaN(ts)) { + return DateTime.invalid("invalid input"); + } + const zoneToUse = normalizeZone(options.zone, Settings.defaultZone); + if (!zoneToUse.isValid) { + return DateTime.invalid(unsupportedZone(zoneToUse)); + } + return new DateTime({ + ts, + zone: zoneToUse, + loc: Locale.fromObject(options) + }); + } + static fromMillis(milliseconds, options = {}) { + if (!isNumber(milliseconds)) { + throw new InvalidArgumentError(`fromMillis requires a numerical input, but received a ${typeof milliseconds} with value ${milliseconds}`); + } else if (milliseconds < -MAX_DATE || milliseconds > MAX_DATE) { + return DateTime.invalid("Timestamp out of range"); + } else { + return new DateTime({ + ts: milliseconds, + zone: normalizeZone(options.zone, Settings.defaultZone), + loc: Locale.fromObject(options) + }); + } + } + static fromSeconds(seconds, options = {}) { + if (!isNumber(seconds)) { + throw new InvalidArgumentError("fromSeconds requires a numerical input"); + } else { + return new DateTime({ + ts: seconds * 1e3, + zone: normalizeZone(options.zone, Settings.defaultZone), + loc: Locale.fromObject(options) + }); + } + } + static fromObject(obj, opts = {}) { + obj = obj || {}; + const zoneToUse = normalizeZone(opts.zone, Settings.defaultZone); + if (!zoneToUse.isValid) { + return DateTime.invalid(unsupportedZone(zoneToUse)); + } + const tsNow = Settings.now(), offsetProvis = !isUndefined(opts.specificOffset) ? opts.specificOffset : zoneToUse.offset(tsNow), normalized = normalizeObject(obj, normalizeUnit), containsOrdinal = !isUndefined(normalized.ordinal), containsGregorYear = !isUndefined(normalized.year), containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber, loc = Locale.fromObject(opts); + if ((containsGregor || containsOrdinal) && definiteWeekDef) { + throw new ConflictingSpecificationError("Can't mix weekYear/weekNumber units with year/month/day or ordinals"); + } + if (containsGregorMD && containsOrdinal) { + throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day"); + } + const useWeekData = definiteWeekDef || normalized.weekday && !containsGregor; + let units, defaultValues, objNow = tsToObj(tsNow, offsetProvis); + if (useWeekData) { + units = orderedWeekUnits; + defaultValues = defaultWeekUnitValues; + objNow = gregorianToWeek(objNow); + } else if (containsOrdinal) { + units = orderedOrdinalUnits; + defaultValues = defaultOrdinalUnitValues; + objNow = gregorianToOrdinal(objNow); + } else { + units = orderedUnits2; + defaultValues = defaultUnitValues; + } + let foundFirst = false; + for (const u of units) { + const v = normalized[u]; + if (!isUndefined(v)) { + foundFirst = true; + } else if (foundFirst) { + normalized[u] = defaultValues[u]; + } else { + normalized[u] = objNow[u]; + } + } + const higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized) : containsOrdinal ? hasInvalidOrdinalData(normalized) : hasInvalidGregorianData(normalized), invalid = higherOrderInvalid || hasInvalidTimeData(normalized); + if (invalid) { + return DateTime.invalid(invalid); + } + const gregorian = useWeekData ? weekToGregorian(normalized) : containsOrdinal ? ordinalToGregorian(normalized) : normalized, [tsFinal, offsetFinal] = objToTS(gregorian, offsetProvis, zoneToUse), inst = new DateTime({ + ts: tsFinal, + zone: zoneToUse, + o: offsetFinal, + loc + }); + if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) { + return DateTime.invalid("mismatched weekday", `you can't specify both a weekday of ${normalized.weekday} and a date of ${inst.toISO()}`); + } + return inst; + } + static fromISO(text, opts = {}) { + const [vals, parsedZone] = parseISODate(text); + return parseDataToDateTime(vals, parsedZone, opts, "ISO 8601", text); + } + static fromRFC2822(text, opts = {}) { + const [vals, parsedZone] = parseRFC2822Date(text); + return parseDataToDateTime(vals, parsedZone, opts, "RFC 2822", text); + } + static fromHTTP(text, opts = {}) { + const [vals, parsedZone] = parseHTTPDate(text); + return parseDataToDateTime(vals, parsedZone, opts, "HTTP", opts); + } + static fromFormat(text, fmt, opts = {}) { + if (isUndefined(text) || isUndefined(fmt)) { + throw new InvalidArgumentError("fromFormat requires an input string and a format"); + } + const { locale = null, numberingSystem = null } = opts, localeToUse = Locale.fromOpts({ + locale, + numberingSystem, + defaultToEN: true + }), [vals, parsedZone, specificOffset, invalid] = parseFromTokens(localeToUse, text, fmt); + if (invalid) { + return DateTime.invalid(invalid); + } else { + return parseDataToDateTime(vals, parsedZone, opts, `format ${fmt}`, text, specificOffset); + } + } + static fromString(text, fmt, opts = {}) { + return DateTime.fromFormat(text, fmt, opts); + } + static fromSQL(text, opts = {}) { + const [vals, parsedZone] = parseSQL(text); + return parseDataToDateTime(vals, parsedZone, opts, "SQL", text); + } + static invalid(reason, explanation = null) { + if (!reason) { + throw new InvalidArgumentError("need to specify a reason the DateTime is invalid"); + } + const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation); + if (Settings.throwOnInvalid) { + throw new InvalidDateTimeError(invalid); + } else { + return new DateTime({ invalid }); + } + } + static isDateTime(o) { + return o && o.isLuxonDateTime || false; + } + static parseFormatForOpts(formatOpts, localeOpts = {}) { + const tokenList = formatOptsToTokens(formatOpts, Locale.fromObject(localeOpts)); + return !tokenList ? null : tokenList.map((t) => t ? t.val : null).join(""); + } + static expandFormat(fmt, localeOpts = {}) { + const expanded = expandMacroTokens(Formatter.parseFormat(fmt), Locale.fromObject(localeOpts)); + return expanded.map((t) => t.val).join(""); + } + get(unit) { + return this[unit]; + } + get isValid() { + return this.invalid === null; + } + get invalidReason() { + return this.invalid ? this.invalid.reason : null; + } + get invalidExplanation() { + return this.invalid ? this.invalid.explanation : null; + } + get locale() { + return this.isValid ? this.loc.locale : null; + } + get numberingSystem() { + return this.isValid ? this.loc.numberingSystem : null; + } + get outputCalendar() { + return this.isValid ? this.loc.outputCalendar : null; + } + get zone() { + return this._zone; + } + get zoneName() { + return this.isValid ? this.zone.name : null; + } + get year() { + return this.isValid ? this.c.year : NaN; + } + get quarter() { + return this.isValid ? Math.ceil(this.c.month / 3) : NaN; + } + get month() { + return this.isValid ? this.c.month : NaN; + } + get day() { + return this.isValid ? this.c.day : NaN; + } + get hour() { + return this.isValid ? this.c.hour : NaN; + } + get minute() { + return this.isValid ? this.c.minute : NaN; + } + get second() { + return this.isValid ? this.c.second : NaN; + } + get millisecond() { + return this.isValid ? this.c.millisecond : NaN; + } + get weekYear() { + return this.isValid ? possiblyCachedWeekData(this).weekYear : NaN; + } + get weekNumber() { + return this.isValid ? possiblyCachedWeekData(this).weekNumber : NaN; + } + get weekday() { + return this.isValid ? possiblyCachedWeekData(this).weekday : NaN; + } + get ordinal() { + return this.isValid ? gregorianToOrdinal(this.c).ordinal : NaN; + } + get monthShort() { + return this.isValid ? Info.months("short", { locObj: this.loc })[this.month - 1] : null; + } + get monthLong() { + return this.isValid ? Info.months("long", { locObj: this.loc })[this.month - 1] : null; + } + get weekdayShort() { + return this.isValid ? Info.weekdays("short", { locObj: this.loc })[this.weekday - 1] : null; + } + get weekdayLong() { + return this.isValid ? Info.weekdays("long", { locObj: this.loc })[this.weekday - 1] : null; + } + get offset() { + return this.isValid ? +this.o : NaN; + } + get offsetNameShort() { + if (this.isValid) { + return this.zone.offsetName(this.ts, { + format: "short", + locale: this.locale + }); + } else { + return null; + } + } + get offsetNameLong() { + if (this.isValid) { + return this.zone.offsetName(this.ts, { + format: "long", + locale: this.locale + }); + } else { + return null; + } + } + get isOffsetFixed() { + return this.isValid ? this.zone.isUniversal : null; + } + get isInDST() { + if (this.isOffsetFixed) { + return false; + } else { + return this.offset > this.set({ month: 1, day: 1 }).offset || this.offset > this.set({ month: 5 }).offset; + } + } + get isInLeapYear() { + return isLeapYear(this.year); + } + get daysInMonth() { + return daysInMonth(this.year, this.month); + } + get daysInYear() { + return this.isValid ? daysInYear(this.year) : NaN; + } + get weeksInWeekYear() { + return this.isValid ? weeksInWeekYear(this.weekYear) : NaN; + } + resolvedLocaleOptions(opts = {}) { + const { locale, numberingSystem, calendar } = Formatter.create(this.loc.clone(opts), opts).resolvedOptions(this); + return { locale, numberingSystem, outputCalendar: calendar }; + } + toUTC(offset3 = 0, opts = {}) { + return this.setZone(FixedOffsetZone.instance(offset3), opts); + } + toLocal() { + return this.setZone(Settings.defaultZone); + } + setZone(zone, { keepLocalTime = false, keepCalendarTime = false } = {}) { + zone = normalizeZone(zone, Settings.defaultZone); + if (zone.equals(this.zone)) { + return this; + } else if (!zone.isValid) { + return DateTime.invalid(unsupportedZone(zone)); + } else { + let newTS = this.ts; + if (keepLocalTime || keepCalendarTime) { + const offsetGuess = zone.offset(this.ts); + const asObj = this.toObject(); + [newTS] = objToTS(asObj, offsetGuess, zone); + } + return clone2(this, { ts: newTS, zone }); + } + } + reconfigure({ locale, numberingSystem, outputCalendar } = {}) { + const loc = this.loc.clone({ locale, numberingSystem, outputCalendar }); + return clone2(this, { loc }); + } + setLocale(locale) { + return this.reconfigure({ locale }); + } + set(values) { + if (!this.isValid) + return this; + const normalized = normalizeObject(values, normalizeUnit), settingWeekStuff = !isUndefined(normalized.weekYear) || !isUndefined(normalized.weekNumber) || !isUndefined(normalized.weekday), containsOrdinal = !isUndefined(normalized.ordinal), containsGregorYear = !isUndefined(normalized.year), containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day), containsGregor = containsGregorYear || containsGregorMD, definiteWeekDef = normalized.weekYear || normalized.weekNumber; + if ((containsGregor || containsOrdinal) && definiteWeekDef) { + throw new ConflictingSpecificationError("Can't mix weekYear/weekNumber units with year/month/day or ordinals"); + } + if (containsGregorMD && containsOrdinal) { + throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day"); + } + let mixed; + if (settingWeekStuff) { + mixed = weekToGregorian(__spreadValues(__spreadValues({}, gregorianToWeek(this.c)), normalized)); + } else if (!isUndefined(normalized.ordinal)) { + mixed = ordinalToGregorian(__spreadValues(__spreadValues({}, gregorianToOrdinal(this.c)), normalized)); + } else { + mixed = __spreadValues(__spreadValues({}, this.toObject()), normalized); + if (isUndefined(normalized.day)) { + mixed.day = Math.min(daysInMonth(mixed.year, mixed.month), mixed.day); + } + } + const [ts, o] = objToTS(mixed, this.o, this.zone); + return clone2(this, { ts, o }); + } + plus(duration) { + if (!this.isValid) + return this; + const dur = Duration.fromDurationLike(duration); + return clone2(this, adjustTime(this, dur)); + } + minus(duration) { + if (!this.isValid) + return this; + const dur = Duration.fromDurationLike(duration).negate(); + return clone2(this, adjustTime(this, dur)); + } + startOf(unit) { + if (!this.isValid) + return this; + const o = {}, normalizedUnit = Duration.normalizeUnit(unit); + switch (normalizedUnit) { + case "years": + o.month = 1; + case "quarters": + case "months": + o.day = 1; + case "weeks": + case "days": + o.hour = 0; + case "hours": + o.minute = 0; + case "minutes": + o.second = 0; + case "seconds": + o.millisecond = 0; + break; + case "milliseconds": + break; + } + if (normalizedUnit === "weeks") { + o.weekday = 1; + } + if (normalizedUnit === "quarters") { + const q = Math.ceil(this.month / 3); + o.month = (q - 1) * 3 + 1; + } + return this.set(o); + } + endOf(unit) { + return this.isValid ? this.plus({ [unit]: 1 }).startOf(unit).minus(1) : this; + } + toFormat(fmt, opts = {}) { + return this.isValid ? Formatter.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID3; + } + toLocaleString(formatOpts = DATE_SHORT, opts = {}) { + return this.isValid ? Formatter.create(this.loc.clone(opts), formatOpts).formatDateTime(this) : INVALID3; + } + toLocaleParts(opts = {}) { + return this.isValid ? Formatter.create(this.loc.clone(opts), opts).formatDateTimeParts(this) : []; + } + toISO({ + format: format2 = "extended", + suppressSeconds = false, + suppressMilliseconds = false, + includeOffset = true, + extendedZone = false + } = {}) { + if (!this.isValid) { + return null; + } + const ext = format2 === "extended"; + let c = toISODate(this, ext); + c += "T"; + c += toISOTime(this, ext, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone); + return c; + } + toISODate({ format: format2 = "extended" } = {}) { + if (!this.isValid) { + return null; + } + return toISODate(this, format2 === "extended"); + } + toISOWeekDate() { + return toTechFormat(this, "kkkk-'W'WW-c"); + } + toISOTime({ + suppressMilliseconds = false, + suppressSeconds = false, + includeOffset = true, + includePrefix = false, + extendedZone = false, + format: format2 = "extended" + } = {}) { + if (!this.isValid) { + return null; + } + let c = includePrefix ? "T" : ""; + return c + toISOTime(this, format2 === "extended", suppressSeconds, suppressMilliseconds, includeOffset, extendedZone); + } + toRFC2822() { + return toTechFormat(this, "EEE, dd LLL yyyy HH:mm:ss ZZZ", false); + } + toHTTP() { + return toTechFormat(this.toUTC(), "EEE, dd LLL yyyy HH:mm:ss 'GMT'"); + } + toSQLDate() { + if (!this.isValid) { + return null; + } + return toISODate(this, true); + } + toSQLTime({ includeOffset = true, includeZone = false, includeOffsetSpace = true } = {}) { + let fmt = "HH:mm:ss.SSS"; + if (includeZone || includeOffset) { + if (includeOffsetSpace) { + fmt += " "; + } + if (includeZone) { + fmt += "z"; + } else if (includeOffset) { + fmt += "ZZ"; + } + } + return toTechFormat(this, fmt, true); + } + toSQL(opts = {}) { + if (!this.isValid) { + return null; + } + return `${this.toSQLDate()} ${this.toSQLTime(opts)}`; + } + toString() { + return this.isValid ? this.toISO() : INVALID3; + } + valueOf() { + return this.toMillis(); + } + toMillis() { + return this.isValid ? this.ts : NaN; + } + toSeconds() { + return this.isValid ? this.ts / 1e3 : NaN; + } + toUnixInteger() { + return this.isValid ? Math.floor(this.ts / 1e3) : NaN; + } + toJSON() { + return this.toISO(); + } + toBSON() { + return this.toJSDate(); + } + toObject(opts = {}) { + if (!this.isValid) + return {}; + const base = __spreadValues({}, this.c); + if (opts.includeConfig) { + base.outputCalendar = this.outputCalendar; + base.numberingSystem = this.loc.numberingSystem; + base.locale = this.loc.locale; + } + return base; + } + toJSDate() { + return new Date(this.isValid ? this.ts : NaN); + } + diff(otherDateTime, unit = "milliseconds", opts = {}) { + if (!this.isValid || !otherDateTime.isValid) { + return Duration.invalid("created by diffing an invalid DateTime"); + } + const durOpts = __spreadValues({ locale: this.locale, numberingSystem: this.numberingSystem }, opts); + const units = maybeArray(unit).map(Duration.normalizeUnit), otherIsLater = otherDateTime.valueOf() > this.valueOf(), earlier = otherIsLater ? this : otherDateTime, later = otherIsLater ? otherDateTime : this, diffed = diff_default(earlier, later, units, durOpts); + return otherIsLater ? diffed.negate() : diffed; + } + diffNow(unit = "milliseconds", opts = {}) { + return this.diff(DateTime.now(), unit, opts); + } + until(otherDateTime) { + return this.isValid ? Interval.fromDateTimes(this, otherDateTime) : this; + } + hasSame(otherDateTime, unit) { + if (!this.isValid) + return false; + const inputMs = otherDateTime.valueOf(); + const adjustedToZone = this.setZone(otherDateTime.zone, { keepLocalTime: true }); + return adjustedToZone.startOf(unit) <= inputMs && inputMs <= adjustedToZone.endOf(unit); + } + equals(other) { + return this.isValid && other.isValid && this.valueOf() === other.valueOf() && this.zone.equals(other.zone) && this.loc.equals(other.loc); + } + toRelative(options = {}) { + if (!this.isValid) + return null; + const base = options.base || DateTime.fromObject({}, { zone: this.zone }), padding = options.padding ? this < base ? -options.padding : options.padding : 0; + let units = ["years", "months", "days", "hours", "minutes", "seconds"]; + let unit = options.unit; + if (Array.isArray(options.unit)) { + units = options.unit; + unit = void 0; + } + return diffRelative(base, this.plus(padding), __spreadProps(__spreadValues({}, options), { + numeric: "always", + units, + unit + })); + } + toRelativeCalendar(options = {}) { + if (!this.isValid) + return null; + return diffRelative(options.base || DateTime.fromObject({}, { zone: this.zone }), this, __spreadProps(__spreadValues({}, options), { + numeric: "auto", + units: ["years", "months", "days"], + calendary: true + })); + } + static min(...dateTimes) { + if (!dateTimes.every(DateTime.isDateTime)) { + throw new InvalidArgumentError("min requires all arguments be DateTimes"); + } + return bestBy(dateTimes, (i) => i.valueOf(), Math.min); + } + static max(...dateTimes) { + if (!dateTimes.every(DateTime.isDateTime)) { + throw new InvalidArgumentError("max requires all arguments be DateTimes"); + } + return bestBy(dateTimes, (i) => i.valueOf(), Math.max); + } + static fromFormatExplain(text, fmt, options = {}) { + const { locale = null, numberingSystem = null } = options, localeToUse = Locale.fromOpts({ + locale, + numberingSystem, + defaultToEN: true + }); + return explainFromTokens(localeToUse, text, fmt); + } + static fromStringExplain(text, fmt, options = {}) { + return DateTime.fromFormatExplain(text, fmt, options); + } + static get DATE_SHORT() { + return DATE_SHORT; + } + static get DATE_MED() { + return DATE_MED; + } + static get DATE_MED_WITH_WEEKDAY() { + return DATE_MED_WITH_WEEKDAY; + } + static get DATE_FULL() { + return DATE_FULL; + } + static get DATE_HUGE() { + return DATE_HUGE; + } + static get TIME_SIMPLE() { + return TIME_SIMPLE; + } + static get TIME_WITH_SECONDS() { + return TIME_WITH_SECONDS; + } + static get TIME_WITH_SHORT_OFFSET() { + return TIME_WITH_SHORT_OFFSET; + } + static get TIME_WITH_LONG_OFFSET() { + return TIME_WITH_LONG_OFFSET; + } + static get TIME_24_SIMPLE() { + return TIME_24_SIMPLE; + } + static get TIME_24_WITH_SECONDS() { + return TIME_24_WITH_SECONDS; + } + static get TIME_24_WITH_SHORT_OFFSET() { + return TIME_24_WITH_SHORT_OFFSET; + } + static get TIME_24_WITH_LONG_OFFSET() { + return TIME_24_WITH_LONG_OFFSET; + } + static get DATETIME_SHORT() { + return DATETIME_SHORT; + } + static get DATETIME_SHORT_WITH_SECONDS() { + return DATETIME_SHORT_WITH_SECONDS; + } + static get DATETIME_MED() { + return DATETIME_MED; + } + static get DATETIME_MED_WITH_SECONDS() { + return DATETIME_MED_WITH_SECONDS; + } + static get DATETIME_MED_WITH_WEEKDAY() { + return DATETIME_MED_WITH_WEEKDAY; + } + static get DATETIME_FULL() { + return DATETIME_FULL; + } + static get DATETIME_FULL_WITH_SECONDS() { + return DATETIME_FULL_WITH_SECONDS; + } + static get DATETIME_HUGE() { + return DATETIME_HUGE; + } + static get DATETIME_HUGE_WITH_SECONDS() { + return DATETIME_HUGE_WITH_SECONDS; + } +}; +function friendlyDateTime(dateTimeish) { + if (DateTime.isDateTime(dateTimeish)) { + return dateTimeish; + } else if (dateTimeish && dateTimeish.valueOf && isNumber(dateTimeish.valueOf())) { + return DateTime.fromJSDate(dateTimeish); + } else if (dateTimeish && typeof dateTimeish === "object") { + return DateTime.fromObject(dateTimeish); + } else { + throw new InvalidArgumentError(`Unknown datetime argument: ${dateTimeish}, of type ${typeof dateTimeish}`); + } +} + +// src/Publisher.ts +var import_obsidian2 = __toModule(require("obsidian")); + +// node_modules/js-base64/base64.mjs +var version = "3.7.2"; +var VERSION = version; +var _hasatob = typeof atob === "function"; +var _hasbtoa = typeof btoa === "function"; +var _hasBuffer = typeof Buffer === "function"; +var _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0; +var _TE = typeof TextEncoder === "function" ? new TextEncoder() : void 0; +var b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; +var b64chs = Array.prototype.slice.call(b64ch); +var b64tab = ((a) => { + let tab = {}; + a.forEach((c, i) => tab[c] = i); + return tab; +})(b64chs); +var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/; +var _fromCC = String.fromCharCode.bind(String); +var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it, fn2 = (x) => x) => new Uint8Array(Array.prototype.slice.call(it, 0).map(fn2)); +var _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_"); +var _tidyB64 = (s2) => s2.replace(/[^A-Za-z0-9\+\/]/g, ""); +var btoaPolyfill = (bin) => { + let u32, c0, c1, c2, asc = ""; + const pad = bin.length % 3; + for (let i = 0; i < bin.length; ) { + if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255) + throw new TypeError("invalid character found"); + u32 = c0 << 16 | c1 << 8 | c2; + asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63]; + } + return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc; +}; +var _btoa = _hasbtoa ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill; +var _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => { + const maxargs = 4096; + let strs = []; + for (let i = 0, l2 = u8a.length; i < l2; i += maxargs) { + strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs))); + } + return _btoa(strs.join("")); +}; +var fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a); +var cb_utob = (c) => { + if (c.length < 2) { + var cc = c.charCodeAt(0); + return cc < 128 ? c : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63); + } else { + var cc = 65536 + (c.charCodeAt(0) - 55296) * 1024 + (c.charCodeAt(1) - 56320); + return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63); + } +}; +var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g; +var utob = (u) => u.replace(re_utob, cb_utob); +var _encode = _hasBuffer ? (s2) => Buffer.from(s2, "utf8").toString("base64") : _TE ? (s2) => _fromUint8Array(_TE.encode(s2)) : (s2) => _btoa(utob(s2)); +var encode = (src, urlsafe = false) => urlsafe ? _mkUriSafe(_encode(src)) : _encode(src); +var encodeURI2 = (src) => encode(src, true); +var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g; +var cb_btou = (cccc) => { + switch (cccc.length) { + case 4: + var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset3 = cp - 65536; + return _fromCC((offset3 >>> 10) + 55296) + _fromCC((offset3 & 1023) + 56320); + case 3: + return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2)); + default: + return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1)); + } +}; +var btou = (b) => b.replace(re_btou, cb_btou); +var atobPolyfill = (asc) => { + asc = asc.replace(/\s+/g, ""); + if (!b64re.test(asc)) + throw new TypeError("malformed base64."); + asc += "==".slice(2 - (asc.length & 3)); + let u24, bin = "", r1, r2; + for (let i = 0; i < asc.length; ) { + u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]); + bin += r1 === 64 ? _fromCC(u24 >> 16 & 255) : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255) : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255); + } + return bin; +}; +var _atob = _hasatob ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill; +var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a), (c) => c.charCodeAt(0)); +var toUint8Array = (a) => _toUint8Array(_unURI(a)); +var _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a)); +var _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/")); +var decode = (src) => _decode(_unURI(src)); +var isValid = (src) => { + if (typeof src !== "string") + return false; + const s2 = src.replace(/\s+/g, "").replace(/={0,2}$/, ""); + return !/[^\s0-9a-zA-Z\+/]/.test(s2) || !/[^\s0-9a-zA-Z\-_]/.test(s2); +}; +var _noEnum = (v) => { + return { + value: v, + enumerable: false, + writable: true, + configurable: true + }; +}; +var extendString = function() { + const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body)); + _add("fromBase64", function() { + return decode(this); + }); + _add("toBase64", function(urlsafe) { + return encode(this, urlsafe); + }); + _add("toBase64URI", function() { + return encode(this, true); + }); + _add("toBase64URL", function() { + return encode(this, true); + }); + _add("toUint8Array", function() { + return toUint8Array(this); + }); +}; +var extendUint8Array = function() { + const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body)); + _add("toBase64", function(urlsafe) { + return fromUint8Array(this, urlsafe); + }); + _add("toBase64URI", function() { + return fromUint8Array(this, true); + }); + _add("toBase64URL", function() { + return fromUint8Array(this, true); + }); +}; +var extendBuiltins = () => { + extendString(); + extendUint8Array(); +}; +var gBase64 = { + version, + VERSION, + atob: _atob, + atobPolyfill, + btoa: _btoa, + btoaPolyfill, + fromBase64: decode, + toBase64: encode, + encode, + encodeURI: encodeURI2, + encodeURL: encodeURI2, + utob, + btou, + decode, + isValid, + fromUint8Array, + toUint8Array, + extendString, + extendUint8Array, + extendBuiltins +}; + +// node_modules/universal-user-agent/dist-web/index.js +function getUserAgent() { + if (typeof navigator === "object" && "userAgent" in navigator) { + return navigator.userAgent; + } + if (typeof process === "object" && "version" in process) { + return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; + } + return ""; +} + +// node_modules/@octokit/core/dist-web/index.js +var import_before_after_hook = __toModule(require_before_after_hook()); + +// node_modules/is-plain-object/dist/is-plain-object.mjs +function isObject(o) { + return Object.prototype.toString.call(o) === "[object Object]"; +} +function isPlainObject(o) { + var ctor, prot; + if (isObject(o) === false) + return false; + ctor = o.constructor; + if (ctor === void 0) + return true; + prot = ctor.prototype; + if (isObject(prot) === false) + return false; + if (prot.hasOwnProperty("isPrototypeOf") === false) { + return false; + } + return true; +} + +// node_modules/@octokit/endpoint/dist-web/index.js +function lowercaseKeys(object) { + if (!object) { + return {}; + } + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); +} +function mergeDeep(defaults, options) { + const result = Object.assign({}, defaults); + Object.keys(options).forEach((key) => { + if (isPlainObject(options[key])) { + if (!(key in defaults)) + Object.assign(result, { [key]: options[key] }); + else + result[key] = mergeDeep(defaults[key], options[key]); + } else { + Object.assign(result, { [key]: options[key] }); + } + }); + return result; +} +function removeUndefinedProperties(obj) { + for (const key in obj) { + if (obj[key] === void 0) { + delete obj[key]; + } + } + return obj; +} +function merge(defaults, route, options) { + if (typeof route === "string") { + let [method, url] = route.split(" "); + options = Object.assign(url ? { method, url } : { url: method }, options); + } else { + options = Object.assign({}, route); + } + options.headers = lowercaseKeys(options.headers); + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults || {}, options); + if (defaults && defaults.mediaType.previews.length) { + mergedOptions.mediaType.previews = defaults.mediaType.previews.filter((preview) => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); + } + mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map((preview) => preview.replace(/-preview/, "")); + return mergedOptions; +} +function addQueryParameters(url, parameters) { + const separator = /\?/.test(url) ? "&" : "?"; + const names = Object.keys(parameters); + if (names.length === 0) { + return url; + } + return url + separator + names.map((name) => { + if (name === "q") { + return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); + } + return `${name}=${encodeURIComponent(parameters[name])}`; + }).join("&"); +} +var urlVariableRegex = /\{[^}]+\}/g; +function removeNonChars(variableName) { + return variableName.replace(/^\W+|\W+$/g, "").split(/,/); +} +function extractUrlVariableNames(url) { + const matches = url.match(urlVariableRegex); + if (!matches) { + return []; + } + return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []); +} +function omit(object, keysToOmit) { + return Object.keys(object).filter((option) => !keysToOmit.includes(option)).reduce((obj, key) => { + obj[key] = object[key]; + return obj; + }, {}); +} +function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) { + if (!/%[0-9A-Fa-f]/.test(part)) { + part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); + } + return part; + }).join(""); +} +function encodeUnreserved(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function(c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} +function encodeValue(operator, value, key) { + value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); + if (key) { + return encodeUnreserved(key) + "=" + value; + } else { + return value; + } +} +function isDefined(value) { + return value !== void 0 && value !== null; +} +function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; +} +function getValues(context, operator, key, modifier) { + var value = context[key], result = []; + if (isDefined(value) && value !== "") { + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + value = value.toString(); + if (modifier && modifier !== "*") { + value = value.substring(0, parseInt(modifier, 10)); + } + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + } else { + if (modifier === "*") { + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function(value2) { + result.push(encodeValue(operator, value2, isKeyOperator(operator) ? key : "")); + }); + } else { + Object.keys(value).forEach(function(k) { + if (isDefined(value[k])) { + result.push(encodeValue(operator, value[k], k)); + } + }); + } + } else { + const tmp = []; + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function(value2) { + tmp.push(encodeValue(operator, value2)); + }); + } else { + Object.keys(value).forEach(function(k) { + if (isDefined(value[k])) { + tmp.push(encodeUnreserved(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + } + if (isKeyOperator(operator)) { + result.push(encodeUnreserved(key) + "=" + tmp.join(",")); + } else if (tmp.length !== 0) { + result.push(tmp.join(",")); + } + } + } + } else { + if (operator === ";") { + if (isDefined(value)) { + result.push(encodeUnreserved(key)); + } + } else if (value === "" && (operator === "&" || operator === "?")) { + result.push(encodeUnreserved(key) + "="); + } else if (value === "") { + result.push(""); + } + } + return result; +} +function parseUrl(template) { + return { + expand: expand.bind(null, template) + }; +} +function expand(template, context) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression, literal) { + if (expression) { + let operator = ""; + const values = []; + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + expression.split(/,/g).forEach(function(variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + }); + if (operator && operator !== "+") { + var separator = ","; + if (operator === "?") { + separator = "&"; + } else if (operator !== "#") { + separator = operator; + } + return (values.length !== 0 ? operator : "") + values.join(separator); + } else { + return values.join(","); + } + } else { + return encodeReserved(literal); + } + }); +} +function parse2(options) { + let method = options.method.toUpperCase(); + let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}"); + let headers = Object.assign({}, options.headers); + let body; + let parameters = omit(options, [ + "method", + "baseUrl", + "url", + "headers", + "request", + "mediaType" + ]); + const urlVariableNames = extractUrlVariableNames(url); + url = parseUrl(url).expand(parameters); + if (!/^http/.test(url)) { + url = options.baseUrl + url; + } + const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl"); + const remainingParameters = omit(parameters, omittedParameters); + const isBinaryRequest = /application\/octet-stream/i.test(headers.accept); + if (!isBinaryRequest) { + if (options.mediaType.format) { + headers.accept = headers.accept.split(/,/).map((preview) => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); + } + if (options.mediaType.previews.length) { + const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || []; + headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => { + const format2 = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format2}`; + }).join(","); + } + } + if (["GET", "HEAD"].includes(method)) { + url = addQueryParameters(url, remainingParameters); + } else { + if ("data" in remainingParameters) { + body = remainingParameters.data; + } else { + if (Object.keys(remainingParameters).length) { + body = remainingParameters; + } else { + headers["content-length"] = 0; + } + } + } + if (!headers["content-type"] && typeof body !== "undefined") { + headers["content-type"] = "application/json; charset=utf-8"; + } + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { + body = ""; + } + return Object.assign({ method, url, headers }, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null); +} +function endpointWithDefaults(defaults, route, options) { + return parse2(merge(defaults, route, options)); +} +function withDefaults(oldDefaults, newDefaults) { + const DEFAULTS2 = merge(oldDefaults, newDefaults); + const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2); + return Object.assign(endpoint2, { + DEFAULTS: DEFAULTS2, + defaults: withDefaults.bind(null, DEFAULTS2), + merge: merge.bind(null, DEFAULTS2), + parse: parse2 + }); +} +var VERSION2 = "6.0.12"; +var userAgent = `octokit-endpoint.js/${VERSION2} ${getUserAgent()}`; +var DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": userAgent + }, + mediaType: { + format: "", + previews: [] + } +}; +var endpoint = withDefaults(null, DEFAULTS); + +// node_modules/@octokit/request/dist-web/index.js +var import_node_fetch = __toModule(require_browser()); + +// node_modules/deprecation/dist-web/index.js +var Deprecation = class extends Error { + constructor(message) { + super(message); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + this.name = "Deprecation"; + } +}; + +// node_modules/@octokit/request-error/dist-web/index.js +var import_once = __toModule(require_once()); +var logOnceCode = (0, import_once.default)((deprecation) => console.warn(deprecation)); +var logOnceHeaders = (0, import_once.default)((deprecation) => console.warn(deprecation)); +var RequestError = class extends Error { + constructor(message, statusCode, options) { + super(message); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + this.name = "HttpError"; + this.status = statusCode; + let headers; + if ("headers" in options && typeof options.headers !== "undefined") { + headers = options.headers; + } + if ("response" in options) { + this.response = options.response; + headers = options.response.headers; + } + const requestCopy = Object.assign({}, options.request); + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") + }); + } + requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); + this.request = requestCopy; + Object.defineProperty(this, "code", { + get() { + logOnceCode(new Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); + return statusCode; + } + }); + Object.defineProperty(this, "headers", { + get() { + logOnceHeaders(new Deprecation("[@octokit/request-error] `error.headers` is deprecated, use `error.response.headers`.")); + return headers || {}; + } + }); + } +}; + +// node_modules/@octokit/request/dist-web/index.js +var VERSION3 = "5.6.3"; +function getBufferResponse(response) { + return response.arrayBuffer(); +} +function fetchWrapper(requestOptions) { + const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; + if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + let headers = {}; + let status; + let url; + const fetch = requestOptions.request && requestOptions.request.fetch || import_node_fetch.default; + return fetch(requestOptions.url, Object.assign({ + method: requestOptions.method, + body: requestOptions.body, + headers: requestOptions.headers, + redirect: requestOptions.redirect + }, requestOptions.request)).then((response) => __async(this, null, function* () { + url = response.url; + status = response.status; + for (const keyAndValue of response.headers) { + headers[keyAndValue[0]] = keyAndValue[1]; + } + if ("deprecation" in headers) { + const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/); + const deprecationLink = matches && matches.pop(); + log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`); + } + if (status === 204 || status === 205) { + return; + } + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + throw new RequestError(response.statusText, status, { + response: { + url, + status, + headers, + data: void 0 + }, + request: requestOptions + }); + } + if (status === 304) { + throw new RequestError("Not modified", status, { + response: { + url, + status, + headers, + data: yield getResponseData(response) + }, + request: requestOptions + }); + } + if (status >= 400) { + const data = yield getResponseData(response); + const error = new RequestError(toErrorMessage(data), status, { + response: { + url, + status, + headers, + data + }, + request: requestOptions + }); + throw error; + } + return getResponseData(response); + })).then((data) => { + return { + status, + url, + headers, + data + }; + }).catch((error) => { + if (error instanceof RequestError) + throw error; + throw new RequestError(error.message, 500, { + request: requestOptions + }); + }); +} +function getResponseData(response) { + return __async(this, null, function* () { + const contentType = response.headers.get("content-type"); + if (/application\/json/.test(contentType)) { + return response.json(); + } + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + return getBufferResponse(response); + }); +} +function toErrorMessage(data) { + if (typeof data === "string") + return data; + if ("message" in data) { + if (Array.isArray(data.errors)) { + return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`; + } + return data.message; + } + return `Unknown error: ${JSON.stringify(data)}`; +} +function withDefaults2(oldEndpoint, newDefaults) { + const endpoint2 = oldEndpoint.defaults(newDefaults); + const newApi = function(route, parameters) { + const endpointOptions = endpoint2.merge(route, parameters); + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint2.parse(endpointOptions)); + } + const request2 = (route2, parameters2) => { + return fetchWrapper(endpoint2.parse(endpoint2.merge(route2, parameters2))); + }; + Object.assign(request2, { + endpoint: endpoint2, + defaults: withDefaults2.bind(null, endpoint2) + }); + return endpointOptions.request.hook(request2, endpointOptions); + }; + return Object.assign(newApi, { + endpoint: endpoint2, + defaults: withDefaults2.bind(null, endpoint2) + }); +} +var request = withDefaults2(endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION3} ${getUserAgent()}` + } +}); + +// node_modules/@octokit/graphql/dist-web/index.js +var VERSION4 = "4.8.0"; +function _buildMessageForResponseErrors(data) { + return `Request failed due to following response errors: +` + data.errors.map((e) => ` - ${e.message}`).join("\n"); +} +var GraphqlResponseError = class extends Error { + constructor(request2, headers, response) { + super(_buildMessageForResponseErrors(response)); + this.request = request2; + this.headers = headers; + this.response = response; + this.name = "GraphqlResponseError"; + this.errors = response.errors; + this.data = response.data; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } +}; +var NON_VARIABLE_OPTIONS = [ + "method", + "baseUrl", + "url", + "headers", + "request", + "query", + "mediaType" +]; +var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; +var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; +function graphql(request2, query, options) { + if (options) { + if (typeof query === "string" && "query" in options) { + return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); + } + for (const key in options) { + if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) + continue; + return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)); + } + } + const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query; + const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = parsedOptions[key]; + return result; + } + if (!result.variables) { + result.variables = {}; + } + result.variables[key] = parsedOptions[key]; + return result; + }, {}); + const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl; + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + return request2(requestOptions).then((response) => { + if (response.data.errors) { + const headers = {}; + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + throw new GraphqlResponseError(requestOptions, headers, response.data); + } + return response.data.data; + }); +} +function withDefaults3(request$1, newDefaults) { + const newRequest = request$1.defaults(newDefaults); + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + return Object.assign(newApi, { + defaults: withDefaults3.bind(null, newRequest), + endpoint: request.endpoint + }); +} +var graphql$1 = withDefaults3(request, { + headers: { + "user-agent": `octokit-graphql.js/${VERSION4} ${getUserAgent()}` + }, + method: "POST", + url: "/graphql" +}); +function withCustomRequest(customRequest) { + return withDefaults3(customRequest, { + method: "POST", + url: "/graphql" + }); +} + +// node_modules/@octokit/auth-token/dist-web/index.js +var REGEX_IS_INSTALLATION_LEGACY = /^v1\./; +var REGEX_IS_INSTALLATION = /^ghs_/; +var REGEX_IS_USER_TO_SERVER = /^ghu_/; +function auth(token) { + return __async(this, null, function* () { + const isApp = token.split(/\./).length === 3; + const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token); + const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token); + const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth"; + return { + type: "token", + token, + tokenType + }; + }); +} +function withAuthorizationPrefix(token) { + if (token.split(/\./).length === 3) { + return `bearer ${token}`; + } + return `token ${token}`; +} +function hook(token, request2, route, parameters) { + return __async(this, null, function* () { + const endpoint2 = request2.endpoint.merge(route, parameters); + endpoint2.headers.authorization = withAuthorizationPrefix(token); + return request2(endpoint2); + }); +} +var createTokenAuth = function createTokenAuth2(token) { + if (!token) { + throw new Error("[@octokit/auth-token] No token passed to createTokenAuth"); + } + if (typeof token !== "string") { + throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string"); + } + token = token.replace(/^(token|bearer) +/i, ""); + return Object.assign(auth.bind(null, token), { + hook: hook.bind(null, token) + }); +}; + +// node_modules/@octokit/core/dist-web/index.js +var VERSION5 = "3.6.0"; +var Octokit = class { + constructor(options = {}) { + const hook2 = new import_before_after_hook.Collection(); + const requestDefaults = { + baseUrl: request.endpoint.DEFAULTS.baseUrl, + headers: {}, + request: Object.assign({}, options.request, { + hook: hook2.bind(null, "request") + }), + mediaType: { + previews: [], + format: "" + } + }; + requestDefaults.headers["user-agent"] = [ + options.userAgent, + `octokit-core.js/${VERSION5} ${getUserAgent()}` + ].filter(Boolean).join(" "); + if (options.baseUrl) { + requestDefaults.baseUrl = options.baseUrl; + } + if (options.previews) { + requestDefaults.mediaType.previews = options.previews; + } + if (options.timeZone) { + requestDefaults.headers["time-zone"] = options.timeZone; + } + this.request = request.defaults(requestDefaults); + this.graphql = withCustomRequest(this.request).defaults(requestDefaults); + this.log = Object.assign({ + debug: () => { + }, + info: () => { + }, + warn: console.warn.bind(console), + error: console.error.bind(console) + }, options.log); + this.hook = hook2; + if (!options.authStrategy) { + if (!options.auth) { + this.auth = () => __async(this, null, function* () { + return { + type: "unauthenticated" + }; + }); + } else { + const auth2 = createTokenAuth(options.auth); + hook2.wrap("request", auth2.hook); + this.auth = auth2; + } + } else { + const _a = options, { authStrategy } = _a, otherOptions = __objRest(_a, ["authStrategy"]); + const auth2 = authStrategy(Object.assign({ + request: this.request, + log: this.log, + octokit: this, + octokitOptions: otherOptions + }, options.auth)); + hook2.wrap("request", auth2.hook); + this.auth = auth2; + } + const classConstructor = this.constructor; + classConstructor.plugins.forEach((plugin) => { + Object.assign(this, plugin(this, options)); + }); + } + static defaults(defaults) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + if (typeof defaults === "function") { + super(defaults(options)); + return; + } + super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { + userAgent: `${options.userAgent} ${defaults.userAgent}` + } : null)); + } + }; + return OctokitWithDefaults; + } + static plugin(...newPlugins) { + var _a; + const currentPlugins = this.plugins; + const NewOctokit = (_a = class extends this { + }, _a.plugins = currentPlugins.concat(newPlugins.filter((plugin) => !currentPlugins.includes(plugin))), _a); + return NewOctokit; + } +}; +Octokit.VERSION = VERSION5; +Octokit.plugins = []; + +// src/utils.ts +var import_slugify = __toModule(require_slugify()); +var import_sha1 = __toModule(require_sha1()); +function arrayBufferToBase64(buffer) { + let binary = ""; + const bytes = new Uint8Array(buffer); + const len = bytes.byteLength; + for (let i = 0; i < len; i++) { + binary += String.fromCharCode(bytes[i]); + } + return gBase64.btoa(binary); +} +function extractBaseUrl(url) { + return url && url.replace("https://", "").replace("http://", "").replace(/\/$/, ""); +} +function generateUrlPath(filePath, slugifyPath = true) { + if (!filePath) { + return filePath; + } + const extensionLessPath = filePath.substring(0, filePath.lastIndexOf(".")); + if (!slugifyPath) { + return extensionLessPath + "/"; + } + return extensionLessPath.split("/").map((x) => (0, import_slugify.default)(x)).join("/") + "/"; +} +function generateBlobHash(content) { + const byteLength = new TextEncoder().encode(content).byteLength; + const header = `blob ${byteLength}\0`; + const gitBlob = header + content; + return (0, import_sha1.default)(gitBlob).toString(); +} +function kebabize(str) { + return str.split("").map((letter, idx) => { + return letter.toUpperCase() === letter ? `${idx !== 0 ? "-" : ""}${letter.toLowerCase()}` : letter; + }).join(""); +} +var wrapAround = (value, size) => { + return (value % size + size) % size; +}; +function getRewriteRules(pathRewriteRules) { + return pathRewriteRules.split("\n").map((line) => { + return line.split(":"); + }).filter((rule) => { + return rule.length == 2; + }); +} +function getGardenPathForNote(vaultPath, rules) { + for (let index = 0; index < rules.length; index++) { + const rule = rules[index]; + if (vaultPath.startsWith(rule[0])) { + return rule[1] + vaultPath.slice(rule[0].length); + } + } + return vaultPath; +} +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function fixSvgForXmlSerializer(svgElement) { + const styles = svgElement.getElementsByTagName("style"); + if (styles.length > 0) { + for (let i = 0; i < styles.length; i++) { + const style = styles[i]; + if (!style.textContent.trim()) { + style.textContent = "/**/"; + } + } + } +} + +// src/Validator.ts +var import_obsidian = __toModule(require("obsidian")); +function vallidatePublishFrontmatter(frontMatter) { + if (!frontMatter || !frontMatter["dg-publish"]) { + new import_obsidian.Notice("Note does not have the dg-publish: true set. Please add this and try again."); + return false; + } + return true; +} + +// src/constants.ts +var seedling = `Layer 1`; +var excaliDrawBundle = `