From 0d4a937b7958cb6c1f6256d4583cfc9c6b22ecc7 Mon Sep 17 00:00:00 2001 From: rawpixel-vincent Date: Thu, 14 Mar 2024 15:45:24 +0700 Subject: [PATCH] add cjs exports --- .eslintrc.json | 1 + README.md | 10 - StringLiteralList.js | 54 +- jsconfig.json | 3 +- package-lock.json | 407 +++++++ package.json | 15 +- strict.cjs | 2395 ++++++++++++++++++++++++++++++++++++++++++ stringList.cjs | 2391 +++++++++++++++++++++++++++++++++++++++++ stringList.test.js | 157 +-- types/list.d.ts | 42 +- 10 files changed, 5342 insertions(+), 133 deletions(-) create mode 100644 strict.cjs create mode 100644 stringList.cjs diff --git a/.eslintrc.json b/.eslintrc.json index a3e00e5..e5e5d74 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -17,6 +17,7 @@ ] }, "overrides": [], + "ignorePatterns": ["*.cjs"], "parserOptions": { "ecmaVersion": 14, "sourceType": "module" diff --git a/README.md b/README.md index 3b60621..4c9a0e1 100644 --- a/README.md +++ b/README.md @@ -21,7 +21,6 @@ The StringList class extends the Array with new methods and supercharges the arr - `without(...$)`: filter out the given values, accept string and StringList. - `withPrefix($)` and `withSuffix($)`: add prefix/suffix to all the words. - - `withDerivatedPrefix($)` and `withDerivatedSuffix($)`: Generate words variants with or without the given suffix/prefix depending on their presence. - `value($)`: similar to enum but throws an error if the value doesn't exists. - `enum[$]:$` Object is exposed as readonly. - `withTrim()`: trim all the words. @@ -129,15 +128,6 @@ const arr = list.mutable(); // => ["foo","bar"] list.value('foo'); // 'foo' list.value('n'); // throws error -// Generate words variants with or without the given suffix/prefix depending on their presence. -const foods = sl('food', 'bars', 'pasta', 'meatballs'); -foods.withDerivatedSuffix('s'); -// => SL<"food" | "bars" | "pasta" | "meatballs" | "foods" | "pastas" | "bar" | "meatball"> - -const tags = sl('spring', '#boot', '#typescript', 'fundamentals'); -tags.withDerivatedPrefix('#'); -//=> SL<"#spring" | "#boot" | "#typescript" | "#fundamentals" | "spring" | "boot" | "typescript" | "fundamentals"> - const scored = sl(' has ', 'spaces', ' between ', ' o r', 'in the words') .withTrim() .withReplaceAll(' ', '_'); diff --git a/StringLiteralList.js b/StringLiteralList.js index c7978c5..292d85c 100644 --- a/StringLiteralList.js +++ b/StringLiteralList.js @@ -124,33 +124,33 @@ export class SL extends Array { ); } - withDerivatedSuffix(chars = '') { - return freezeIfImmutable( - this, - new SL( - ...super.flatMap((t) => [ - t, - t.endsWith(chars) - ? t.slice(0, Math.min(t.length, chars.length) * -1) - : `${t}${chars}`, - ]), - ), - ); - } - - withDerivatedPrefix(chars = '') { - return freezeIfImmutable( - this, - new SL( - ...super.flatMap((t) => [ - t, - t.startsWith(chars) - ? t.slice(Math.min(chars.length, t.length), t.length) - : `${chars}${t}`, - ]), - ), - ); - } + // withDerivatedSuffix(chars = '') { + // return freezeIfImmutable( + // this, + // new SL( + // ...super.flatMap((t) => [ + // t, + // t.endsWith(chars) + // ? t.slice(0, Math.min(t.length, chars.length) * -1) + // : `${t}${chars}`, + // ]), + // ), + // ); + // } + + // withDerivatedPrefix(chars = '') { + // return freezeIfImmutable( + // this, + // new SL( + // ...super.flatMap((t) => [ + // t, + // t.startsWith(chars) + // ? t.slice(Math.min(chars.length, t.length), t.length) + // : `${chars}${t}`, + // ]), + // ), + // ); + // } withReplace(string, replacement = undefined) { return freezeIfImmutable( diff --git a/jsconfig.json b/jsconfig.json index ffe2448..800ffdf 100644 --- a/jsconfig.json +++ b/jsconfig.json @@ -13,5 +13,6 @@ "traceResolution": false, "allowSyntheticDefaultImports": true }, - "include": ["*.js", "*.d.ts", "*.ts", "types/*"] + "include": ["*.js", "*.d.ts", "*.ts", "types/*.d.ts"], + "exclude": ["node_modules", "*.cjs", "**/*.cjs"] } diff --git a/package-lock.json b/package-lock.json index 06bf80a..8c0547e 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13,6 +13,7 @@ "string-ts": "^2.0.0" }, "devDependencies": { + "esbuild": "^0.20.1", "eslint": "latest", "eslint-config-prettier": "latest", "eslint-config-standard": "latest", @@ -72,6 +73,374 @@ "node": ">=12" } }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.20.1.tgz", + "integrity": "sha512-m55cpeupQ2DbuRGQMMZDzbv9J9PgVelPjlcmM5kxHnrBdBx6REaEd7LamYV7Dm8N7rCyR/XwU6rVP8ploKtIkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.20.1.tgz", + "integrity": "sha512-4j0+G27/2ZXGWR5okcJi7pQYhmkVgb4D7UKwxcqrjhvp5TKWx3cUjgB1CGj1mfdmJBQ9VnUGgUhign+FPF2Zgw==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.20.1.tgz", + "integrity": "sha512-hCnXNF0HM6AjowP+Zou0ZJMWWa1VkD77BXe959zERgGJBBxB+sV+J9f/rcjeg2c5bsukD/n17RKWXGFCO5dD5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.20.1.tgz", + "integrity": "sha512-MSfZMBoAsnhpS+2yMFYIQUPs8Z19ajwfuaSZx+tSl09xrHZCjbeXXMsUF/0oq7ojxYEpsSo4c0SfjxOYXRbpaA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.20.1.tgz", + "integrity": "sha512-Ylk6rzgMD8klUklGPzS414UQLa5NPXZD5tf8JmQU8GQrj6BrFA/Ic9tb2zRe1kOZyCbGl+e8VMbDRazCEBqPvA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.20.1.tgz", + "integrity": "sha512-pFIfj7U2w5sMp52wTY1XVOdoxw+GDwy9FsK3OFz4BpMAjvZVs0dT1VXs8aQm22nhwoIWUmIRaE+4xow8xfIDZA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.20.1.tgz", + "integrity": "sha512-UyW1WZvHDuM4xDz0jWun4qtQFauNdXjXOtIy7SYdf7pbxSWWVlqhnR/T2TpX6LX5NI62spt0a3ldIIEkPM6RHw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.20.1.tgz", + "integrity": "sha512-itPwCw5C+Jh/c624vcDd9kRCCZVpzpQn8dtwoYIt2TJF3S9xJLiRohnnNrKwREvcZYx0n8sCSbvGH349XkcQeg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.20.1.tgz", + "integrity": "sha512-LojC28v3+IhIbfQ+Vu4Ut5n3wKcgTu6POKIHN9Wpt0HnfgUGlBuyDDQR4jWZUZFyYLiz4RBBBmfU6sNfn6RhLw==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.20.1.tgz", + "integrity": "sha512-cX8WdlF6Cnvw/DO9/X7XLH2J6CkBnz7Twjpk56cshk9sjYVcuh4sXQBy5bmTwzBjNVZze2yaV1vtcJS04LbN8w==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.20.1.tgz", + "integrity": "sha512-4H/sQCy1mnnGkUt/xszaLlYJVTz3W9ep52xEefGtd6yXDQbz/5fZE5dFLUgsPdbUOQANcVUa5iO6g3nyy5BJiw==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.20.1.tgz", + "integrity": "sha512-c0jgtB+sRHCciVXlyjDcWb2FUuzlGVRwGXgI+3WqKOIuoo8AmZAddzeOHeYLtD+dmtHw3B4Xo9wAUdjlfW5yYA==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.20.1.tgz", + "integrity": "sha512-TgFyCfIxSujyuqdZKDZ3yTwWiGv+KnlOeXXitCQ+trDODJ+ZtGOzLkSWngynP0HZnTsDyBbPy7GWVXWaEl6lhA==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.20.1.tgz", + "integrity": "sha512-b+yuD1IUeL+Y93PmFZDZFIElwbmFfIKLKlYI8M6tRyzE6u7oEP7onGk0vZRh8wfVGC2dZoy0EqX1V8qok4qHaw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.20.1.tgz", + "integrity": "sha512-wpDlpE0oRKZwX+GfomcALcouqjjV8MIX8DyTrxfyCfXxoKQSDm45CZr9fanJ4F6ckD4yDEPT98SrjvLwIqUCgg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.20.1.tgz", + "integrity": "sha512-5BepC2Au80EohQ2dBpyTquqGCES7++p7G+7lXe1bAIvMdXm4YYcEfZtQrP4gaoZ96Wv1Ute61CEHFU7h4FMueQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.20.1.tgz", + "integrity": "sha512-5gRPk7pKuaIB+tmH+yKd2aQTRpqlf1E4f/mC+tawIm/CGJemZcHZpp2ic8oD83nKgUPMEd0fNanrnFljiruuyA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.20.1.tgz", + "integrity": "sha512-4fL68JdrLV2nVW2AaWZBv3XEm3Ae3NZn/7qy2KGAt3dexAgSVT+Hc97JKSZnqezgMlv9x6KV0ZkZY7UO5cNLCg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.20.1.tgz", + "integrity": "sha512-GhRuXlvRE+twf2ES+8REbeCb/zeikNqwD3+6S5y5/x+DYbAQUNl0HNBs4RQJqrechS4v4MruEr8ZtAin/hK5iw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.20.1.tgz", + "integrity": "sha512-ZnWEyCM0G1Ex6JtsygvC3KUUrlDXqOihw8RicRuQAzw+c4f1D66YlPNNV3rkjVW90zXVsHwZYWbJh3v+oQFM9Q==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.20.1.tgz", + "integrity": "sha512-QZ6gXue0vVQY2Oon9WyLFCdSuYbXSoxaZrPuJ4c20j6ICedfsDilNPYfHLlMH7vGfU5DQR0czHLmJvH4Nzis/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.20.1.tgz", + "integrity": "sha512-HzcJa1NcSWTAU0MJIxOho8JftNp9YALui3o+Ny7hCh0v5f90nprly1U3Sj1Ldj/CvKKdvvFsCRvDkpsEMp4DNw==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.20.1.tgz", + "integrity": "sha512-0MBh53o6XtI6ctDnRMeQ+xoCN8kD2qI1rY1KgF/xdWQwoFeKou7puvDfV8/Wv4Ctx2rRpET/gGdz3YlNtNACSA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, "node_modules/@eslint-community/eslint-utils": { "version": "4.4.0", "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", @@ -2184,6 +2553,44 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/esbuild": { + "version": "0.20.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.20.1.tgz", + "integrity": "sha512-OJwEgrpWm/PCMsLVWXKqvcjme3bHNpOgN7Tb6cQnR5n0TPbQx1/Xrn7rqM+wn17bYeT6MGB5sn1Bh5YiGi70nA==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.20.1", + "@esbuild/android-arm": "0.20.1", + "@esbuild/android-arm64": "0.20.1", + "@esbuild/android-x64": "0.20.1", + "@esbuild/darwin-arm64": "0.20.1", + "@esbuild/darwin-x64": "0.20.1", + "@esbuild/freebsd-arm64": "0.20.1", + "@esbuild/freebsd-x64": "0.20.1", + "@esbuild/linux-arm": "0.20.1", + "@esbuild/linux-arm64": "0.20.1", + "@esbuild/linux-ia32": "0.20.1", + "@esbuild/linux-loong64": "0.20.1", + "@esbuild/linux-mips64el": "0.20.1", + "@esbuild/linux-ppc64": "0.20.1", + "@esbuild/linux-riscv64": "0.20.1", + "@esbuild/linux-s390x": "0.20.1", + "@esbuild/linux-x64": "0.20.1", + "@esbuild/netbsd-x64": "0.20.1", + "@esbuild/openbsd-x64": "0.20.1", + "@esbuild/sunos-x64": "0.20.1", + "@esbuild/win32-arm64": "0.20.1", + "@esbuild/win32-ia32": "0.20.1", + "@esbuild/win32-x64": "0.20.1" + } + }, "node_modules/escalade": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz", diff --git a/package.json b/package.json index 97905dd..1ed2e26 100644 --- a/package.json +++ b/package.json @@ -1,18 +1,21 @@ { "name": "string-literal-list", - "version": "1.13.0", + "version": "1.14.0", "description": "an array for string literal", "main": "stringList.js", "types": "stringList.d.ts", "exports": { ".": { - "import": "./stringList.js" + "import": "./stringList.js", + "require": "./stringList.cjs" }, "./strict.js": { - "import": "./strict.js" + "import": "./strict.js", + "require": "./strict.cjs" }, "./types.js": { - "import": "./types/index.js" + "import": "./types/index.js", + "require": "./types/index.js" } }, "engines": { @@ -27,6 +30,9 @@ "prettier": "prettier --write \"**/*.{js,ts}\"", "lint": "eslint --fix \"./*.js\"", "lint:ci": "eslint . --ext .js", + "build": "npm run build:main && npm run build:strict", + "build:strict": "esbuild ./strict.js --bundle --format=cjs --keep-names --outfile=strict.cjs", + "build:main": "esbuild ./stringList.js --bundle --format=cjs --keep-names --outfile=stringList.cjs", "prepare": "husky" }, "author": "Vincent Baronnet", @@ -36,6 +42,7 @@ "url": "https://github.com/rawpixel-vincent/string-literal-list.git" }, "devDependencies": { + "esbuild": "^0.20.1", "eslint": "latest", "eslint-config-prettier": "latest", "eslint-config-standard": "latest", diff --git a/strict.cjs b/strict.cjs new file mode 100644 index 0000000..3788f6e --- /dev/null +++ b/strict.cjs @@ -0,0 +1,2395 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/core-js/internals/global.js +var require_global = __commonJS({ + "node_modules/core-js/internals/global.js"(exports, module2) { + "use strict"; + var check = /* @__PURE__ */ __name(function(it) { + return it && it.Math === Math && it; + }, "check"); + module2.exports = // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == "object" && self) || check(typeof global == "object" && global) || check(typeof exports == "object" && exports) || // eslint-disable-next-line no-new-func -- fallback + /* @__PURE__ */ function() { + return this; + }() || Function("return this")(); + } +}); + +// node_modules/core-js/internals/fails.js +var require_fails = __commonJS({ + "node_modules/core-js/internals/fails.js"(exports, module2) { + "use strict"; + module2.exports = function(exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + } +}); + +// node_modules/core-js/internals/descriptors.js +var require_descriptors = __commonJS({ + "node_modules/core-js/internals/descriptors.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + module2.exports = !fails(function() { + return Object.defineProperty({}, 1, { get: function() { + return 7; + } })[1] !== 7; + }); + } +}); + +// node_modules/core-js/internals/function-bind-native.js +var require_function_bind_native = __commonJS({ + "node_modules/core-js/internals/function-bind-native.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + module2.exports = !fails(function() { + var test = function() { + }.bind(); + return typeof test != "function" || test.hasOwnProperty("prototype"); + }); + } +}); + +// node_modules/core-js/internals/function-call.js +var require_function_call = __commonJS({ + "node_modules/core-js/internals/function-call.js"(exports, module2) { + "use strict"; + var NATIVE_BIND = require_function_bind_native(); + var call = Function.prototype.call; + module2.exports = NATIVE_BIND ? call.bind(call) : function() { + return call.apply(call, arguments); + }; + } +}); + +// node_modules/core-js/internals/object-property-is-enumerable.js +var require_object_property_is_enumerable = __commonJS({ + "node_modules/core-js/internals/object-property-is-enumerable.js"(exports) { + "use strict"; + var $propertyIsEnumerable = {}.propertyIsEnumerable; + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); + exports.f = NASHORN_BUG ? /* @__PURE__ */ __name(function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; + }, "propertyIsEnumerable") : $propertyIsEnumerable; + } +}); + +// node_modules/core-js/internals/create-property-descriptor.js +var require_create_property_descriptor = __commonJS({ + "node_modules/core-js/internals/create-property-descriptor.js"(exports, module2) { + "use strict"; + module2.exports = function(bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value + }; + }; + } +}); + +// node_modules/core-js/internals/function-uncurry-this.js +var require_function_uncurry_this = __commonJS({ + "node_modules/core-js/internals/function-uncurry-this.js"(exports, module2) { + "use strict"; + var NATIVE_BIND = require_function_bind_native(); + var FunctionPrototype = Function.prototype; + var call = FunctionPrototype.call; + var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call); + module2.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) { + return function() { + return call.apply(fn, arguments); + }; + }; + } +}); + +// node_modules/core-js/internals/classof-raw.js +var require_classof_raw = __commonJS({ + "node_modules/core-js/internals/classof-raw.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var toString = uncurryThis({}.toString); + var stringSlice = uncurryThis("".slice); + module2.exports = function(it) { + return stringSlice(toString(it), 8, -1); + }; + } +}); + +// node_modules/core-js/internals/indexed-object.js +var require_indexed_object = __commonJS({ + "node_modules/core-js/internals/indexed-object.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var fails = require_fails(); + var classof = require_classof_raw(); + var $Object = Object; + var split = uncurryThis("".split); + module2.exports = fails(function() { + return !$Object("z").propertyIsEnumerable(0); + }) ? function(it) { + return classof(it) === "String" ? split(it, "") : $Object(it); + } : $Object; + } +}); + +// node_modules/core-js/internals/is-null-or-undefined.js +var require_is_null_or_undefined = __commonJS({ + "node_modules/core-js/internals/is-null-or-undefined.js"(exports, module2) { + "use strict"; + module2.exports = function(it) { + return it === null || it === void 0; + }; + } +}); + +// node_modules/core-js/internals/require-object-coercible.js +var require_require_object_coercible = __commonJS({ + "node_modules/core-js/internals/require-object-coercible.js"(exports, module2) { + "use strict"; + var isNullOrUndefined = require_is_null_or_undefined(); + var $TypeError = TypeError; + module2.exports = function(it) { + if (isNullOrUndefined(it)) + throw new $TypeError("Can't call method on " + it); + return it; + }; + } +}); + +// node_modules/core-js/internals/to-indexed-object.js +var require_to_indexed_object = __commonJS({ + "node_modules/core-js/internals/to-indexed-object.js"(exports, module2) { + "use strict"; + var IndexedObject = require_indexed_object(); + var requireObjectCoercible = require_require_object_coercible(); + module2.exports = function(it) { + return IndexedObject(requireObjectCoercible(it)); + }; + } +}); + +// node_modules/core-js/internals/is-callable.js +var require_is_callable = __commonJS({ + "node_modules/core-js/internals/is-callable.js"(exports, module2) { + "use strict"; + var documentAll = typeof document == "object" && document.all; + module2.exports = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) { + return typeof argument == "function" || argument === documentAll; + } : function(argument) { + return typeof argument == "function"; + }; + } +}); + +// node_modules/core-js/internals/is-object.js +var require_is_object = __commonJS({ + "node_modules/core-js/internals/is-object.js"(exports, module2) { + "use strict"; + var isCallable = require_is_callable(); + module2.exports = function(it) { + return typeof it == "object" ? it !== null : isCallable(it); + }; + } +}); + +// node_modules/core-js/internals/get-built-in.js +var require_get_built_in = __commonJS({ + "node_modules/core-js/internals/get-built-in.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var isCallable = require_is_callable(); + var aFunction = /* @__PURE__ */ __name(function(argument) { + return isCallable(argument) ? argument : void 0; + }, "aFunction"); + module2.exports = function(namespace, method) { + return arguments.length < 2 ? aFunction(global2[namespace]) : global2[namespace] && global2[namespace][method]; + }; + } +}); + +// node_modules/core-js/internals/object-is-prototype-of.js +var require_object_is_prototype_of = __commonJS({ + "node_modules/core-js/internals/object-is-prototype-of.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + module2.exports = uncurryThis({}.isPrototypeOf); + } +}); + +// node_modules/core-js/internals/engine-user-agent.js +var require_engine_user_agent = __commonJS({ + "node_modules/core-js/internals/engine-user-agent.js"(exports, module2) { + "use strict"; + module2.exports = typeof navigator != "undefined" && String(navigator.userAgent) || ""; + } +}); + +// node_modules/core-js/internals/engine-v8-version.js +var require_engine_v8_version = __commonJS({ + "node_modules/core-js/internals/engine-v8-version.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var userAgent = require_engine_user_agent(); + var process2 = global2.process; + var Deno = global2.Deno; + var versions = process2 && process2.versions || Deno && Deno.version; + var v8 = versions && versions.v8; + var match; + var version; + if (v8) { + match = v8.split("."); + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + if (!version && userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) + version = +match[1]; + } + } + module2.exports = version; + } +}); + +// node_modules/core-js/internals/symbol-constructor-detection.js +var require_symbol_constructor_detection = __commonJS({ + "node_modules/core-js/internals/symbol-constructor-detection.js"(exports, module2) { + "use strict"; + var V8_VERSION = require_engine_v8_version(); + var fails = require_fails(); + var global2 = require_global(); + var $String = global2.String; + module2.exports = !!Object.getOwnPropertySymbols && !fails(function() { + var symbol = Symbol("symbol detection"); + return !$String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION && V8_VERSION < 41; + }); + } +}); + +// node_modules/core-js/internals/use-symbol-as-uid.js +var require_use_symbol_as_uid = __commonJS({ + "node_modules/core-js/internals/use-symbol-as-uid.js"(exports, module2) { + "use strict"; + var NATIVE_SYMBOL = require_symbol_constructor_detection(); + module2.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol"; + } +}); + +// node_modules/core-js/internals/is-symbol.js +var require_is_symbol = __commonJS({ + "node_modules/core-js/internals/is-symbol.js"(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + var isCallable = require_is_callable(); + var isPrototypeOf = require_object_is_prototype_of(); + var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); + var $Object = Object; + module2.exports = USE_SYMBOL_AS_UID ? function(it) { + return typeof it == "symbol"; + } : function(it) { + var $Symbol = getBuiltIn("Symbol"); + return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it)); + }; + } +}); + +// node_modules/core-js/internals/try-to-string.js +var require_try_to_string = __commonJS({ + "node_modules/core-js/internals/try-to-string.js"(exports, module2) { + "use strict"; + var $String = String; + module2.exports = function(argument) { + try { + return $String(argument); + } catch (error) { + return "Object"; + } + }; + } +}); + +// node_modules/core-js/internals/a-callable.js +var require_a_callable = __commonJS({ + "node_modules/core-js/internals/a-callable.js"(exports, module2) { + "use strict"; + var isCallable = require_is_callable(); + var tryToString = require_try_to_string(); + var $TypeError = TypeError; + module2.exports = function(argument) { + if (isCallable(argument)) + return argument; + throw new $TypeError(tryToString(argument) + " is not a function"); + }; + } +}); + +// node_modules/core-js/internals/get-method.js +var require_get_method = __commonJS({ + "node_modules/core-js/internals/get-method.js"(exports, module2) { + "use strict"; + var aCallable = require_a_callable(); + var isNullOrUndefined = require_is_null_or_undefined(); + module2.exports = function(V, P) { + var func = V[P]; + return isNullOrUndefined(func) ? void 0 : aCallable(func); + }; + } +}); + +// node_modules/core-js/internals/ordinary-to-primitive.js +var require_ordinary_to_primitive = __commonJS({ + "node_modules/core-js/internals/ordinary-to-primitive.js"(exports, module2) { + "use strict"; + var call = require_function_call(); + var isCallable = require_is_callable(); + var isObject = require_is_object(); + var $TypeError = TypeError; + module2.exports = function(input, pref) { + var fn, val; + if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) + return val; + if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) + return val; + if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) + return val; + throw new $TypeError("Can't convert object to primitive value"); + }; + } +}); + +// node_modules/core-js/internals/is-pure.js +var require_is_pure = __commonJS({ + "node_modules/core-js/internals/is-pure.js"(exports, module2) { + "use strict"; + module2.exports = false; + } +}); + +// node_modules/core-js/internals/define-global-property.js +var require_define_global_property = __commonJS({ + "node_modules/core-js/internals/define-global-property.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var defineProperty = Object.defineProperty; + module2.exports = function(key, value) { + try { + defineProperty(global2, key, { value, configurable: true, writable: true }); + } catch (error) { + global2[key] = value; + } + return value; + }; + } +}); + +// node_modules/core-js/internals/shared-store.js +var require_shared_store = __commonJS({ + "node_modules/core-js/internals/shared-store.js"(exports, module2) { + "use strict"; + var IS_PURE = require_is_pure(); + var globalThis2 = require_global(); + var defineGlobalProperty = require_define_global_property(); + var SHARED = "__core-js_shared__"; + var store = module2.exports = globalThis2[SHARED] || defineGlobalProperty(SHARED, {}); + (store.versions || (store.versions = [])).push({ + version: "3.36.0", + mode: IS_PURE ? "pure" : "global", + copyright: "\xA9 2014-2024 Denis Pushkarev (zloirock.ru)", + license: "https://github.com/zloirock/core-js/blob/v3.36.0/LICENSE", + source: "https://github.com/zloirock/core-js" + }); + } +}); + +// node_modules/core-js/internals/shared.js +var require_shared = __commonJS({ + "node_modules/core-js/internals/shared.js"(exports, module2) { + "use strict"; + var store = require_shared_store(); + module2.exports = function(key, value) { + return store[key] || (store[key] = value || {}); + }; + } +}); + +// node_modules/core-js/internals/to-object.js +var require_to_object = __commonJS({ + "node_modules/core-js/internals/to-object.js"(exports, module2) { + "use strict"; + var requireObjectCoercible = require_require_object_coercible(); + var $Object = Object; + module2.exports = function(argument) { + return $Object(requireObjectCoercible(argument)); + }; + } +}); + +// node_modules/core-js/internals/has-own-property.js +var require_has_own_property = __commonJS({ + "node_modules/core-js/internals/has-own-property.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var toObject = require_to_object(); + var hasOwnProperty = uncurryThis({}.hasOwnProperty); + module2.exports = Object.hasOwn || /* @__PURE__ */ __name(function hasOwn(it, key) { + return hasOwnProperty(toObject(it), key); + }, "hasOwn"); + } +}); + +// node_modules/core-js/internals/uid.js +var require_uid = __commonJS({ + "node_modules/core-js/internals/uid.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var id = 0; + var postfix = Math.random(); + var toString = uncurryThis(1 .toString); + module2.exports = function(key) { + return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString(++id + postfix, 36); + }; + } +}); + +// node_modules/core-js/internals/well-known-symbol.js +var require_well_known_symbol = __commonJS({ + "node_modules/core-js/internals/well-known-symbol.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var shared = require_shared(); + var hasOwn = require_has_own_property(); + var uid = require_uid(); + var NATIVE_SYMBOL = require_symbol_constructor_detection(); + var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); + var Symbol2 = global2.Symbol; + var WellKnownSymbolsStore = shared("wks"); + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid; + module2.exports = function(name) { + if (!hasOwn(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name); + } + return WellKnownSymbolsStore[name]; + }; + } +}); + +// node_modules/core-js/internals/to-primitive.js +var require_to_primitive = __commonJS({ + "node_modules/core-js/internals/to-primitive.js"(exports, module2) { + "use strict"; + var call = require_function_call(); + var isObject = require_is_object(); + var isSymbol = require_is_symbol(); + var getMethod = require_get_method(); + var ordinaryToPrimitive = require_ordinary_to_primitive(); + var wellKnownSymbol = require_well_known_symbol(); + var $TypeError = TypeError; + var TO_PRIMITIVE = wellKnownSymbol("toPrimitive"); + module2.exports = function(input, pref) { + if (!isObject(input) || isSymbol(input)) + return input; + var exoticToPrim = getMethod(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === void 0) + pref = "default"; + result = call(exoticToPrim, input, pref); + if (!isObject(result) || isSymbol(result)) + return result; + throw new $TypeError("Can't convert object to primitive value"); + } + if (pref === void 0) + pref = "number"; + return ordinaryToPrimitive(input, pref); + }; + } +}); + +// node_modules/core-js/internals/to-property-key.js +var require_to_property_key = __commonJS({ + "node_modules/core-js/internals/to-property-key.js"(exports, module2) { + "use strict"; + var toPrimitive = require_to_primitive(); + var isSymbol = require_is_symbol(); + module2.exports = function(argument) { + var key = toPrimitive(argument, "string"); + return isSymbol(key) ? key : key + ""; + }; + } +}); + +// node_modules/core-js/internals/document-create-element.js +var require_document_create_element = __commonJS({ + "node_modules/core-js/internals/document-create-element.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var isObject = require_is_object(); + var document2 = global2.document; + var EXISTS = isObject(document2) && isObject(document2.createElement); + module2.exports = function(it) { + return EXISTS ? document2.createElement(it) : {}; + }; + } +}); + +// node_modules/core-js/internals/ie8-dom-define.js +var require_ie8_dom_define = __commonJS({ + "node_modules/core-js/internals/ie8-dom-define.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var fails = require_fails(); + var createElement = require_document_create_element(); + module2.exports = !DESCRIPTORS && !fails(function() { + return Object.defineProperty(createElement("div"), "a", { + get: function() { + return 7; + } + }).a !== 7; + }); + } +}); + +// node_modules/core-js/internals/object-get-own-property-descriptor.js +var require_object_get_own_property_descriptor = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-descriptor.js"(exports) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var call = require_function_call(); + var propertyIsEnumerableModule = require_object_property_is_enumerable(); + var createPropertyDescriptor = require_create_property_descriptor(); + var toIndexedObject = require_to_indexed_object(); + var toPropertyKey = require_to_property_key(); + var hasOwn = require_has_own_property(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : /* @__PURE__ */ __name(function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) + try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { + } + if (hasOwn(O, P)) + return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); + }, "getOwnPropertyDescriptor"); + } +}); + +// node_modules/core-js/internals/v8-prototype-define-bug.js +var require_v8_prototype_define_bug = __commonJS({ + "node_modules/core-js/internals/v8-prototype-define-bug.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var fails = require_fails(); + module2.exports = DESCRIPTORS && fails(function() { + return Object.defineProperty(function() { + }, "prototype", { + value: 42, + writable: false + }).prototype !== 42; + }); + } +}); + +// node_modules/core-js/internals/an-object.js +var require_an_object = __commonJS({ + "node_modules/core-js/internals/an-object.js"(exports, module2) { + "use strict"; + var isObject = require_is_object(); + var $String = String; + var $TypeError = TypeError; + module2.exports = function(argument) { + if (isObject(argument)) + return argument; + throw new $TypeError($String(argument) + " is not an object"); + }; + } +}); + +// node_modules/core-js/internals/object-define-property.js +var require_object_define_property = __commonJS({ + "node_modules/core-js/internals/object-define-property.js"(exports) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug(); + var anObject = require_an_object(); + var toPropertyKey = require_to_property_key(); + var $TypeError = TypeError; + var $defineProperty = Object.defineProperty; + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var ENUMERABLE = "enumerable"; + var CONFIGURABLE = "configurable"; + var WRITABLE = "writable"; + exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? /* @__PURE__ */ __name(function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } + return $defineProperty(O, P, Attributes); + }, "defineProperty") : $defineProperty : /* @__PURE__ */ __name(function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (IE8_DOM_DEFINE) + try { + return $defineProperty(O, P, Attributes); + } catch (error) { + } + if ("get" in Attributes || "set" in Attributes) + throw new $TypeError("Accessors not supported"); + if ("value" in Attributes) + O[P] = Attributes.value; + return O; + }, "defineProperty"); + } +}); + +// node_modules/core-js/internals/create-non-enumerable-property.js +var require_create_non_enumerable_property = __commonJS({ + "node_modules/core-js/internals/create-non-enumerable-property.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var definePropertyModule = require_object_define_property(); + var createPropertyDescriptor = require_create_property_descriptor(); + module2.exports = DESCRIPTORS ? function(object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); + } : function(object, key, value) { + object[key] = value; + return object; + }; + } +}); + +// node_modules/core-js/internals/function-name.js +var require_function_name = __commonJS({ + "node_modules/core-js/internals/function-name.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var hasOwn = require_has_own_property(); + var FunctionPrototype = Function.prototype; + var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor; + var EXISTS = hasOwn(FunctionPrototype, "name"); + var PROPER = EXISTS && (/* @__PURE__ */ __name(function something() { + }, "something")).name === "something"; + var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, "name").configurable); + module2.exports = { + EXISTS, + PROPER, + CONFIGURABLE + }; + } +}); + +// node_modules/core-js/internals/inspect-source.js +var require_inspect_source = __commonJS({ + "node_modules/core-js/internals/inspect-source.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var isCallable = require_is_callable(); + var store = require_shared_store(); + var functionToString = uncurryThis(Function.toString); + if (!isCallable(store.inspectSource)) { + store.inspectSource = function(it) { + return functionToString(it); + }; + } + module2.exports = store.inspectSource; + } +}); + +// node_modules/core-js/internals/weak-map-basic-detection.js +var require_weak_map_basic_detection = __commonJS({ + "node_modules/core-js/internals/weak-map-basic-detection.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var isCallable = require_is_callable(); + var WeakMap = global2.WeakMap; + module2.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap)); + } +}); + +// node_modules/core-js/internals/shared-key.js +var require_shared_key = __commonJS({ + "node_modules/core-js/internals/shared-key.js"(exports, module2) { + "use strict"; + var shared = require_shared(); + var uid = require_uid(); + var keys = shared("keys"); + module2.exports = function(key) { + return keys[key] || (keys[key] = uid(key)); + }; + } +}); + +// node_modules/core-js/internals/hidden-keys.js +var require_hidden_keys = __commonJS({ + "node_modules/core-js/internals/hidden-keys.js"(exports, module2) { + "use strict"; + module2.exports = {}; + } +}); + +// node_modules/core-js/internals/internal-state.js +var require_internal_state = __commonJS({ + "node_modules/core-js/internals/internal-state.js"(exports, module2) { + "use strict"; + var NATIVE_WEAK_MAP = require_weak_map_basic_detection(); + var global2 = require_global(); + var isObject = require_is_object(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var hasOwn = require_has_own_property(); + var shared = require_shared_store(); + var sharedKey = require_shared_key(); + var hiddenKeys = require_hidden_keys(); + var OBJECT_ALREADY_INITIALIZED = "Object already initialized"; + var TypeError2 = global2.TypeError; + var WeakMap = global2.WeakMap; + var set; + var get; + var has; + var enforce = /* @__PURE__ */ __name(function(it) { + return has(it) ? get(it) : set(it, {}); + }, "enforce"); + var getterFor = /* @__PURE__ */ __name(function(TYPE) { + return function(it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw new TypeError2("Incompatible receiver, " + TYPE + " required"); + } + return state; + }; + }, "getterFor"); + if (NATIVE_WEAK_MAP || shared.state) { + store = shared.state || (shared.state = new WeakMap()); + store.get = store.get; + store.has = store.has; + store.set = store.set; + set = /* @__PURE__ */ __name(function(it, metadata) { + if (store.has(it)) + throw new TypeError2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }, "set"); + get = /* @__PURE__ */ __name(function(it) { + return store.get(it) || {}; + }, "get"); + has = /* @__PURE__ */ __name(function(it) { + return store.has(it); + }, "has"); + } else { + STATE = sharedKey("state"); + hiddenKeys[STATE] = true; + set = /* @__PURE__ */ __name(function(it, metadata) { + if (hasOwn(it, STATE)) + throw new TypeError2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }, "set"); + get = /* @__PURE__ */ __name(function(it) { + return hasOwn(it, STATE) ? it[STATE] : {}; + }, "get"); + has = /* @__PURE__ */ __name(function(it) { + return hasOwn(it, STATE); + }, "has"); + } + var store; + var STATE; + module2.exports = { + set, + get, + has, + enforce, + getterFor + }; + } +}); + +// node_modules/core-js/internals/make-built-in.js +var require_make_built_in = __commonJS({ + "node_modules/core-js/internals/make-built-in.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var fails = require_fails(); + var isCallable = require_is_callable(); + var hasOwn = require_has_own_property(); + var DESCRIPTORS = require_descriptors(); + var CONFIGURABLE_FUNCTION_NAME = require_function_name().CONFIGURABLE; + var inspectSource = require_inspect_source(); + var InternalStateModule = require_internal_state(); + var enforceInternalState = InternalStateModule.enforce; + var getInternalState = InternalStateModule.get; + var $String = String; + var defineProperty = Object.defineProperty; + var stringSlice = uncurryThis("".slice); + var replace = uncurryThis("".replace); + var join = uncurryThis([].join); + var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() { + return defineProperty(function() { + }, "length", { value: 8 }).length !== 8; + }); + var TEMPLATE = String(String).split("String"); + var makeBuiltIn = module2.exports = function(value, name, options) { + if (stringSlice($String(name), 0, 7) === "Symbol(") { + name = "[" + replace($String(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]"; + } + if (options && options.getter) + name = "get " + name; + if (options && options.setter) + name = "set " + name; + if (!hasOwn(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) { + if (DESCRIPTORS) + defineProperty(value, "name", { value: name, configurable: true }); + else + value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn(options, "arity") && value.length !== options.arity) { + defineProperty(value, "length", { value: options.arity }); + } + try { + if (options && hasOwn(options, "constructor") && options.constructor) { + if (DESCRIPTORS) + defineProperty(value, "prototype", { writable: false }); + } else if (value.prototype) + value.prototype = void 0; + } catch (error) { + } + var state = enforceInternalState(value); + if (!hasOwn(state, "source")) { + state.source = join(TEMPLATE, typeof name == "string" ? name : ""); + } + return value; + }; + Function.prototype.toString = makeBuiltIn(/* @__PURE__ */ __name(function toString() { + return isCallable(this) && getInternalState(this).source || inspectSource(this); + }, "toString"), "toString"); + } +}); + +// node_modules/core-js/internals/define-built-in.js +var require_define_built_in = __commonJS({ + "node_modules/core-js/internals/define-built-in.js"(exports, module2) { + "use strict"; + var isCallable = require_is_callable(); + var definePropertyModule = require_object_define_property(); + var makeBuiltIn = require_make_built_in(); + var defineGlobalProperty = require_define_global_property(); + module2.exports = function(O, key, value, options) { + if (!options) + options = {}; + var simple = options.enumerable; + var name = options.name !== void 0 ? options.name : key; + if (isCallable(value)) + makeBuiltIn(value, name, options); + if (options.global) { + if (simple) + O[key] = value; + else + defineGlobalProperty(key, value); + } else { + try { + if (!options.unsafe) + delete O[key]; + else if (O[key]) + simple = true; + } catch (error) { + } + if (simple) + O[key] = value; + else + definePropertyModule.f(O, key, { + value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } + return O; + }; + } +}); + +// node_modules/core-js/internals/math-trunc.js +var require_math_trunc = __commonJS({ + "node_modules/core-js/internals/math-trunc.js"(exports, module2) { + "use strict"; + var ceil = Math.ceil; + var floor = Math.floor; + module2.exports = Math.trunc || /* @__PURE__ */ __name(function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); + }, "trunc"); + } +}); + +// node_modules/core-js/internals/to-integer-or-infinity.js +var require_to_integer_or_infinity = __commonJS({ + "node_modules/core-js/internals/to-integer-or-infinity.js"(exports, module2) { + "use strict"; + var trunc = require_math_trunc(); + module2.exports = function(argument) { + var number = +argument; + return number !== number || number === 0 ? 0 : trunc(number); + }; + } +}); + +// node_modules/core-js/internals/to-absolute-index.js +var require_to_absolute_index = __commonJS({ + "node_modules/core-js/internals/to-absolute-index.js"(exports, module2) { + "use strict"; + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var max = Math.max; + var min = Math.min; + module2.exports = function(index, length) { + var integer = toIntegerOrInfinity(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); + }; + } +}); + +// node_modules/core-js/internals/to-length.js +var require_to_length = __commonJS({ + "node_modules/core-js/internals/to-length.js"(exports, module2) { + "use strict"; + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var min = Math.min; + module2.exports = function(argument) { + var len = toIntegerOrInfinity(argument); + return len > 0 ? min(len, 9007199254740991) : 0; + }; + } +}); + +// node_modules/core-js/internals/length-of-array-like.js +var require_length_of_array_like = __commonJS({ + "node_modules/core-js/internals/length-of-array-like.js"(exports, module2) { + "use strict"; + var toLength = require_to_length(); + module2.exports = function(obj) { + return toLength(obj.length); + }; + } +}); + +// node_modules/core-js/internals/array-includes.js +var require_array_includes = __commonJS({ + "node_modules/core-js/internals/array-includes.js"(exports, module2) { + "use strict"; + var toIndexedObject = require_to_indexed_object(); + var toAbsoluteIndex = require_to_absolute_index(); + var lengthOfArrayLike = require_length_of_array_like(); + var createMethod = /* @__PURE__ */ __name(function(IS_INCLUDES) { + return function($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = lengthOfArrayLike(O); + if (length === 0) + return !IS_INCLUDES && -1; + var index = toAbsoluteIndex(fromIndex, length); + var value; + if (IS_INCLUDES && el !== el) + while (length > index) { + value = O[index++]; + if (value !== value) + return true; + } + else + for (; length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) + return IS_INCLUDES || index || 0; + } + return !IS_INCLUDES && -1; + }; + }, "createMethod"); + module2.exports = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) + }; + } +}); + +// node_modules/core-js/internals/object-keys-internal.js +var require_object_keys_internal = __commonJS({ + "node_modules/core-js/internals/object-keys-internal.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var hasOwn = require_has_own_property(); + var toIndexedObject = require_to_indexed_object(); + var indexOf = require_array_includes().indexOf; + var hiddenKeys = require_hidden_keys(); + var push = uncurryThis([].push); + module2.exports = function(object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) + !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key); + while (names.length > i) + if (hasOwn(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; + }; + } +}); + +// node_modules/core-js/internals/enum-bug-keys.js +var require_enum_bug_keys = __commonJS({ + "node_modules/core-js/internals/enum-bug-keys.js"(exports, module2) { + "use strict"; + module2.exports = [ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf" + ]; + } +}); + +// node_modules/core-js/internals/object-get-own-property-names.js +var require_object_get_own_property_names = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-names.js"(exports) { + "use strict"; + var internalObjectKeys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + var hiddenKeys = enumBugKeys.concat("length", "prototype"); + exports.f = Object.getOwnPropertyNames || /* @__PURE__ */ __name(function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); + }, "getOwnPropertyNames"); + } +}); + +// node_modules/core-js/internals/object-get-own-property-symbols.js +var require_object_get_own_property_symbols = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-symbols.js"(exports) { + "use strict"; + exports.f = Object.getOwnPropertySymbols; + } +}); + +// node_modules/core-js/internals/own-keys.js +var require_own_keys = __commonJS({ + "node_modules/core-js/internals/own-keys.js"(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + var uncurryThis = require_function_uncurry_this(); + var getOwnPropertyNamesModule = require_object_get_own_property_names(); + var getOwnPropertySymbolsModule = require_object_get_own_property_symbols(); + var anObject = require_an_object(); + var concat = uncurryThis([].concat); + module2.exports = getBuiltIn("Reflect", "ownKeys") || /* @__PURE__ */ __name(function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys; + }, "ownKeys"); + } +}); + +// node_modules/core-js/internals/copy-constructor-properties.js +var require_copy_constructor_properties = __commonJS({ + "node_modules/core-js/internals/copy-constructor-properties.js"(exports, module2) { + "use strict"; + var hasOwn = require_has_own_property(); + var ownKeys = require_own_keys(); + var getOwnPropertyDescriptorModule = require_object_get_own_property_descriptor(); + var definePropertyModule = require_object_define_property(); + module2.exports = function(target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + } +}); + +// node_modules/core-js/internals/is-forced.js +var require_is_forced = __commonJS({ + "node_modules/core-js/internals/is-forced.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + var isCallable = require_is_callable(); + var replacement = /#|\.prototype\./; + var isForced = /* @__PURE__ */ __name(function(feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection; + }, "isForced"); + var normalize = isForced.normalize = function(string) { + return String(string).replace(replacement, ".").toLowerCase(); + }; + var data = isForced.data = {}; + var NATIVE = isForced.NATIVE = "N"; + var POLYFILL = isForced.POLYFILL = "P"; + module2.exports = isForced; + } +}); + +// node_modules/core-js/internals/export.js +var require_export = __commonJS({ + "node_modules/core-js/internals/export.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f; + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var defineBuiltIn = require_define_built_in(); + var defineGlobalProperty = require_define_global_property(); + var copyConstructorProperties = require_copy_constructor_properties(); + var isForced = require_is_forced(); + module2.exports = function(options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global2; + } else if (STATIC) { + target = global2[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = global2[TARGET] && global2[TARGET].prototype; + } + if (target) + for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else + targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced); + if (!FORCED && targetProperty !== void 0) { + if (typeof sourceProperty == typeof targetProperty) + continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + if (options.sham || targetProperty && targetProperty.sham) { + createNonEnumerableProperty(sourceProperty, "sham", true); + } + defineBuiltIn(target, key, sourceProperty, options); + } + }; + } +}); + +// node_modules/core-js/internals/array-to-reversed.js +var require_array_to_reversed = __commonJS({ + "node_modules/core-js/internals/array-to-reversed.js"(exports, module2) { + "use strict"; + var lengthOfArrayLike = require_length_of_array_like(); + module2.exports = function(O, C) { + var len = lengthOfArrayLike(O); + var A = new C(len); + var k = 0; + for (; k < len; k++) + A[k] = O[len - k - 1]; + return A; + }; + } +}); + +// node_modules/core-js/internals/object-keys.js +var require_object_keys = __commonJS({ + "node_modules/core-js/internals/object-keys.js"(exports, module2) { + "use strict"; + var internalObjectKeys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + module2.exports = Object.keys || /* @__PURE__ */ __name(function keys(O) { + return internalObjectKeys(O, enumBugKeys); + }, "keys"); + } +}); + +// node_modules/core-js/internals/object-define-properties.js +var require_object_define_properties = __commonJS({ + "node_modules/core-js/internals/object-define-properties.js"(exports) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug(); + var definePropertyModule = require_object_define_property(); + var anObject = require_an_object(); + var toIndexedObject = require_to_indexed_object(); + var objectKeys = require_object_keys(); + exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : /* @__PURE__ */ __name(function defineProperties(O, Properties) { + anObject(O); + var props = toIndexedObject(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) + definePropertyModule.f(O, key = keys[index++], props[key]); + return O; + }, "defineProperties"); + } +}); + +// node_modules/core-js/internals/html.js +var require_html = __commonJS({ + "node_modules/core-js/internals/html.js"(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + module2.exports = getBuiltIn("document", "documentElement"); + } +}); + +// node_modules/core-js/internals/object-create.js +var require_object_create = __commonJS({ + "node_modules/core-js/internals/object-create.js"(exports, module2) { + "use strict"; + var anObject = require_an_object(); + var definePropertiesModule = require_object_define_properties(); + var enumBugKeys = require_enum_bug_keys(); + var hiddenKeys = require_hidden_keys(); + var html = require_html(); + var documentCreateElement = require_document_create_element(); + var sharedKey = require_shared_key(); + var GT = ">"; + var LT = "<"; + var PROTOTYPE = "prototype"; + var SCRIPT = "script"; + var IE_PROTO = sharedKey("IE_PROTO"); + var EmptyConstructor = /* @__PURE__ */ __name(function() { + }, "EmptyConstructor"); + var scriptTag = /* @__PURE__ */ __name(function(content) { + return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT; + }, "scriptTag"); + var NullProtoObjectViaActiveX = /* @__PURE__ */ __name(function(activeXDocument2) { + activeXDocument2.write(scriptTag("")); + activeXDocument2.close(); + var temp = activeXDocument2.parentWindow.Object; + activeXDocument2 = null; + return temp; + }, "NullProtoObjectViaActiveX"); + var NullProtoObjectViaIFrame = /* @__PURE__ */ __name(function() { + var iframe = documentCreateElement("iframe"); + var JS = "java" + SCRIPT + ":"; + var iframeDocument; + iframe.style.display = "none"; + html.appendChild(iframe); + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag("document.F=Object")); + iframeDocument.close(); + return iframeDocument.F; + }, "NullProtoObjectViaIFrame"); + var activeXDocument; + var NullProtoObject = /* @__PURE__ */ __name(function() { + try { + activeXDocument = new ActiveXObject("htmlfile"); + } catch (error) { + } + NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument); + var length = enumBugKeys.length; + while (length--) + delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }, "NullProtoObject"); + hiddenKeys[IE_PROTO] = true; + module2.exports = Object.create || /* @__PURE__ */ __name(function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + result[IE_PROTO] = O; + } else + result = NullProtoObject(); + return Properties === void 0 ? result : definePropertiesModule.f(result, Properties); + }, "create"); + } +}); + +// node_modules/core-js/internals/add-to-unscopables.js +var require_add_to_unscopables = __commonJS({ + "node_modules/core-js/internals/add-to-unscopables.js"(exports, module2) { + "use strict"; + var wellKnownSymbol = require_well_known_symbol(); + var create = require_object_create(); + var defineProperty = require_object_define_property().f; + var UNSCOPABLES = wellKnownSymbol("unscopables"); + var ArrayPrototype = Array.prototype; + if (ArrayPrototype[UNSCOPABLES] === void 0) { + defineProperty(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); + } + module2.exports = function(key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + } +}); + +// node_modules/core-js/modules/es.array.to-reversed.js +var require_es_array_to_reversed = __commonJS({ + "node_modules/core-js/modules/es.array.to-reversed.js"() { + "use strict"; + var $ = require_export(); + var arrayToReversed = require_array_to_reversed(); + var toIndexedObject = require_to_indexed_object(); + var addToUnscopables = require_add_to_unscopables(); + var $Array = Array; + $({ target: "Array", proto: true }, { + toReversed: /* @__PURE__ */ __name(function toReversed() { + return arrayToReversed(toIndexedObject(this), $Array); + }, "toReversed") + }); + addToUnscopables("toReversed"); + } +}); + +// node_modules/core-js/internals/entry-unbind.js +var require_entry_unbind = __commonJS({ + "node_modules/core-js/internals/entry-unbind.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var uncurryThis = require_function_uncurry_this(); + module2.exports = function(CONSTRUCTOR, METHOD) { + return uncurryThis(global2[CONSTRUCTOR].prototype[METHOD]); + }; + } +}); + +// node_modules/core-js/es/array/to-reversed.js +var require_to_reversed = __commonJS({ + "node_modules/core-js/es/array/to-reversed.js"(exports, module2) { + "use strict"; + require_es_array_to_reversed(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "toReversed"); + } +}); + +// node_modules/core-js/stable/array/to-reversed.js +var require_to_reversed2 = __commonJS({ + "node_modules/core-js/stable/array/to-reversed.js"(exports, module2) { + "use strict"; + var parent = require_to_reversed(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.to-reversed.js +var require_esnext_array_to_reversed = __commonJS({ + "node_modules/core-js/modules/esnext.array.to-reversed.js"() { + "use strict"; + require_es_array_to_reversed(); + } +}); + +// node_modules/core-js/actual/array/to-reversed.js +var require_to_reversed3 = __commonJS({ + "node_modules/core-js/actual/array/to-reversed.js"(exports, module2) { + "use strict"; + var parent = require_to_reversed2(); + require_esnext_array_to_reversed(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/delete-property-or-throw.js +var require_delete_property_or_throw = __commonJS({ + "node_modules/core-js/internals/delete-property-or-throw.js"(exports, module2) { + "use strict"; + var tryToString = require_try_to_string(); + var $TypeError = TypeError; + module2.exports = function(O, P) { + if (!delete O[P]) + throw new $TypeError("Cannot delete property " + tryToString(P) + " of " + tryToString(O)); + }; + } +}); + +// node_modules/core-js/internals/to-string-tag-support.js +var require_to_string_tag_support = __commonJS({ + "node_modules/core-js/internals/to-string-tag-support.js"(exports, module2) { + "use strict"; + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var test = {}; + test[TO_STRING_TAG] = "z"; + module2.exports = String(test) === "[object z]"; + } +}); + +// node_modules/core-js/internals/classof.js +var require_classof = __commonJS({ + "node_modules/core-js/internals/classof.js"(exports, module2) { + "use strict"; + var TO_STRING_TAG_SUPPORT = require_to_string_tag_support(); + var isCallable = require_is_callable(); + var classofRaw = require_classof_raw(); + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var $Object = Object; + var CORRECT_ARGUMENTS = classofRaw(/* @__PURE__ */ function() { + return arguments; + }()) === "Arguments"; + var tryGet = /* @__PURE__ */ __name(function(it, key) { + try { + return it[key]; + } catch (error) { + } + }, "tryGet"); + module2.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) { + var O, tag, result; + return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) === "Object" && isCallable(O.callee) ? "Arguments" : result; + }; + } +}); + +// node_modules/core-js/internals/to-string.js +var require_to_string = __commonJS({ + "node_modules/core-js/internals/to-string.js"(exports, module2) { + "use strict"; + var classof = require_classof(); + var $String = String; + module2.exports = function(argument) { + if (classof(argument) === "Symbol") + throw new TypeError("Cannot convert a Symbol value to a string"); + return $String(argument); + }; + } +}); + +// node_modules/core-js/internals/array-slice.js +var require_array_slice = __commonJS({ + "node_modules/core-js/internals/array-slice.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + module2.exports = uncurryThis([].slice); + } +}); + +// node_modules/core-js/internals/array-sort.js +var require_array_sort = __commonJS({ + "node_modules/core-js/internals/array-sort.js"(exports, module2) { + "use strict"; + var arraySlice = require_array_slice(); + var floor = Math.floor; + var sort = /* @__PURE__ */ __name(function(array, comparefn) { + var length = array.length; + if (length < 8) { + var i = 1; + var element, j; + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) + array[j] = element; + } + } else { + var middle = floor(length / 2); + var left = sort(arraySlice(array, 0, middle), comparefn); + var right = sort(arraySlice(array, middle), comparefn); + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = lindex < llength && rindex < rlength ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] : lindex < llength ? left[lindex++] : right[rindex++]; + } + } + return array; + }, "sort"); + module2.exports = sort; + } +}); + +// node_modules/core-js/internals/array-method-is-strict.js +var require_array_method_is_strict = __commonJS({ + "node_modules/core-js/internals/array-method-is-strict.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + module2.exports = function(METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails(function() { + method.call(null, argument || function() { + return 1; + }, 1); + }); + }; + } +}); + +// node_modules/core-js/internals/engine-ff-version.js +var require_engine_ff_version = __commonJS({ + "node_modules/core-js/internals/engine-ff-version.js"(exports, module2) { + "use strict"; + var userAgent = require_engine_user_agent(); + var firefox = userAgent.match(/firefox\/(\d+)/i); + module2.exports = !!firefox && +firefox[1]; + } +}); + +// node_modules/core-js/internals/engine-is-ie-or-edge.js +var require_engine_is_ie_or_edge = __commonJS({ + "node_modules/core-js/internals/engine-is-ie-or-edge.js"(exports, module2) { + "use strict"; + var UA = require_engine_user_agent(); + module2.exports = /MSIE|Trident/.test(UA); + } +}); + +// node_modules/core-js/internals/engine-webkit-version.js +var require_engine_webkit_version = __commonJS({ + "node_modules/core-js/internals/engine-webkit-version.js"(exports, module2) { + "use strict"; + var userAgent = require_engine_user_agent(); + var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + module2.exports = !!webkit && +webkit[1]; + } +}); + +// node_modules/core-js/modules/es.array.sort.js +var require_es_array_sort = __commonJS({ + "node_modules/core-js/modules/es.array.sort.js"() { + "use strict"; + var $ = require_export(); + var uncurryThis = require_function_uncurry_this(); + var aCallable = require_a_callable(); + var toObject = require_to_object(); + var lengthOfArrayLike = require_length_of_array_like(); + var deletePropertyOrThrow = require_delete_property_or_throw(); + var toString = require_to_string(); + var fails = require_fails(); + var internalSort = require_array_sort(); + var arrayMethodIsStrict = require_array_method_is_strict(); + var FF = require_engine_ff_version(); + var IE_OR_EDGE = require_engine_is_ie_or_edge(); + var V8 = require_engine_v8_version(); + var WEBKIT = require_engine_webkit_version(); + var test = []; + var nativeSort = uncurryThis(test.sort); + var push = uncurryThis(test.push); + var FAILS_ON_UNDEFINED = fails(function() { + test.sort(void 0); + }); + var FAILS_ON_NULL = fails(function() { + test.sort(null); + }); + var STRICT_METHOD = arrayMethodIsStrict("sort"); + var STABLE_SORT = !fails(function() { + if (V8) + return V8 < 70; + if (FF && FF > 3) + return; + if (IE_OR_EDGE) + return true; + if (WEBKIT) + return WEBKIT < 603; + var result = ""; + var code, chr, value, index; + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + switch (code) { + case 66: + case 69: + case 70: + case 72: + value = 3; + break; + case 68: + case 71: + value = 4; + break; + default: + value = 2; + } + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + test.sort(function(a, b) { + return b.v - a.v; + }); + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) + result += chr; + } + return result !== "DGBEFHACIJK"; + }); + var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT; + var getSortCompare = /* @__PURE__ */ __name(function(comparefn) { + return function(x, y) { + if (y === void 0) + return -1; + if (x === void 0) + return 1; + if (comparefn !== void 0) + return +comparefn(x, y) || 0; + return toString(x) > toString(y) ? 1 : -1; + }; + }, "getSortCompare"); + $({ target: "Array", proto: true, forced: FORCED }, { + sort: /* @__PURE__ */ __name(function sort(comparefn) { + if (comparefn !== void 0) + aCallable(comparefn); + var array = toObject(this); + if (STABLE_SORT) + return comparefn === void 0 ? nativeSort(array) : nativeSort(array, comparefn); + var items = []; + var arrayLength = lengthOfArrayLike(array); + var itemsLength, index; + for (index = 0; index < arrayLength; index++) { + if (index in array) + push(items, array[index]); + } + internalSort(items, getSortCompare(comparefn)); + itemsLength = lengthOfArrayLike(items); + index = 0; + while (index < itemsLength) + array[index] = items[index++]; + while (index < arrayLength) + deletePropertyOrThrow(array, index++); + return array; + }, "sort") + }); + } +}); + +// node_modules/core-js/internals/array-from-constructor-and-list.js +var require_array_from_constructor_and_list = __commonJS({ + "node_modules/core-js/internals/array-from-constructor-and-list.js"(exports, module2) { + "use strict"; + var lengthOfArrayLike = require_length_of_array_like(); + module2.exports = function(Constructor, list, $length) { + var index = 0; + var length = arguments.length > 2 ? $length : lengthOfArrayLike(list); + var result = new Constructor(length); + while (length > index) + result[index] = list[index++]; + return result; + }; + } +}); + +// node_modules/core-js/internals/get-built-in-prototype-method.js +var require_get_built_in_prototype_method = __commonJS({ + "node_modules/core-js/internals/get-built-in-prototype-method.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + module2.exports = function(CONSTRUCTOR, METHOD) { + var Constructor = global2[CONSTRUCTOR]; + var Prototype = Constructor && Constructor.prototype; + return Prototype && Prototype[METHOD]; + }; + } +}); + +// node_modules/core-js/modules/es.array.to-sorted.js +var require_es_array_to_sorted = __commonJS({ + "node_modules/core-js/modules/es.array.to-sorted.js"() { + "use strict"; + var $ = require_export(); + var uncurryThis = require_function_uncurry_this(); + var aCallable = require_a_callable(); + var toIndexedObject = require_to_indexed_object(); + var arrayFromConstructorAndList = require_array_from_constructor_and_list(); + var getBuiltInPrototypeMethod = require_get_built_in_prototype_method(); + var addToUnscopables = require_add_to_unscopables(); + var $Array = Array; + var sort = uncurryThis(getBuiltInPrototypeMethod("Array", "sort")); + $({ target: "Array", proto: true }, { + toSorted: /* @__PURE__ */ __name(function toSorted(compareFn) { + if (compareFn !== void 0) + aCallable(compareFn); + var O = toIndexedObject(this); + var A = arrayFromConstructorAndList($Array, O); + return sort(A, compareFn); + }, "toSorted") + }); + addToUnscopables("toSorted"); + } +}); + +// node_modules/core-js/es/array/to-sorted.js +var require_to_sorted = __commonJS({ + "node_modules/core-js/es/array/to-sorted.js"(exports, module2) { + "use strict"; + require_es_array_sort(); + require_es_array_to_sorted(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "toSorted"); + } +}); + +// node_modules/core-js/stable/array/to-sorted.js +var require_to_sorted2 = __commonJS({ + "node_modules/core-js/stable/array/to-sorted.js"(exports, module2) { + "use strict"; + var parent = require_to_sorted(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.to-sorted.js +var require_esnext_array_to_sorted = __commonJS({ + "node_modules/core-js/modules/esnext.array.to-sorted.js"() { + "use strict"; + require_es_array_to_sorted(); + } +}); + +// node_modules/core-js/actual/array/to-sorted.js +var require_to_sorted3 = __commonJS({ + "node_modules/core-js/actual/array/to-sorted.js"(exports, module2) { + "use strict"; + var parent = require_to_sorted2(); + require_esnext_array_to_sorted(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/does-not-exceed-safe-integer.js +var require_does_not_exceed_safe_integer = __commonJS({ + "node_modules/core-js/internals/does-not-exceed-safe-integer.js"(exports, module2) { + "use strict"; + var $TypeError = TypeError; + var MAX_SAFE_INTEGER = 9007199254740991; + module2.exports = function(it) { + if (it > MAX_SAFE_INTEGER) + throw $TypeError("Maximum allowed index exceeded"); + return it; + }; + } +}); + +// node_modules/core-js/modules/es.array.to-spliced.js +var require_es_array_to_spliced = __commonJS({ + "node_modules/core-js/modules/es.array.to-spliced.js"() { + "use strict"; + var $ = require_export(); + var addToUnscopables = require_add_to_unscopables(); + var doesNotExceedSafeInteger = require_does_not_exceed_safe_integer(); + var lengthOfArrayLike = require_length_of_array_like(); + var toAbsoluteIndex = require_to_absolute_index(); + var toIndexedObject = require_to_indexed_object(); + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var $Array = Array; + var max = Math.max; + var min = Math.min; + $({ target: "Array", proto: true }, { + toSpliced: /* @__PURE__ */ __name(function toSpliced(start, deleteCount) { + var O = toIndexedObject(this); + var len = lengthOfArrayLike(O); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var k = 0; + var insertCount, actualDeleteCount, newLen, A; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart); + } + newLen = doesNotExceedSafeInteger(len + insertCount - actualDeleteCount); + A = $Array(newLen); + for (; k < actualStart; k++) + A[k] = O[k]; + for (; k < actualStart + insertCount; k++) + A[k] = arguments[k - actualStart + 2]; + for (; k < newLen; k++) + A[k] = O[k + actualDeleteCount - insertCount]; + return A; + }, "toSpliced") + }); + addToUnscopables("toSpliced"); + } +}); + +// node_modules/core-js/es/array/to-spliced.js +var require_to_spliced = __commonJS({ + "node_modules/core-js/es/array/to-spliced.js"(exports, module2) { + "use strict"; + require_es_array_to_spliced(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "toSpliced"); + } +}); + +// node_modules/core-js/stable/array/to-spliced.js +var require_to_spliced2 = __commonJS({ + "node_modules/core-js/stable/array/to-spliced.js"(exports, module2) { + "use strict"; + var parent = require_to_spliced(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.to-spliced.js +var require_esnext_array_to_spliced = __commonJS({ + "node_modules/core-js/modules/esnext.array.to-spliced.js"() { + "use strict"; + require_es_array_to_spliced(); + } +}); + +// node_modules/core-js/actual/array/to-spliced.js +var require_to_spliced3 = __commonJS({ + "node_modules/core-js/actual/array/to-spliced.js"(exports, module2) { + "use strict"; + var parent = require_to_spliced2(); + require_esnext_array_to_spliced(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/function-uncurry-this-clause.js +var require_function_uncurry_this_clause = __commonJS({ + "node_modules/core-js/internals/function-uncurry-this-clause.js"(exports, module2) { + "use strict"; + var classofRaw = require_classof_raw(); + var uncurryThis = require_function_uncurry_this(); + module2.exports = function(fn) { + if (classofRaw(fn) === "Function") + return uncurryThis(fn); + }; + } +}); + +// node_modules/core-js/internals/function-bind-context.js +var require_function_bind_context = __commonJS({ + "node_modules/core-js/internals/function-bind-context.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this_clause(); + var aCallable = require_a_callable(); + var NATIVE_BIND = require_function_bind_native(); + var bind = uncurryThis(uncurryThis.bind); + module2.exports = function(fn, that) { + aCallable(fn); + return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() { + return fn.apply(that, arguments); + }; + }; + } +}); + +// node_modules/core-js/internals/array-iteration-from-last.js +var require_array_iteration_from_last = __commonJS({ + "node_modules/core-js/internals/array-iteration-from-last.js"(exports, module2) { + "use strict"; + var bind = require_function_bind_context(); + var IndexedObject = require_indexed_object(); + var toObject = require_to_object(); + var lengthOfArrayLike = require_length_of_array_like(); + var createMethod = /* @__PURE__ */ __name(function(TYPE) { + var IS_FIND_LAST_INDEX = TYPE === 1; + return function($this, callbackfn, that) { + var O = toObject($this); + var self2 = IndexedObject(O); + var index = lengthOfArrayLike(self2); + var boundFunction = bind(callbackfn, that); + var value, result; + while (index-- > 0) { + value = self2[index]; + result = boundFunction(value, index, O); + if (result) + switch (TYPE) { + case 0: + return value; + case 1: + return index; + } + } + return IS_FIND_LAST_INDEX ? -1 : void 0; + }; + }, "createMethod"); + module2.exports = { + // `Array.prototype.findLast` method + // https://github.com/tc39/proposal-array-find-from-last + findLast: createMethod(0), + // `Array.prototype.findLastIndex` method + // https://github.com/tc39/proposal-array-find-from-last + findLastIndex: createMethod(1) + }; + } +}); + +// node_modules/core-js/modules/es.array.find-last-index.js +var require_es_array_find_last_index = __commonJS({ + "node_modules/core-js/modules/es.array.find-last-index.js"() { + "use strict"; + var $ = require_export(); + var $findLastIndex = require_array_iteration_from_last().findLastIndex; + var addToUnscopables = require_add_to_unscopables(); + $({ target: "Array", proto: true }, { + findLastIndex: /* @__PURE__ */ __name(function findLastIndex(callbackfn) { + return $findLastIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : void 0); + }, "findLastIndex") + }); + addToUnscopables("findLastIndex"); + } +}); + +// node_modules/core-js/modules/esnext.array.find-last-index.js +var require_esnext_array_find_last_index = __commonJS({ + "node_modules/core-js/modules/esnext.array.find-last-index.js"() { + "use strict"; + require_es_array_find_last_index(); + } +}); + +// node_modules/core-js/es/array/find-last-index.js +var require_find_last_index = __commonJS({ + "node_modules/core-js/es/array/find-last-index.js"(exports, module2) { + "use strict"; + require_es_array_find_last_index(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "findLastIndex"); + } +}); + +// node_modules/core-js/stable/array/find-last-index.js +var require_find_last_index2 = __commonJS({ + "node_modules/core-js/stable/array/find-last-index.js"(exports, module2) { + "use strict"; + module2.exports = require_find_last_index(); + } +}); + +// node_modules/core-js/actual/array/find-last-index.js +var require_find_last_index3 = __commonJS({ + "node_modules/core-js/actual/array/find-last-index.js"(exports, module2) { + "use strict"; + require_esnext_array_find_last_index(); + var parent = require_find_last_index2(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/array-with.js +var require_array_with = __commonJS({ + "node_modules/core-js/internals/array-with.js"(exports, module2) { + "use strict"; + var lengthOfArrayLike = require_length_of_array_like(); + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var $RangeError = RangeError; + module2.exports = function(O, C, index, value) { + var len = lengthOfArrayLike(O); + var relativeIndex = toIntegerOrInfinity(index); + var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex; + if (actualIndex >= len || actualIndex < 0) + throw new $RangeError("Incorrect index"); + var A = new C(len); + var k = 0; + for (; k < len; k++) + A[k] = k === actualIndex ? value : O[k]; + return A; + }; + } +}); + +// node_modules/core-js/modules/es.array.with.js +var require_es_array_with = __commonJS({ + "node_modules/core-js/modules/es.array.with.js"() { + "use strict"; + var $ = require_export(); + var arrayWith = require_array_with(); + var toIndexedObject = require_to_indexed_object(); + var $Array = Array; + $({ target: "Array", proto: true }, { + "with": function(index, value) { + return arrayWith(toIndexedObject(this), $Array, index, value); + } + }); + } +}); + +// node_modules/core-js/es/array/with.js +var require_with = __commonJS({ + "node_modules/core-js/es/array/with.js"(exports, module2) { + "use strict"; + require_es_array_with(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "with"); + } +}); + +// node_modules/core-js/stable/array/with.js +var require_with2 = __commonJS({ + "node_modules/core-js/stable/array/with.js"(exports, module2) { + "use strict"; + var parent = require_with(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.with.js +var require_esnext_array_with = __commonJS({ + "node_modules/core-js/modules/esnext.array.with.js"() { + "use strict"; + require_es_array_with(); + } +}); + +// node_modules/core-js/actual/array/with.js +var require_with3 = __commonJS({ + "node_modules/core-js/actual/array/with.js"(exports, module2) { + "use strict"; + var parent = require_with2(); + require_esnext_array_with(); + module2.exports = parent; + } +}); + +// strict.js +var strict_exports = {}; +__export(strict_exports, { + sl: () => sl, + stringList: () => stringList +}); +module.exports = __toCommonJS(strict_exports); + +// StringLiteralList.js +var import_to_reversed = __toESM(require_to_reversed3(), 1); +var import_to_sorted = __toESM(require_to_sorted3(), 1); +var import_to_spliced = __toESM(require_to_spliced3(), 1); +var import_find_last_index = __toESM(require_find_last_index3(), 1); +var import_with = __toESM(require_with3(), 1); +var SeparatorsRegexp = /[[|\]{}()\\/\-_\\ .,\]]+/g; +var freezeIfImmutable = /* @__PURE__ */ __name((source, target) => { + if (source && target && Object.isFrozen(source)) { + return Object.freeze(target); + } + return target; +}, "freezeIfImmutable"); +var SL = class _SL extends Array { + static { + __name(this, "SL"); + } + infered = { + Union: void 0, + Tuple: void 0, + Mutable: void 0, + Unsorted: void 0 + }; + enum; + hasEmpty = false; + constructor(...args) { + const entries = []; + const arr = []; + let emptyFound = false; + for (const str of args.flat()) { + if (typeof str === "string") { + if (str === "") { + emptyFound = true; + } + entries.push([str, str]); + arr.push(str); + } + } + super(...arr); + this.hasEmpty = emptyFound; + this.enum = Object.fromEntries(entries); + if (this.hasEmpty) { + this.enum[""] = ""; + } + Object.freeze(this.enum); + } + concat(...args) { + return freezeIfImmutable( + this, + new _SL(...super.concat.apply(this, args.flat())) + ); + } + concatList(list) { + return this.concat(...list); + } + toSorted() { + return freezeIfImmutable( + this, + new _SL(...super.toSorted.apply(this, arguments)) + ); + } + toReversed() { + return freezeIfImmutable( + this, + new _SL(...super.toReversed.apply(this, arguments)) + ); + } + reverse() { + return freezeIfImmutable( + this, + new _SL(...super.reverse.apply(this, arguments)) + ); + } + toSpliced() { + return freezeIfImmutable( + this, + new _SL(...super.toSpliced.apply(this, arguments)) + ); + } + slice() { + return freezeIfImmutable( + this, + new _SL(...super.slice.apply(this, arguments)) + ); + } + without() { + const values = Array.from(arguments).flatMap( + (el) => Array.isArray(el) ? el.filter((s) => typeof s === "string") : typeof el === "string" ? [el] : [] + ); + return freezeIfImmutable( + this, + new _SL(...this.filter((e) => !values.includes(e))) + ); + } + withTrim() { + return freezeIfImmutable(this, new _SL(...super.map((e) => e.trim()))); + } + withPrefix(prefix = "") { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => `${prefix}${e}`)) + ); + } + withSuffix(suffix = "") { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => `${e}${suffix}`)) + ); + } + // withDerivatedSuffix(chars = '') { + // return freezeIfImmutable( + // this, + // new SL( + // ...super.flatMap((t) => [ + // t, + // t.endsWith(chars) + // ? t.slice(0, Math.min(t.length, chars.length) * -1) + // : `${t}${chars}`, + // ]), + // ), + // ); + // } + // withDerivatedPrefix(chars = '') { + // return freezeIfImmutable( + // this, + // new SL( + // ...super.flatMap((t) => [ + // t, + // t.startsWith(chars) + // ? t.slice(Math.min(chars.length, t.length), t.length) + // : `${chars}${t}`, + // ]), + // ), + // ); + // } + withReplace(string, replacement = void 0) { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.replace(string, replacement))) + ); + } + withReplaceAll(string, replacement = void 0) { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.replaceAll(string, replacement))) + ); + } + toLowerCase() { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.toLowerCase())) + ); + } + toUpperCase() { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.toUpperCase())) + ); + } + toCapitalize() { + return this.withReplace(/\b\w/g, (char) => char.toUpperCase()); + } + toUnCapitalize() { + return this.withReplace(/\b\w/g, (char) => char.toLowerCase()); + } + toPascalCase() { + return freezeIfImmutable( + this, + new _SL( + ...super.map( + (e) => e.trim().replace(SeparatorsRegexp, "_").replace(/[^a-z0-9_]+/gi, "").replace(/[_]+/g, "_").replace(/(?:^|_)(\w)/g, (_, char) => char.toUpperCase()).replace(/[\s_]+/g, "").trim() + ) + ) + ).toCapitalize(); + } + toCamelCase() { + return this.withPrefix("_").toPascalCase().toUnCapitalize(); + } + toSnakeCase() { + return freezeIfImmutable( + this, + new _SL( + ...super.map( + (e) => e.trim().replace(SeparatorsRegexp, "_").replace(/[^a-z0-9_]+/gi, "").replace(/([A-Z])/g, (_, char) => `_${char.toLowerCase()}`).replace(/[\s_]+/g, "_").replace(/^[_]+/g, "").toLowerCase().trim() + ) + ) + ); + } + value(value) { + if (typeof value === "string" && (this.enum[value] || this.hasEmpty && value === "")) { + return value; + } + throw new Error(`Invalid value ${value}`); + } + // Get the native array + mutable() { + return Array.from(this); + } + toRecordValue(initialValue = void 0, ...records) { + return Object.assign( + {}, + ...records, + Object.fromEntries(super.map((e) => [e, initialValue])) + ); + } + toRecordType(type = "any", initialValue = void 0, ...records) { + return Object.assign( + {}, + ...records, + Object.fromEntries(super.map((e) => [e, initialValue])) + ); + } + // Methods returning the native array + map() { + const mut = this.mutable(); + return mut.map.apply(mut, arguments); + } + filter() { + const mut = this.mutable(); + return mut.filter.apply(mut, arguments); + } + reduce() { + const mut = this.mutable(); + return mut.reduce.apply(mut, arguments); + } + reduceRight() { + const mut = this.mutable(); + return mut.reduceRight.apply(mut, arguments); + } + flat() { + const mut = this.mutable(); + return mut.flat.apply(mut, arguments); + } + flatMap() { + const mut = this.mutable(); + return mut.flatMap.apply(mut, arguments); + } + with() { + const mut = this.mutable(); + return mut.with.apply(mut, arguments); + } +}; +var ARRAY_IN_PLACE_MUTATION = Object.freeze({ + push: "push", + unshift: "unshift", + shift: "shift", + copyWithin: "copyWithin", + pop: "pop", + fill: "fill", + splice: "splice" +}); + +// stringListFunction.js +function stringListMutable(...strings) { + let values = strings; + let invalid = strings.some((el) => typeof el !== "string"); + if (strings.length && invalid) { + if (typeof window === "undefined" && true && true) { + console.debug( + `Unexpected type in stringList(${typeof invalid}). Casting all arguments to string type.` + ); + } + values = strings.flatMap( + (el) => Array.isArray(el) ? el.filter((s) => typeof s === "string") : typeof el === "string" ? [el] : typeof el === "number" ? [String(el)] : [] + ); + } + return new SL(...values); +} +__name(stringListMutable, "stringListMutable"); +function stringListReadonly(...strings) { + return Object.freeze(stringListMutable(...strings)); +} +__name(stringListReadonly, "stringListReadonly"); + +// strict.js +var stringList = stringListReadonly; +var sl = stringListReadonly; diff --git a/stringList.cjs b/stringList.cjs new file mode 100644 index 0000000..9f2fa60 --- /dev/null +++ b/stringList.cjs @@ -0,0 +1,2391 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/core-js/internals/global.js +var require_global = __commonJS({ + "node_modules/core-js/internals/global.js"(exports, module2) { + "use strict"; + var check = /* @__PURE__ */ __name(function(it) { + return it && it.Math === Math && it; + }, "check"); + module2.exports = // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == "object" && self) || check(typeof global == "object" && global) || check(typeof exports == "object" && exports) || // eslint-disable-next-line no-new-func -- fallback + /* @__PURE__ */ function() { + return this; + }() || Function("return this")(); + } +}); + +// node_modules/core-js/internals/fails.js +var require_fails = __commonJS({ + "node_modules/core-js/internals/fails.js"(exports, module2) { + "use strict"; + module2.exports = function(exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + } +}); + +// node_modules/core-js/internals/descriptors.js +var require_descriptors = __commonJS({ + "node_modules/core-js/internals/descriptors.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + module2.exports = !fails(function() { + return Object.defineProperty({}, 1, { get: function() { + return 7; + } })[1] !== 7; + }); + } +}); + +// node_modules/core-js/internals/function-bind-native.js +var require_function_bind_native = __commonJS({ + "node_modules/core-js/internals/function-bind-native.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + module2.exports = !fails(function() { + var test = function() { + }.bind(); + return typeof test != "function" || test.hasOwnProperty("prototype"); + }); + } +}); + +// node_modules/core-js/internals/function-call.js +var require_function_call = __commonJS({ + "node_modules/core-js/internals/function-call.js"(exports, module2) { + "use strict"; + var NATIVE_BIND = require_function_bind_native(); + var call = Function.prototype.call; + module2.exports = NATIVE_BIND ? call.bind(call) : function() { + return call.apply(call, arguments); + }; + } +}); + +// node_modules/core-js/internals/object-property-is-enumerable.js +var require_object_property_is_enumerable = __commonJS({ + "node_modules/core-js/internals/object-property-is-enumerable.js"(exports) { + "use strict"; + var $propertyIsEnumerable = {}.propertyIsEnumerable; + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); + exports.f = NASHORN_BUG ? /* @__PURE__ */ __name(function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; + }, "propertyIsEnumerable") : $propertyIsEnumerable; + } +}); + +// node_modules/core-js/internals/create-property-descriptor.js +var require_create_property_descriptor = __commonJS({ + "node_modules/core-js/internals/create-property-descriptor.js"(exports, module2) { + "use strict"; + module2.exports = function(bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value + }; + }; + } +}); + +// node_modules/core-js/internals/function-uncurry-this.js +var require_function_uncurry_this = __commonJS({ + "node_modules/core-js/internals/function-uncurry-this.js"(exports, module2) { + "use strict"; + var NATIVE_BIND = require_function_bind_native(); + var FunctionPrototype = Function.prototype; + var call = FunctionPrototype.call; + var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call); + module2.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) { + return function() { + return call.apply(fn, arguments); + }; + }; + } +}); + +// node_modules/core-js/internals/classof-raw.js +var require_classof_raw = __commonJS({ + "node_modules/core-js/internals/classof-raw.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var toString = uncurryThis({}.toString); + var stringSlice = uncurryThis("".slice); + module2.exports = function(it) { + return stringSlice(toString(it), 8, -1); + }; + } +}); + +// node_modules/core-js/internals/indexed-object.js +var require_indexed_object = __commonJS({ + "node_modules/core-js/internals/indexed-object.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var fails = require_fails(); + var classof = require_classof_raw(); + var $Object = Object; + var split = uncurryThis("".split); + module2.exports = fails(function() { + return !$Object("z").propertyIsEnumerable(0); + }) ? function(it) { + return classof(it) === "String" ? split(it, "") : $Object(it); + } : $Object; + } +}); + +// node_modules/core-js/internals/is-null-or-undefined.js +var require_is_null_or_undefined = __commonJS({ + "node_modules/core-js/internals/is-null-or-undefined.js"(exports, module2) { + "use strict"; + module2.exports = function(it) { + return it === null || it === void 0; + }; + } +}); + +// node_modules/core-js/internals/require-object-coercible.js +var require_require_object_coercible = __commonJS({ + "node_modules/core-js/internals/require-object-coercible.js"(exports, module2) { + "use strict"; + var isNullOrUndefined = require_is_null_or_undefined(); + var $TypeError = TypeError; + module2.exports = function(it) { + if (isNullOrUndefined(it)) + throw new $TypeError("Can't call method on " + it); + return it; + }; + } +}); + +// node_modules/core-js/internals/to-indexed-object.js +var require_to_indexed_object = __commonJS({ + "node_modules/core-js/internals/to-indexed-object.js"(exports, module2) { + "use strict"; + var IndexedObject = require_indexed_object(); + var requireObjectCoercible = require_require_object_coercible(); + module2.exports = function(it) { + return IndexedObject(requireObjectCoercible(it)); + }; + } +}); + +// node_modules/core-js/internals/is-callable.js +var require_is_callable = __commonJS({ + "node_modules/core-js/internals/is-callable.js"(exports, module2) { + "use strict"; + var documentAll = typeof document == "object" && document.all; + module2.exports = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) { + return typeof argument == "function" || argument === documentAll; + } : function(argument) { + return typeof argument == "function"; + }; + } +}); + +// node_modules/core-js/internals/is-object.js +var require_is_object = __commonJS({ + "node_modules/core-js/internals/is-object.js"(exports, module2) { + "use strict"; + var isCallable = require_is_callable(); + module2.exports = function(it) { + return typeof it == "object" ? it !== null : isCallable(it); + }; + } +}); + +// node_modules/core-js/internals/get-built-in.js +var require_get_built_in = __commonJS({ + "node_modules/core-js/internals/get-built-in.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var isCallable = require_is_callable(); + var aFunction = /* @__PURE__ */ __name(function(argument) { + return isCallable(argument) ? argument : void 0; + }, "aFunction"); + module2.exports = function(namespace, method) { + return arguments.length < 2 ? aFunction(global2[namespace]) : global2[namespace] && global2[namespace][method]; + }; + } +}); + +// node_modules/core-js/internals/object-is-prototype-of.js +var require_object_is_prototype_of = __commonJS({ + "node_modules/core-js/internals/object-is-prototype-of.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + module2.exports = uncurryThis({}.isPrototypeOf); + } +}); + +// node_modules/core-js/internals/engine-user-agent.js +var require_engine_user_agent = __commonJS({ + "node_modules/core-js/internals/engine-user-agent.js"(exports, module2) { + "use strict"; + module2.exports = typeof navigator != "undefined" && String(navigator.userAgent) || ""; + } +}); + +// node_modules/core-js/internals/engine-v8-version.js +var require_engine_v8_version = __commonJS({ + "node_modules/core-js/internals/engine-v8-version.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var userAgent = require_engine_user_agent(); + var process2 = global2.process; + var Deno = global2.Deno; + var versions = process2 && process2.versions || Deno && Deno.version; + var v8 = versions && versions.v8; + var match; + var version; + if (v8) { + match = v8.split("."); + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + if (!version && userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) + version = +match[1]; + } + } + module2.exports = version; + } +}); + +// node_modules/core-js/internals/symbol-constructor-detection.js +var require_symbol_constructor_detection = __commonJS({ + "node_modules/core-js/internals/symbol-constructor-detection.js"(exports, module2) { + "use strict"; + var V8_VERSION = require_engine_v8_version(); + var fails = require_fails(); + var global2 = require_global(); + var $String = global2.String; + module2.exports = !!Object.getOwnPropertySymbols && !fails(function() { + var symbol = Symbol("symbol detection"); + return !$String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION && V8_VERSION < 41; + }); + } +}); + +// node_modules/core-js/internals/use-symbol-as-uid.js +var require_use_symbol_as_uid = __commonJS({ + "node_modules/core-js/internals/use-symbol-as-uid.js"(exports, module2) { + "use strict"; + var NATIVE_SYMBOL = require_symbol_constructor_detection(); + module2.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol"; + } +}); + +// node_modules/core-js/internals/is-symbol.js +var require_is_symbol = __commonJS({ + "node_modules/core-js/internals/is-symbol.js"(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + var isCallable = require_is_callable(); + var isPrototypeOf = require_object_is_prototype_of(); + var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); + var $Object = Object; + module2.exports = USE_SYMBOL_AS_UID ? function(it) { + return typeof it == "symbol"; + } : function(it) { + var $Symbol = getBuiltIn("Symbol"); + return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it)); + }; + } +}); + +// node_modules/core-js/internals/try-to-string.js +var require_try_to_string = __commonJS({ + "node_modules/core-js/internals/try-to-string.js"(exports, module2) { + "use strict"; + var $String = String; + module2.exports = function(argument) { + try { + return $String(argument); + } catch (error) { + return "Object"; + } + }; + } +}); + +// node_modules/core-js/internals/a-callable.js +var require_a_callable = __commonJS({ + "node_modules/core-js/internals/a-callable.js"(exports, module2) { + "use strict"; + var isCallable = require_is_callable(); + var tryToString = require_try_to_string(); + var $TypeError = TypeError; + module2.exports = function(argument) { + if (isCallable(argument)) + return argument; + throw new $TypeError(tryToString(argument) + " is not a function"); + }; + } +}); + +// node_modules/core-js/internals/get-method.js +var require_get_method = __commonJS({ + "node_modules/core-js/internals/get-method.js"(exports, module2) { + "use strict"; + var aCallable = require_a_callable(); + var isNullOrUndefined = require_is_null_or_undefined(); + module2.exports = function(V, P) { + var func = V[P]; + return isNullOrUndefined(func) ? void 0 : aCallable(func); + }; + } +}); + +// node_modules/core-js/internals/ordinary-to-primitive.js +var require_ordinary_to_primitive = __commonJS({ + "node_modules/core-js/internals/ordinary-to-primitive.js"(exports, module2) { + "use strict"; + var call = require_function_call(); + var isCallable = require_is_callable(); + var isObject = require_is_object(); + var $TypeError = TypeError; + module2.exports = function(input, pref) { + var fn, val; + if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) + return val; + if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) + return val; + if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) + return val; + throw new $TypeError("Can't convert object to primitive value"); + }; + } +}); + +// node_modules/core-js/internals/is-pure.js +var require_is_pure = __commonJS({ + "node_modules/core-js/internals/is-pure.js"(exports, module2) { + "use strict"; + module2.exports = false; + } +}); + +// node_modules/core-js/internals/define-global-property.js +var require_define_global_property = __commonJS({ + "node_modules/core-js/internals/define-global-property.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var defineProperty = Object.defineProperty; + module2.exports = function(key, value) { + try { + defineProperty(global2, key, { value, configurable: true, writable: true }); + } catch (error) { + global2[key] = value; + } + return value; + }; + } +}); + +// node_modules/core-js/internals/shared-store.js +var require_shared_store = __commonJS({ + "node_modules/core-js/internals/shared-store.js"(exports, module2) { + "use strict"; + var IS_PURE = require_is_pure(); + var globalThis2 = require_global(); + var defineGlobalProperty = require_define_global_property(); + var SHARED = "__core-js_shared__"; + var store = module2.exports = globalThis2[SHARED] || defineGlobalProperty(SHARED, {}); + (store.versions || (store.versions = [])).push({ + version: "3.36.0", + mode: IS_PURE ? "pure" : "global", + copyright: "\xA9 2014-2024 Denis Pushkarev (zloirock.ru)", + license: "https://github.com/zloirock/core-js/blob/v3.36.0/LICENSE", + source: "https://github.com/zloirock/core-js" + }); + } +}); + +// node_modules/core-js/internals/shared.js +var require_shared = __commonJS({ + "node_modules/core-js/internals/shared.js"(exports, module2) { + "use strict"; + var store = require_shared_store(); + module2.exports = function(key, value) { + return store[key] || (store[key] = value || {}); + }; + } +}); + +// node_modules/core-js/internals/to-object.js +var require_to_object = __commonJS({ + "node_modules/core-js/internals/to-object.js"(exports, module2) { + "use strict"; + var requireObjectCoercible = require_require_object_coercible(); + var $Object = Object; + module2.exports = function(argument) { + return $Object(requireObjectCoercible(argument)); + }; + } +}); + +// node_modules/core-js/internals/has-own-property.js +var require_has_own_property = __commonJS({ + "node_modules/core-js/internals/has-own-property.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var toObject = require_to_object(); + var hasOwnProperty = uncurryThis({}.hasOwnProperty); + module2.exports = Object.hasOwn || /* @__PURE__ */ __name(function hasOwn(it, key) { + return hasOwnProperty(toObject(it), key); + }, "hasOwn"); + } +}); + +// node_modules/core-js/internals/uid.js +var require_uid = __commonJS({ + "node_modules/core-js/internals/uid.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var id = 0; + var postfix = Math.random(); + var toString = uncurryThis(1 .toString); + module2.exports = function(key) { + return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString(++id + postfix, 36); + }; + } +}); + +// node_modules/core-js/internals/well-known-symbol.js +var require_well_known_symbol = __commonJS({ + "node_modules/core-js/internals/well-known-symbol.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var shared = require_shared(); + var hasOwn = require_has_own_property(); + var uid = require_uid(); + var NATIVE_SYMBOL = require_symbol_constructor_detection(); + var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); + var Symbol2 = global2.Symbol; + var WellKnownSymbolsStore = shared("wks"); + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid; + module2.exports = function(name) { + if (!hasOwn(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name); + } + return WellKnownSymbolsStore[name]; + }; + } +}); + +// node_modules/core-js/internals/to-primitive.js +var require_to_primitive = __commonJS({ + "node_modules/core-js/internals/to-primitive.js"(exports, module2) { + "use strict"; + var call = require_function_call(); + var isObject = require_is_object(); + var isSymbol = require_is_symbol(); + var getMethod = require_get_method(); + var ordinaryToPrimitive = require_ordinary_to_primitive(); + var wellKnownSymbol = require_well_known_symbol(); + var $TypeError = TypeError; + var TO_PRIMITIVE = wellKnownSymbol("toPrimitive"); + module2.exports = function(input, pref) { + if (!isObject(input) || isSymbol(input)) + return input; + var exoticToPrim = getMethod(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === void 0) + pref = "default"; + result = call(exoticToPrim, input, pref); + if (!isObject(result) || isSymbol(result)) + return result; + throw new $TypeError("Can't convert object to primitive value"); + } + if (pref === void 0) + pref = "number"; + return ordinaryToPrimitive(input, pref); + }; + } +}); + +// node_modules/core-js/internals/to-property-key.js +var require_to_property_key = __commonJS({ + "node_modules/core-js/internals/to-property-key.js"(exports, module2) { + "use strict"; + var toPrimitive = require_to_primitive(); + var isSymbol = require_is_symbol(); + module2.exports = function(argument) { + var key = toPrimitive(argument, "string"); + return isSymbol(key) ? key : key + ""; + }; + } +}); + +// node_modules/core-js/internals/document-create-element.js +var require_document_create_element = __commonJS({ + "node_modules/core-js/internals/document-create-element.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var isObject = require_is_object(); + var document2 = global2.document; + var EXISTS = isObject(document2) && isObject(document2.createElement); + module2.exports = function(it) { + return EXISTS ? document2.createElement(it) : {}; + }; + } +}); + +// node_modules/core-js/internals/ie8-dom-define.js +var require_ie8_dom_define = __commonJS({ + "node_modules/core-js/internals/ie8-dom-define.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var fails = require_fails(); + var createElement = require_document_create_element(); + module2.exports = !DESCRIPTORS && !fails(function() { + return Object.defineProperty(createElement("div"), "a", { + get: function() { + return 7; + } + }).a !== 7; + }); + } +}); + +// node_modules/core-js/internals/object-get-own-property-descriptor.js +var require_object_get_own_property_descriptor = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-descriptor.js"(exports) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var call = require_function_call(); + var propertyIsEnumerableModule = require_object_property_is_enumerable(); + var createPropertyDescriptor = require_create_property_descriptor(); + var toIndexedObject = require_to_indexed_object(); + var toPropertyKey = require_to_property_key(); + var hasOwn = require_has_own_property(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : /* @__PURE__ */ __name(function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) + try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { + } + if (hasOwn(O, P)) + return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); + }, "getOwnPropertyDescriptor"); + } +}); + +// node_modules/core-js/internals/v8-prototype-define-bug.js +var require_v8_prototype_define_bug = __commonJS({ + "node_modules/core-js/internals/v8-prototype-define-bug.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var fails = require_fails(); + module2.exports = DESCRIPTORS && fails(function() { + return Object.defineProperty(function() { + }, "prototype", { + value: 42, + writable: false + }).prototype !== 42; + }); + } +}); + +// node_modules/core-js/internals/an-object.js +var require_an_object = __commonJS({ + "node_modules/core-js/internals/an-object.js"(exports, module2) { + "use strict"; + var isObject = require_is_object(); + var $String = String; + var $TypeError = TypeError; + module2.exports = function(argument) { + if (isObject(argument)) + return argument; + throw new $TypeError($String(argument) + " is not an object"); + }; + } +}); + +// node_modules/core-js/internals/object-define-property.js +var require_object_define_property = __commonJS({ + "node_modules/core-js/internals/object-define-property.js"(exports) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug(); + var anObject = require_an_object(); + var toPropertyKey = require_to_property_key(); + var $TypeError = TypeError; + var $defineProperty = Object.defineProperty; + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var ENUMERABLE = "enumerable"; + var CONFIGURABLE = "configurable"; + var WRITABLE = "writable"; + exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? /* @__PURE__ */ __name(function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } + return $defineProperty(O, P, Attributes); + }, "defineProperty") : $defineProperty : /* @__PURE__ */ __name(function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (IE8_DOM_DEFINE) + try { + return $defineProperty(O, P, Attributes); + } catch (error) { + } + if ("get" in Attributes || "set" in Attributes) + throw new $TypeError("Accessors not supported"); + if ("value" in Attributes) + O[P] = Attributes.value; + return O; + }, "defineProperty"); + } +}); + +// node_modules/core-js/internals/create-non-enumerable-property.js +var require_create_non_enumerable_property = __commonJS({ + "node_modules/core-js/internals/create-non-enumerable-property.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var definePropertyModule = require_object_define_property(); + var createPropertyDescriptor = require_create_property_descriptor(); + module2.exports = DESCRIPTORS ? function(object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); + } : function(object, key, value) { + object[key] = value; + return object; + }; + } +}); + +// node_modules/core-js/internals/function-name.js +var require_function_name = __commonJS({ + "node_modules/core-js/internals/function-name.js"(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var hasOwn = require_has_own_property(); + var FunctionPrototype = Function.prototype; + var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor; + var EXISTS = hasOwn(FunctionPrototype, "name"); + var PROPER = EXISTS && (/* @__PURE__ */ __name(function something() { + }, "something")).name === "something"; + var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, "name").configurable); + module2.exports = { + EXISTS, + PROPER, + CONFIGURABLE + }; + } +}); + +// node_modules/core-js/internals/inspect-source.js +var require_inspect_source = __commonJS({ + "node_modules/core-js/internals/inspect-source.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var isCallable = require_is_callable(); + var store = require_shared_store(); + var functionToString = uncurryThis(Function.toString); + if (!isCallable(store.inspectSource)) { + store.inspectSource = function(it) { + return functionToString(it); + }; + } + module2.exports = store.inspectSource; + } +}); + +// node_modules/core-js/internals/weak-map-basic-detection.js +var require_weak_map_basic_detection = __commonJS({ + "node_modules/core-js/internals/weak-map-basic-detection.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var isCallable = require_is_callable(); + var WeakMap = global2.WeakMap; + module2.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap)); + } +}); + +// node_modules/core-js/internals/shared-key.js +var require_shared_key = __commonJS({ + "node_modules/core-js/internals/shared-key.js"(exports, module2) { + "use strict"; + var shared = require_shared(); + var uid = require_uid(); + var keys = shared("keys"); + module2.exports = function(key) { + return keys[key] || (keys[key] = uid(key)); + }; + } +}); + +// node_modules/core-js/internals/hidden-keys.js +var require_hidden_keys = __commonJS({ + "node_modules/core-js/internals/hidden-keys.js"(exports, module2) { + "use strict"; + module2.exports = {}; + } +}); + +// node_modules/core-js/internals/internal-state.js +var require_internal_state = __commonJS({ + "node_modules/core-js/internals/internal-state.js"(exports, module2) { + "use strict"; + var NATIVE_WEAK_MAP = require_weak_map_basic_detection(); + var global2 = require_global(); + var isObject = require_is_object(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var hasOwn = require_has_own_property(); + var shared = require_shared_store(); + var sharedKey = require_shared_key(); + var hiddenKeys = require_hidden_keys(); + var OBJECT_ALREADY_INITIALIZED = "Object already initialized"; + var TypeError2 = global2.TypeError; + var WeakMap = global2.WeakMap; + var set; + var get; + var has; + var enforce = /* @__PURE__ */ __name(function(it) { + return has(it) ? get(it) : set(it, {}); + }, "enforce"); + var getterFor = /* @__PURE__ */ __name(function(TYPE) { + return function(it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw new TypeError2("Incompatible receiver, " + TYPE + " required"); + } + return state; + }; + }, "getterFor"); + if (NATIVE_WEAK_MAP || shared.state) { + store = shared.state || (shared.state = new WeakMap()); + store.get = store.get; + store.has = store.has; + store.set = store.set; + set = /* @__PURE__ */ __name(function(it, metadata) { + if (store.has(it)) + throw new TypeError2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }, "set"); + get = /* @__PURE__ */ __name(function(it) { + return store.get(it) || {}; + }, "get"); + has = /* @__PURE__ */ __name(function(it) { + return store.has(it); + }, "has"); + } else { + STATE = sharedKey("state"); + hiddenKeys[STATE] = true; + set = /* @__PURE__ */ __name(function(it, metadata) { + if (hasOwn(it, STATE)) + throw new TypeError2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }, "set"); + get = /* @__PURE__ */ __name(function(it) { + return hasOwn(it, STATE) ? it[STATE] : {}; + }, "get"); + has = /* @__PURE__ */ __name(function(it) { + return hasOwn(it, STATE); + }, "has"); + } + var store; + var STATE; + module2.exports = { + set, + get, + has, + enforce, + getterFor + }; + } +}); + +// node_modules/core-js/internals/make-built-in.js +var require_make_built_in = __commonJS({ + "node_modules/core-js/internals/make-built-in.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var fails = require_fails(); + var isCallable = require_is_callable(); + var hasOwn = require_has_own_property(); + var DESCRIPTORS = require_descriptors(); + var CONFIGURABLE_FUNCTION_NAME = require_function_name().CONFIGURABLE; + var inspectSource = require_inspect_source(); + var InternalStateModule = require_internal_state(); + var enforceInternalState = InternalStateModule.enforce; + var getInternalState = InternalStateModule.get; + var $String = String; + var defineProperty = Object.defineProperty; + var stringSlice = uncurryThis("".slice); + var replace = uncurryThis("".replace); + var join = uncurryThis([].join); + var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() { + return defineProperty(function() { + }, "length", { value: 8 }).length !== 8; + }); + var TEMPLATE = String(String).split("String"); + var makeBuiltIn = module2.exports = function(value, name, options) { + if (stringSlice($String(name), 0, 7) === "Symbol(") { + name = "[" + replace($String(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]"; + } + if (options && options.getter) + name = "get " + name; + if (options && options.setter) + name = "set " + name; + if (!hasOwn(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) { + if (DESCRIPTORS) + defineProperty(value, "name", { value: name, configurable: true }); + else + value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn(options, "arity") && value.length !== options.arity) { + defineProperty(value, "length", { value: options.arity }); + } + try { + if (options && hasOwn(options, "constructor") && options.constructor) { + if (DESCRIPTORS) + defineProperty(value, "prototype", { writable: false }); + } else if (value.prototype) + value.prototype = void 0; + } catch (error) { + } + var state = enforceInternalState(value); + if (!hasOwn(state, "source")) { + state.source = join(TEMPLATE, typeof name == "string" ? name : ""); + } + return value; + }; + Function.prototype.toString = makeBuiltIn(/* @__PURE__ */ __name(function toString() { + return isCallable(this) && getInternalState(this).source || inspectSource(this); + }, "toString"), "toString"); + } +}); + +// node_modules/core-js/internals/define-built-in.js +var require_define_built_in = __commonJS({ + "node_modules/core-js/internals/define-built-in.js"(exports, module2) { + "use strict"; + var isCallable = require_is_callable(); + var definePropertyModule = require_object_define_property(); + var makeBuiltIn = require_make_built_in(); + var defineGlobalProperty = require_define_global_property(); + module2.exports = function(O, key, value, options) { + if (!options) + options = {}; + var simple = options.enumerable; + var name = options.name !== void 0 ? options.name : key; + if (isCallable(value)) + makeBuiltIn(value, name, options); + if (options.global) { + if (simple) + O[key] = value; + else + defineGlobalProperty(key, value); + } else { + try { + if (!options.unsafe) + delete O[key]; + else if (O[key]) + simple = true; + } catch (error) { + } + if (simple) + O[key] = value; + else + definePropertyModule.f(O, key, { + value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } + return O; + }; + } +}); + +// node_modules/core-js/internals/math-trunc.js +var require_math_trunc = __commonJS({ + "node_modules/core-js/internals/math-trunc.js"(exports, module2) { + "use strict"; + var ceil = Math.ceil; + var floor = Math.floor; + module2.exports = Math.trunc || /* @__PURE__ */ __name(function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); + }, "trunc"); + } +}); + +// node_modules/core-js/internals/to-integer-or-infinity.js +var require_to_integer_or_infinity = __commonJS({ + "node_modules/core-js/internals/to-integer-or-infinity.js"(exports, module2) { + "use strict"; + var trunc = require_math_trunc(); + module2.exports = function(argument) { + var number = +argument; + return number !== number || number === 0 ? 0 : trunc(number); + }; + } +}); + +// node_modules/core-js/internals/to-absolute-index.js +var require_to_absolute_index = __commonJS({ + "node_modules/core-js/internals/to-absolute-index.js"(exports, module2) { + "use strict"; + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var max = Math.max; + var min = Math.min; + module2.exports = function(index, length) { + var integer = toIntegerOrInfinity(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); + }; + } +}); + +// node_modules/core-js/internals/to-length.js +var require_to_length = __commonJS({ + "node_modules/core-js/internals/to-length.js"(exports, module2) { + "use strict"; + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var min = Math.min; + module2.exports = function(argument) { + var len = toIntegerOrInfinity(argument); + return len > 0 ? min(len, 9007199254740991) : 0; + }; + } +}); + +// node_modules/core-js/internals/length-of-array-like.js +var require_length_of_array_like = __commonJS({ + "node_modules/core-js/internals/length-of-array-like.js"(exports, module2) { + "use strict"; + var toLength = require_to_length(); + module2.exports = function(obj) { + return toLength(obj.length); + }; + } +}); + +// node_modules/core-js/internals/array-includes.js +var require_array_includes = __commonJS({ + "node_modules/core-js/internals/array-includes.js"(exports, module2) { + "use strict"; + var toIndexedObject = require_to_indexed_object(); + var toAbsoluteIndex = require_to_absolute_index(); + var lengthOfArrayLike = require_length_of_array_like(); + var createMethod = /* @__PURE__ */ __name(function(IS_INCLUDES) { + return function($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = lengthOfArrayLike(O); + if (length === 0) + return !IS_INCLUDES && -1; + var index = toAbsoluteIndex(fromIndex, length); + var value; + if (IS_INCLUDES && el !== el) + while (length > index) { + value = O[index++]; + if (value !== value) + return true; + } + else + for (; length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) + return IS_INCLUDES || index || 0; + } + return !IS_INCLUDES && -1; + }; + }, "createMethod"); + module2.exports = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) + }; + } +}); + +// node_modules/core-js/internals/object-keys-internal.js +var require_object_keys_internal = __commonJS({ + "node_modules/core-js/internals/object-keys-internal.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + var hasOwn = require_has_own_property(); + var toIndexedObject = require_to_indexed_object(); + var indexOf = require_array_includes().indexOf; + var hiddenKeys = require_hidden_keys(); + var push = uncurryThis([].push); + module2.exports = function(object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) + !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key); + while (names.length > i) + if (hasOwn(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; + }; + } +}); + +// node_modules/core-js/internals/enum-bug-keys.js +var require_enum_bug_keys = __commonJS({ + "node_modules/core-js/internals/enum-bug-keys.js"(exports, module2) { + "use strict"; + module2.exports = [ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf" + ]; + } +}); + +// node_modules/core-js/internals/object-get-own-property-names.js +var require_object_get_own_property_names = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-names.js"(exports) { + "use strict"; + var internalObjectKeys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + var hiddenKeys = enumBugKeys.concat("length", "prototype"); + exports.f = Object.getOwnPropertyNames || /* @__PURE__ */ __name(function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); + }, "getOwnPropertyNames"); + } +}); + +// node_modules/core-js/internals/object-get-own-property-symbols.js +var require_object_get_own_property_symbols = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-symbols.js"(exports) { + "use strict"; + exports.f = Object.getOwnPropertySymbols; + } +}); + +// node_modules/core-js/internals/own-keys.js +var require_own_keys = __commonJS({ + "node_modules/core-js/internals/own-keys.js"(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + var uncurryThis = require_function_uncurry_this(); + var getOwnPropertyNamesModule = require_object_get_own_property_names(); + var getOwnPropertySymbolsModule = require_object_get_own_property_symbols(); + var anObject = require_an_object(); + var concat = uncurryThis([].concat); + module2.exports = getBuiltIn("Reflect", "ownKeys") || /* @__PURE__ */ __name(function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys; + }, "ownKeys"); + } +}); + +// node_modules/core-js/internals/copy-constructor-properties.js +var require_copy_constructor_properties = __commonJS({ + "node_modules/core-js/internals/copy-constructor-properties.js"(exports, module2) { + "use strict"; + var hasOwn = require_has_own_property(); + var ownKeys = require_own_keys(); + var getOwnPropertyDescriptorModule = require_object_get_own_property_descriptor(); + var definePropertyModule = require_object_define_property(); + module2.exports = function(target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + } +}); + +// node_modules/core-js/internals/is-forced.js +var require_is_forced = __commonJS({ + "node_modules/core-js/internals/is-forced.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + var isCallable = require_is_callable(); + var replacement = /#|\.prototype\./; + var isForced = /* @__PURE__ */ __name(function(feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection; + }, "isForced"); + var normalize = isForced.normalize = function(string) { + return String(string).replace(replacement, ".").toLowerCase(); + }; + var data = isForced.data = {}; + var NATIVE = isForced.NATIVE = "N"; + var POLYFILL = isForced.POLYFILL = "P"; + module2.exports = isForced; + } +}); + +// node_modules/core-js/internals/export.js +var require_export = __commonJS({ + "node_modules/core-js/internals/export.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f; + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var defineBuiltIn = require_define_built_in(); + var defineGlobalProperty = require_define_global_property(); + var copyConstructorProperties = require_copy_constructor_properties(); + var isForced = require_is_forced(); + module2.exports = function(options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global2; + } else if (STATIC) { + target = global2[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = global2[TARGET] && global2[TARGET].prototype; + } + if (target) + for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else + targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced); + if (!FORCED && targetProperty !== void 0) { + if (typeof sourceProperty == typeof targetProperty) + continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + if (options.sham || targetProperty && targetProperty.sham) { + createNonEnumerableProperty(sourceProperty, "sham", true); + } + defineBuiltIn(target, key, sourceProperty, options); + } + }; + } +}); + +// node_modules/core-js/internals/array-to-reversed.js +var require_array_to_reversed = __commonJS({ + "node_modules/core-js/internals/array-to-reversed.js"(exports, module2) { + "use strict"; + var lengthOfArrayLike = require_length_of_array_like(); + module2.exports = function(O, C) { + var len = lengthOfArrayLike(O); + var A = new C(len); + var k = 0; + for (; k < len; k++) + A[k] = O[len - k - 1]; + return A; + }; + } +}); + +// node_modules/core-js/internals/object-keys.js +var require_object_keys = __commonJS({ + "node_modules/core-js/internals/object-keys.js"(exports, module2) { + "use strict"; + var internalObjectKeys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + module2.exports = Object.keys || /* @__PURE__ */ __name(function keys(O) { + return internalObjectKeys(O, enumBugKeys); + }, "keys"); + } +}); + +// node_modules/core-js/internals/object-define-properties.js +var require_object_define_properties = __commonJS({ + "node_modules/core-js/internals/object-define-properties.js"(exports) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug(); + var definePropertyModule = require_object_define_property(); + var anObject = require_an_object(); + var toIndexedObject = require_to_indexed_object(); + var objectKeys = require_object_keys(); + exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : /* @__PURE__ */ __name(function defineProperties(O, Properties) { + anObject(O); + var props = toIndexedObject(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) + definePropertyModule.f(O, key = keys[index++], props[key]); + return O; + }, "defineProperties"); + } +}); + +// node_modules/core-js/internals/html.js +var require_html = __commonJS({ + "node_modules/core-js/internals/html.js"(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + module2.exports = getBuiltIn("document", "documentElement"); + } +}); + +// node_modules/core-js/internals/object-create.js +var require_object_create = __commonJS({ + "node_modules/core-js/internals/object-create.js"(exports, module2) { + "use strict"; + var anObject = require_an_object(); + var definePropertiesModule = require_object_define_properties(); + var enumBugKeys = require_enum_bug_keys(); + var hiddenKeys = require_hidden_keys(); + var html = require_html(); + var documentCreateElement = require_document_create_element(); + var sharedKey = require_shared_key(); + var GT = ">"; + var LT = "<"; + var PROTOTYPE = "prototype"; + var SCRIPT = "script"; + var IE_PROTO = sharedKey("IE_PROTO"); + var EmptyConstructor = /* @__PURE__ */ __name(function() { + }, "EmptyConstructor"); + var scriptTag = /* @__PURE__ */ __name(function(content) { + return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT; + }, "scriptTag"); + var NullProtoObjectViaActiveX = /* @__PURE__ */ __name(function(activeXDocument2) { + activeXDocument2.write(scriptTag("")); + activeXDocument2.close(); + var temp = activeXDocument2.parentWindow.Object; + activeXDocument2 = null; + return temp; + }, "NullProtoObjectViaActiveX"); + var NullProtoObjectViaIFrame = /* @__PURE__ */ __name(function() { + var iframe = documentCreateElement("iframe"); + var JS = "java" + SCRIPT + ":"; + var iframeDocument; + iframe.style.display = "none"; + html.appendChild(iframe); + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag("document.F=Object")); + iframeDocument.close(); + return iframeDocument.F; + }, "NullProtoObjectViaIFrame"); + var activeXDocument; + var NullProtoObject = /* @__PURE__ */ __name(function() { + try { + activeXDocument = new ActiveXObject("htmlfile"); + } catch (error) { + } + NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument); + var length = enumBugKeys.length; + while (length--) + delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }, "NullProtoObject"); + hiddenKeys[IE_PROTO] = true; + module2.exports = Object.create || /* @__PURE__ */ __name(function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + result[IE_PROTO] = O; + } else + result = NullProtoObject(); + return Properties === void 0 ? result : definePropertiesModule.f(result, Properties); + }, "create"); + } +}); + +// node_modules/core-js/internals/add-to-unscopables.js +var require_add_to_unscopables = __commonJS({ + "node_modules/core-js/internals/add-to-unscopables.js"(exports, module2) { + "use strict"; + var wellKnownSymbol = require_well_known_symbol(); + var create = require_object_create(); + var defineProperty = require_object_define_property().f; + var UNSCOPABLES = wellKnownSymbol("unscopables"); + var ArrayPrototype = Array.prototype; + if (ArrayPrototype[UNSCOPABLES] === void 0) { + defineProperty(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); + } + module2.exports = function(key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + } +}); + +// node_modules/core-js/modules/es.array.to-reversed.js +var require_es_array_to_reversed = __commonJS({ + "node_modules/core-js/modules/es.array.to-reversed.js"() { + "use strict"; + var $ = require_export(); + var arrayToReversed = require_array_to_reversed(); + var toIndexedObject = require_to_indexed_object(); + var addToUnscopables = require_add_to_unscopables(); + var $Array = Array; + $({ target: "Array", proto: true }, { + toReversed: /* @__PURE__ */ __name(function toReversed() { + return arrayToReversed(toIndexedObject(this), $Array); + }, "toReversed") + }); + addToUnscopables("toReversed"); + } +}); + +// node_modules/core-js/internals/entry-unbind.js +var require_entry_unbind = __commonJS({ + "node_modules/core-js/internals/entry-unbind.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + var uncurryThis = require_function_uncurry_this(); + module2.exports = function(CONSTRUCTOR, METHOD) { + return uncurryThis(global2[CONSTRUCTOR].prototype[METHOD]); + }; + } +}); + +// node_modules/core-js/es/array/to-reversed.js +var require_to_reversed = __commonJS({ + "node_modules/core-js/es/array/to-reversed.js"(exports, module2) { + "use strict"; + require_es_array_to_reversed(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "toReversed"); + } +}); + +// node_modules/core-js/stable/array/to-reversed.js +var require_to_reversed2 = __commonJS({ + "node_modules/core-js/stable/array/to-reversed.js"(exports, module2) { + "use strict"; + var parent = require_to_reversed(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.to-reversed.js +var require_esnext_array_to_reversed = __commonJS({ + "node_modules/core-js/modules/esnext.array.to-reversed.js"() { + "use strict"; + require_es_array_to_reversed(); + } +}); + +// node_modules/core-js/actual/array/to-reversed.js +var require_to_reversed3 = __commonJS({ + "node_modules/core-js/actual/array/to-reversed.js"(exports, module2) { + "use strict"; + var parent = require_to_reversed2(); + require_esnext_array_to_reversed(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/delete-property-or-throw.js +var require_delete_property_or_throw = __commonJS({ + "node_modules/core-js/internals/delete-property-or-throw.js"(exports, module2) { + "use strict"; + var tryToString = require_try_to_string(); + var $TypeError = TypeError; + module2.exports = function(O, P) { + if (!delete O[P]) + throw new $TypeError("Cannot delete property " + tryToString(P) + " of " + tryToString(O)); + }; + } +}); + +// node_modules/core-js/internals/to-string-tag-support.js +var require_to_string_tag_support = __commonJS({ + "node_modules/core-js/internals/to-string-tag-support.js"(exports, module2) { + "use strict"; + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var test = {}; + test[TO_STRING_TAG] = "z"; + module2.exports = String(test) === "[object z]"; + } +}); + +// node_modules/core-js/internals/classof.js +var require_classof = __commonJS({ + "node_modules/core-js/internals/classof.js"(exports, module2) { + "use strict"; + var TO_STRING_TAG_SUPPORT = require_to_string_tag_support(); + var isCallable = require_is_callable(); + var classofRaw = require_classof_raw(); + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var $Object = Object; + var CORRECT_ARGUMENTS = classofRaw(/* @__PURE__ */ function() { + return arguments; + }()) === "Arguments"; + var tryGet = /* @__PURE__ */ __name(function(it, key) { + try { + return it[key]; + } catch (error) { + } + }, "tryGet"); + module2.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) { + var O, tag, result; + return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) === "Object" && isCallable(O.callee) ? "Arguments" : result; + }; + } +}); + +// node_modules/core-js/internals/to-string.js +var require_to_string = __commonJS({ + "node_modules/core-js/internals/to-string.js"(exports, module2) { + "use strict"; + var classof = require_classof(); + var $String = String; + module2.exports = function(argument) { + if (classof(argument) === "Symbol") + throw new TypeError("Cannot convert a Symbol value to a string"); + return $String(argument); + }; + } +}); + +// node_modules/core-js/internals/array-slice.js +var require_array_slice = __commonJS({ + "node_modules/core-js/internals/array-slice.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this(); + module2.exports = uncurryThis([].slice); + } +}); + +// node_modules/core-js/internals/array-sort.js +var require_array_sort = __commonJS({ + "node_modules/core-js/internals/array-sort.js"(exports, module2) { + "use strict"; + var arraySlice = require_array_slice(); + var floor = Math.floor; + var sort = /* @__PURE__ */ __name(function(array, comparefn) { + var length = array.length; + if (length < 8) { + var i = 1; + var element, j; + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) + array[j] = element; + } + } else { + var middle = floor(length / 2); + var left = sort(arraySlice(array, 0, middle), comparefn); + var right = sort(arraySlice(array, middle), comparefn); + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = lindex < llength && rindex < rlength ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] : lindex < llength ? left[lindex++] : right[rindex++]; + } + } + return array; + }, "sort"); + module2.exports = sort; + } +}); + +// node_modules/core-js/internals/array-method-is-strict.js +var require_array_method_is_strict = __commonJS({ + "node_modules/core-js/internals/array-method-is-strict.js"(exports, module2) { + "use strict"; + var fails = require_fails(); + module2.exports = function(METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails(function() { + method.call(null, argument || function() { + return 1; + }, 1); + }); + }; + } +}); + +// node_modules/core-js/internals/engine-ff-version.js +var require_engine_ff_version = __commonJS({ + "node_modules/core-js/internals/engine-ff-version.js"(exports, module2) { + "use strict"; + var userAgent = require_engine_user_agent(); + var firefox = userAgent.match(/firefox\/(\d+)/i); + module2.exports = !!firefox && +firefox[1]; + } +}); + +// node_modules/core-js/internals/engine-is-ie-or-edge.js +var require_engine_is_ie_or_edge = __commonJS({ + "node_modules/core-js/internals/engine-is-ie-or-edge.js"(exports, module2) { + "use strict"; + var UA = require_engine_user_agent(); + module2.exports = /MSIE|Trident/.test(UA); + } +}); + +// node_modules/core-js/internals/engine-webkit-version.js +var require_engine_webkit_version = __commonJS({ + "node_modules/core-js/internals/engine-webkit-version.js"(exports, module2) { + "use strict"; + var userAgent = require_engine_user_agent(); + var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + module2.exports = !!webkit && +webkit[1]; + } +}); + +// node_modules/core-js/modules/es.array.sort.js +var require_es_array_sort = __commonJS({ + "node_modules/core-js/modules/es.array.sort.js"() { + "use strict"; + var $ = require_export(); + var uncurryThis = require_function_uncurry_this(); + var aCallable = require_a_callable(); + var toObject = require_to_object(); + var lengthOfArrayLike = require_length_of_array_like(); + var deletePropertyOrThrow = require_delete_property_or_throw(); + var toString = require_to_string(); + var fails = require_fails(); + var internalSort = require_array_sort(); + var arrayMethodIsStrict = require_array_method_is_strict(); + var FF = require_engine_ff_version(); + var IE_OR_EDGE = require_engine_is_ie_or_edge(); + var V8 = require_engine_v8_version(); + var WEBKIT = require_engine_webkit_version(); + var test = []; + var nativeSort = uncurryThis(test.sort); + var push = uncurryThis(test.push); + var FAILS_ON_UNDEFINED = fails(function() { + test.sort(void 0); + }); + var FAILS_ON_NULL = fails(function() { + test.sort(null); + }); + var STRICT_METHOD = arrayMethodIsStrict("sort"); + var STABLE_SORT = !fails(function() { + if (V8) + return V8 < 70; + if (FF && FF > 3) + return; + if (IE_OR_EDGE) + return true; + if (WEBKIT) + return WEBKIT < 603; + var result = ""; + var code, chr, value, index; + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + switch (code) { + case 66: + case 69: + case 70: + case 72: + value = 3; + break; + case 68: + case 71: + value = 4; + break; + default: + value = 2; + } + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + test.sort(function(a, b) { + return b.v - a.v; + }); + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) + result += chr; + } + return result !== "DGBEFHACIJK"; + }); + var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT; + var getSortCompare = /* @__PURE__ */ __name(function(comparefn) { + return function(x, y) { + if (y === void 0) + return -1; + if (x === void 0) + return 1; + if (comparefn !== void 0) + return +comparefn(x, y) || 0; + return toString(x) > toString(y) ? 1 : -1; + }; + }, "getSortCompare"); + $({ target: "Array", proto: true, forced: FORCED }, { + sort: /* @__PURE__ */ __name(function sort(comparefn) { + if (comparefn !== void 0) + aCallable(comparefn); + var array = toObject(this); + if (STABLE_SORT) + return comparefn === void 0 ? nativeSort(array) : nativeSort(array, comparefn); + var items = []; + var arrayLength = lengthOfArrayLike(array); + var itemsLength, index; + for (index = 0; index < arrayLength; index++) { + if (index in array) + push(items, array[index]); + } + internalSort(items, getSortCompare(comparefn)); + itemsLength = lengthOfArrayLike(items); + index = 0; + while (index < itemsLength) + array[index] = items[index++]; + while (index < arrayLength) + deletePropertyOrThrow(array, index++); + return array; + }, "sort") + }); + } +}); + +// node_modules/core-js/internals/array-from-constructor-and-list.js +var require_array_from_constructor_and_list = __commonJS({ + "node_modules/core-js/internals/array-from-constructor-and-list.js"(exports, module2) { + "use strict"; + var lengthOfArrayLike = require_length_of_array_like(); + module2.exports = function(Constructor, list, $length) { + var index = 0; + var length = arguments.length > 2 ? $length : lengthOfArrayLike(list); + var result = new Constructor(length); + while (length > index) + result[index] = list[index++]; + return result; + }; + } +}); + +// node_modules/core-js/internals/get-built-in-prototype-method.js +var require_get_built_in_prototype_method = __commonJS({ + "node_modules/core-js/internals/get-built-in-prototype-method.js"(exports, module2) { + "use strict"; + var global2 = require_global(); + module2.exports = function(CONSTRUCTOR, METHOD) { + var Constructor = global2[CONSTRUCTOR]; + var Prototype = Constructor && Constructor.prototype; + return Prototype && Prototype[METHOD]; + }; + } +}); + +// node_modules/core-js/modules/es.array.to-sorted.js +var require_es_array_to_sorted = __commonJS({ + "node_modules/core-js/modules/es.array.to-sorted.js"() { + "use strict"; + var $ = require_export(); + var uncurryThis = require_function_uncurry_this(); + var aCallable = require_a_callable(); + var toIndexedObject = require_to_indexed_object(); + var arrayFromConstructorAndList = require_array_from_constructor_and_list(); + var getBuiltInPrototypeMethod = require_get_built_in_prototype_method(); + var addToUnscopables = require_add_to_unscopables(); + var $Array = Array; + var sort = uncurryThis(getBuiltInPrototypeMethod("Array", "sort")); + $({ target: "Array", proto: true }, { + toSorted: /* @__PURE__ */ __name(function toSorted(compareFn) { + if (compareFn !== void 0) + aCallable(compareFn); + var O = toIndexedObject(this); + var A = arrayFromConstructorAndList($Array, O); + return sort(A, compareFn); + }, "toSorted") + }); + addToUnscopables("toSorted"); + } +}); + +// node_modules/core-js/es/array/to-sorted.js +var require_to_sorted = __commonJS({ + "node_modules/core-js/es/array/to-sorted.js"(exports, module2) { + "use strict"; + require_es_array_sort(); + require_es_array_to_sorted(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "toSorted"); + } +}); + +// node_modules/core-js/stable/array/to-sorted.js +var require_to_sorted2 = __commonJS({ + "node_modules/core-js/stable/array/to-sorted.js"(exports, module2) { + "use strict"; + var parent = require_to_sorted(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.to-sorted.js +var require_esnext_array_to_sorted = __commonJS({ + "node_modules/core-js/modules/esnext.array.to-sorted.js"() { + "use strict"; + require_es_array_to_sorted(); + } +}); + +// node_modules/core-js/actual/array/to-sorted.js +var require_to_sorted3 = __commonJS({ + "node_modules/core-js/actual/array/to-sorted.js"(exports, module2) { + "use strict"; + var parent = require_to_sorted2(); + require_esnext_array_to_sorted(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/does-not-exceed-safe-integer.js +var require_does_not_exceed_safe_integer = __commonJS({ + "node_modules/core-js/internals/does-not-exceed-safe-integer.js"(exports, module2) { + "use strict"; + var $TypeError = TypeError; + var MAX_SAFE_INTEGER = 9007199254740991; + module2.exports = function(it) { + if (it > MAX_SAFE_INTEGER) + throw $TypeError("Maximum allowed index exceeded"); + return it; + }; + } +}); + +// node_modules/core-js/modules/es.array.to-spliced.js +var require_es_array_to_spliced = __commonJS({ + "node_modules/core-js/modules/es.array.to-spliced.js"() { + "use strict"; + var $ = require_export(); + var addToUnscopables = require_add_to_unscopables(); + var doesNotExceedSafeInteger = require_does_not_exceed_safe_integer(); + var lengthOfArrayLike = require_length_of_array_like(); + var toAbsoluteIndex = require_to_absolute_index(); + var toIndexedObject = require_to_indexed_object(); + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var $Array = Array; + var max = Math.max; + var min = Math.min; + $({ target: "Array", proto: true }, { + toSpliced: /* @__PURE__ */ __name(function toSpliced(start, deleteCount) { + var O = toIndexedObject(this); + var len = lengthOfArrayLike(O); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var k = 0; + var insertCount, actualDeleteCount, newLen, A; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart); + } + newLen = doesNotExceedSafeInteger(len + insertCount - actualDeleteCount); + A = $Array(newLen); + for (; k < actualStart; k++) + A[k] = O[k]; + for (; k < actualStart + insertCount; k++) + A[k] = arguments[k - actualStart + 2]; + for (; k < newLen; k++) + A[k] = O[k + actualDeleteCount - insertCount]; + return A; + }, "toSpliced") + }); + addToUnscopables("toSpliced"); + } +}); + +// node_modules/core-js/es/array/to-spliced.js +var require_to_spliced = __commonJS({ + "node_modules/core-js/es/array/to-spliced.js"(exports, module2) { + "use strict"; + require_es_array_to_spliced(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "toSpliced"); + } +}); + +// node_modules/core-js/stable/array/to-spliced.js +var require_to_spliced2 = __commonJS({ + "node_modules/core-js/stable/array/to-spliced.js"(exports, module2) { + "use strict"; + var parent = require_to_spliced(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.to-spliced.js +var require_esnext_array_to_spliced = __commonJS({ + "node_modules/core-js/modules/esnext.array.to-spliced.js"() { + "use strict"; + require_es_array_to_spliced(); + } +}); + +// node_modules/core-js/actual/array/to-spliced.js +var require_to_spliced3 = __commonJS({ + "node_modules/core-js/actual/array/to-spliced.js"(exports, module2) { + "use strict"; + var parent = require_to_spliced2(); + require_esnext_array_to_spliced(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/function-uncurry-this-clause.js +var require_function_uncurry_this_clause = __commonJS({ + "node_modules/core-js/internals/function-uncurry-this-clause.js"(exports, module2) { + "use strict"; + var classofRaw = require_classof_raw(); + var uncurryThis = require_function_uncurry_this(); + module2.exports = function(fn) { + if (classofRaw(fn) === "Function") + return uncurryThis(fn); + }; + } +}); + +// node_modules/core-js/internals/function-bind-context.js +var require_function_bind_context = __commonJS({ + "node_modules/core-js/internals/function-bind-context.js"(exports, module2) { + "use strict"; + var uncurryThis = require_function_uncurry_this_clause(); + var aCallable = require_a_callable(); + var NATIVE_BIND = require_function_bind_native(); + var bind = uncurryThis(uncurryThis.bind); + module2.exports = function(fn, that) { + aCallable(fn); + return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() { + return fn.apply(that, arguments); + }; + }; + } +}); + +// node_modules/core-js/internals/array-iteration-from-last.js +var require_array_iteration_from_last = __commonJS({ + "node_modules/core-js/internals/array-iteration-from-last.js"(exports, module2) { + "use strict"; + var bind = require_function_bind_context(); + var IndexedObject = require_indexed_object(); + var toObject = require_to_object(); + var lengthOfArrayLike = require_length_of_array_like(); + var createMethod = /* @__PURE__ */ __name(function(TYPE) { + var IS_FIND_LAST_INDEX = TYPE === 1; + return function($this, callbackfn, that) { + var O = toObject($this); + var self2 = IndexedObject(O); + var index = lengthOfArrayLike(self2); + var boundFunction = bind(callbackfn, that); + var value, result; + while (index-- > 0) { + value = self2[index]; + result = boundFunction(value, index, O); + if (result) + switch (TYPE) { + case 0: + return value; + case 1: + return index; + } + } + return IS_FIND_LAST_INDEX ? -1 : void 0; + }; + }, "createMethod"); + module2.exports = { + // `Array.prototype.findLast` method + // https://github.com/tc39/proposal-array-find-from-last + findLast: createMethod(0), + // `Array.prototype.findLastIndex` method + // https://github.com/tc39/proposal-array-find-from-last + findLastIndex: createMethod(1) + }; + } +}); + +// node_modules/core-js/modules/es.array.find-last-index.js +var require_es_array_find_last_index = __commonJS({ + "node_modules/core-js/modules/es.array.find-last-index.js"() { + "use strict"; + var $ = require_export(); + var $findLastIndex = require_array_iteration_from_last().findLastIndex; + var addToUnscopables = require_add_to_unscopables(); + $({ target: "Array", proto: true }, { + findLastIndex: /* @__PURE__ */ __name(function findLastIndex(callbackfn) { + return $findLastIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : void 0); + }, "findLastIndex") + }); + addToUnscopables("findLastIndex"); + } +}); + +// node_modules/core-js/modules/esnext.array.find-last-index.js +var require_esnext_array_find_last_index = __commonJS({ + "node_modules/core-js/modules/esnext.array.find-last-index.js"() { + "use strict"; + require_es_array_find_last_index(); + } +}); + +// node_modules/core-js/es/array/find-last-index.js +var require_find_last_index = __commonJS({ + "node_modules/core-js/es/array/find-last-index.js"(exports, module2) { + "use strict"; + require_es_array_find_last_index(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "findLastIndex"); + } +}); + +// node_modules/core-js/stable/array/find-last-index.js +var require_find_last_index2 = __commonJS({ + "node_modules/core-js/stable/array/find-last-index.js"(exports, module2) { + "use strict"; + module2.exports = require_find_last_index(); + } +}); + +// node_modules/core-js/actual/array/find-last-index.js +var require_find_last_index3 = __commonJS({ + "node_modules/core-js/actual/array/find-last-index.js"(exports, module2) { + "use strict"; + require_esnext_array_find_last_index(); + var parent = require_find_last_index2(); + module2.exports = parent; + } +}); + +// node_modules/core-js/internals/array-with.js +var require_array_with = __commonJS({ + "node_modules/core-js/internals/array-with.js"(exports, module2) { + "use strict"; + var lengthOfArrayLike = require_length_of_array_like(); + var toIntegerOrInfinity = require_to_integer_or_infinity(); + var $RangeError = RangeError; + module2.exports = function(O, C, index, value) { + var len = lengthOfArrayLike(O); + var relativeIndex = toIntegerOrInfinity(index); + var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex; + if (actualIndex >= len || actualIndex < 0) + throw new $RangeError("Incorrect index"); + var A = new C(len); + var k = 0; + for (; k < len; k++) + A[k] = k === actualIndex ? value : O[k]; + return A; + }; + } +}); + +// node_modules/core-js/modules/es.array.with.js +var require_es_array_with = __commonJS({ + "node_modules/core-js/modules/es.array.with.js"() { + "use strict"; + var $ = require_export(); + var arrayWith = require_array_with(); + var toIndexedObject = require_to_indexed_object(); + var $Array = Array; + $({ target: "Array", proto: true }, { + "with": function(index, value) { + return arrayWith(toIndexedObject(this), $Array, index, value); + } + }); + } +}); + +// node_modules/core-js/es/array/with.js +var require_with = __commonJS({ + "node_modules/core-js/es/array/with.js"(exports, module2) { + "use strict"; + require_es_array_with(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("Array", "with"); + } +}); + +// node_modules/core-js/stable/array/with.js +var require_with2 = __commonJS({ + "node_modules/core-js/stable/array/with.js"(exports, module2) { + "use strict"; + var parent = require_with(); + module2.exports = parent; + } +}); + +// node_modules/core-js/modules/esnext.array.with.js +var require_esnext_array_with = __commonJS({ + "node_modules/core-js/modules/esnext.array.with.js"() { + "use strict"; + require_es_array_with(); + } +}); + +// node_modules/core-js/actual/array/with.js +var require_with3 = __commonJS({ + "node_modules/core-js/actual/array/with.js"(exports, module2) { + "use strict"; + var parent = require_with2(); + require_esnext_array_with(); + module2.exports = parent; + } +}); + +// stringList.js +var stringList_exports = {}; +__export(stringList_exports, { + sl: () => sl, + stringList: () => stringList +}); +module.exports = __toCommonJS(stringList_exports); + +// StringLiteralList.js +var import_to_reversed = __toESM(require_to_reversed3(), 1); +var import_to_sorted = __toESM(require_to_sorted3(), 1); +var import_to_spliced = __toESM(require_to_spliced3(), 1); +var import_find_last_index = __toESM(require_find_last_index3(), 1); +var import_with = __toESM(require_with3(), 1); +var SeparatorsRegexp = /[[|\]{}()\\/\-_\\ .,\]]+/g; +var freezeIfImmutable = /* @__PURE__ */ __name((source, target) => { + if (source && target && Object.isFrozen(source)) { + return Object.freeze(target); + } + return target; +}, "freezeIfImmutable"); +var SL = class _SL extends Array { + static { + __name(this, "SL"); + } + infered = { + Union: void 0, + Tuple: void 0, + Mutable: void 0, + Unsorted: void 0 + }; + enum; + hasEmpty = false; + constructor(...args) { + const entries = []; + const arr = []; + let emptyFound = false; + for (const str of args.flat()) { + if (typeof str === "string") { + if (str === "") { + emptyFound = true; + } + entries.push([str, str]); + arr.push(str); + } + } + super(...arr); + this.hasEmpty = emptyFound; + this.enum = Object.fromEntries(entries); + if (this.hasEmpty) { + this.enum[""] = ""; + } + Object.freeze(this.enum); + } + concat(...args) { + return freezeIfImmutable( + this, + new _SL(...super.concat.apply(this, args.flat())) + ); + } + concatList(list) { + return this.concat(...list); + } + toSorted() { + return freezeIfImmutable( + this, + new _SL(...super.toSorted.apply(this, arguments)) + ); + } + toReversed() { + return freezeIfImmutable( + this, + new _SL(...super.toReversed.apply(this, arguments)) + ); + } + reverse() { + return freezeIfImmutable( + this, + new _SL(...super.reverse.apply(this, arguments)) + ); + } + toSpliced() { + return freezeIfImmutable( + this, + new _SL(...super.toSpliced.apply(this, arguments)) + ); + } + slice() { + return freezeIfImmutable( + this, + new _SL(...super.slice.apply(this, arguments)) + ); + } + without() { + const values = Array.from(arguments).flatMap( + (el) => Array.isArray(el) ? el.filter((s) => typeof s === "string") : typeof el === "string" ? [el] : [] + ); + return freezeIfImmutable( + this, + new _SL(...this.filter((e) => !values.includes(e))) + ); + } + withTrim() { + return freezeIfImmutable(this, new _SL(...super.map((e) => e.trim()))); + } + withPrefix(prefix = "") { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => `${prefix}${e}`)) + ); + } + withSuffix(suffix = "") { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => `${e}${suffix}`)) + ); + } + // withDerivatedSuffix(chars = '') { + // return freezeIfImmutable( + // this, + // new SL( + // ...super.flatMap((t) => [ + // t, + // t.endsWith(chars) + // ? t.slice(0, Math.min(t.length, chars.length) * -1) + // : `${t}${chars}`, + // ]), + // ), + // ); + // } + // withDerivatedPrefix(chars = '') { + // return freezeIfImmutable( + // this, + // new SL( + // ...super.flatMap((t) => [ + // t, + // t.startsWith(chars) + // ? t.slice(Math.min(chars.length, t.length), t.length) + // : `${chars}${t}`, + // ]), + // ), + // ); + // } + withReplace(string, replacement = void 0) { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.replace(string, replacement))) + ); + } + withReplaceAll(string, replacement = void 0) { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.replaceAll(string, replacement))) + ); + } + toLowerCase() { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.toLowerCase())) + ); + } + toUpperCase() { + return freezeIfImmutable( + this, + new _SL(...super.map((e) => e.toUpperCase())) + ); + } + toCapitalize() { + return this.withReplace(/\b\w/g, (char) => char.toUpperCase()); + } + toUnCapitalize() { + return this.withReplace(/\b\w/g, (char) => char.toLowerCase()); + } + toPascalCase() { + return freezeIfImmutable( + this, + new _SL( + ...super.map( + (e) => e.trim().replace(SeparatorsRegexp, "_").replace(/[^a-z0-9_]+/gi, "").replace(/[_]+/g, "_").replace(/(?:^|_)(\w)/g, (_, char) => char.toUpperCase()).replace(/[\s_]+/g, "").trim() + ) + ) + ).toCapitalize(); + } + toCamelCase() { + return this.withPrefix("_").toPascalCase().toUnCapitalize(); + } + toSnakeCase() { + return freezeIfImmutable( + this, + new _SL( + ...super.map( + (e) => e.trim().replace(SeparatorsRegexp, "_").replace(/[^a-z0-9_]+/gi, "").replace(/([A-Z])/g, (_, char) => `_${char.toLowerCase()}`).replace(/[\s_]+/g, "_").replace(/^[_]+/g, "").toLowerCase().trim() + ) + ) + ); + } + value(value) { + if (typeof value === "string" && (this.enum[value] || this.hasEmpty && value === "")) { + return value; + } + throw new Error(`Invalid value ${value}`); + } + // Get the native array + mutable() { + return Array.from(this); + } + toRecordValue(initialValue = void 0, ...records) { + return Object.assign( + {}, + ...records, + Object.fromEntries(super.map((e) => [e, initialValue])) + ); + } + toRecordType(type = "any", initialValue = void 0, ...records) { + return Object.assign( + {}, + ...records, + Object.fromEntries(super.map((e) => [e, initialValue])) + ); + } + // Methods returning the native array + map() { + const mut = this.mutable(); + return mut.map.apply(mut, arguments); + } + filter() { + const mut = this.mutable(); + return mut.filter.apply(mut, arguments); + } + reduce() { + const mut = this.mutable(); + return mut.reduce.apply(mut, arguments); + } + reduceRight() { + const mut = this.mutable(); + return mut.reduceRight.apply(mut, arguments); + } + flat() { + const mut = this.mutable(); + return mut.flat.apply(mut, arguments); + } + flatMap() { + const mut = this.mutable(); + return mut.flatMap.apply(mut, arguments); + } + with() { + const mut = this.mutable(); + return mut.with.apply(mut, arguments); + } +}; +var ARRAY_IN_PLACE_MUTATION = Object.freeze({ + push: "push", + unshift: "unshift", + shift: "shift", + copyWithin: "copyWithin", + pop: "pop", + fill: "fill", + splice: "splice" +}); + +// stringListFunction.js +function stringListMutable(...strings) { + let values = strings; + let invalid = strings.some((el) => typeof el !== "string"); + if (strings.length && invalid) { + if (typeof window === "undefined" && true && true) { + console.debug( + `Unexpected type in stringList(${typeof invalid}). Casting all arguments to string type.` + ); + } + values = strings.flatMap( + (el) => Array.isArray(el) ? el.filter((s) => typeof s === "string") : typeof el === "string" ? [el] : typeof el === "number" ? [String(el)] : [] + ); + } + return new SL(...values); +} +__name(stringListMutable, "stringListMutable"); + +// stringList.js +var stringList = stringListMutable; +var sl = stringListMutable; diff --git a/stringList.test.js b/stringList.test.js index d969fd8..19725dc 100644 --- a/stringList.test.js +++ b/stringList.test.js @@ -3,11 +3,20 @@ import t from 'tap'; import { ARRAY_IN_PLACE_MUTATION, SL } from './StringLiteralList.js'; - import { stringList as mutableStringList, sl } from './stringList.js'; + import { stringList as immutableStringList } from './strict.js'; -import { stringListMutable } from './stringListFunction.js'; +// import { createRequire } from 'module'; +// const require = createRequire(import.meta.url); +// /** @type {typeof import('./stringList.js')['sl']} */ +// const mutableStringListCjs = require('./' + 'stringList.cjs').stringList; +// /** @type {typeof import('./strict.js')['sl']} */ +// const immutableStringListCjs = require('./' + 'strict.cjs').stringList; + +/** + * @type {{type:string, stringList:typeof import('./stringList.js').stringList}[]} + */ const functions = [ { type: 'mutable', @@ -17,6 +26,14 @@ const functions = [ type: 'immutable', stringList: immutableStringList, }, + // { + // type: 'mutableCjs', + // stringList: mutableStringListCjs, + // }, + // { + // type: 'immutableCjs', + // stringList: immutableStringListCjs, + // }, ]; for (const { type, stringList } of functions) { @@ -299,72 +316,72 @@ for (const { type, stringList } of functions) { t.end(); }); - t.test(type + ": withDerivatedSuffix('s')", (t) => { - const list = stringList('food', 'bars', 'pasta', 'meatballs') - .withDerivatedSuffix('s') - .toSorted((a, b) => a.localeCompare(b)); - - testExpectedArrayValues( - t, - list, - 'bar', - 'bars', - 'food', - 'foods', - 'meatball', - 'meatballs', - 'pasta', - 'pastas', - ); - testEscapingFromStringList( - t, - list, - 'bar', - 'bars', - 'food', - 'foods', - 'meatball', - 'meatballs', - 'pasta', - 'pastas', - ); - - /** @type {'bar::bars::food::foods::meatball::meatballs::pasta::pastas'} */ - // @ts-expect-error - Unsorted list - infer string - const d = list.join('::'); - t.match(d, 'bar::bars::food::foods::meatball::meatballs::pasta::pastas'); - - t.end(); - }); - - t.test(type + ": withDerivatedPrefix('#')", (t) => { - const list = stringList('#trending', 'stuff') - .withDerivatedPrefix('#') - .toSorted((a, b) => a.localeCompare(b)); - testExpectedArrayValues( - t, - list, - '#stuff', - '#trending', - 'stuff', - 'trending', - ); - testEscapingFromStringList( - t, - list, - '#stuff', - '#trending', - 'stuff', - 'trending', - ); - - /** @type {'#stuff::#trending::stuff::trending'} */ - // @ts-expect-error - Unsorted list - infer string - const d = list.join('::'); - t.match(d, '#stuff::#trending::stuff::trending'); - - t.end(); - }); + // t.test(type + ": withDerivatedSuffix('s')", (t) => { + // const list = stringList('food', 'bars', 'pasta', 'meatballs') + // .withDerivatedSuffix('s') + // .toSorted((a, b) => a.localeCompare(b)); + + // testExpectedArrayValues( + // t, + // list, + // 'bar', + // 'bars', + // 'food', + // 'foods', + // 'meatball', + // 'meatballs', + // 'pasta', + // 'pastas', + // ); + // testEscapingFromStringList( + // t, + // list, + // 'bar', + // 'bars', + // 'food', + // 'foods', + // 'meatball', + // 'meatballs', + // 'pasta', + // 'pastas', + // ); + + // /** @type {'bar::bars::food::foods::meatball::meatballs::pasta::pastas'} */ + // // @ts-expect-error - Unsorted list - infer string + // const d = list.join('::'); + // t.match(d, 'bar::bars::food::foods::meatball::meatballs::pasta::pastas'); + + // t.end(); + // }); + + // t.test(type + ": withDerivatedPrefix('#')", (t) => { + // const list = stringList('#trending', 'stuff') + // .withDerivatedPrefix('#') + // .toSorted((a, b) => a.localeCompare(b)); + // testExpectedArrayValues( + // t, + // list, + // '#stuff', + // '#trending', + // 'stuff', + // 'trending', + // ); + // testEscapingFromStringList( + // t, + // list, + // '#stuff', + // '#trending', + // 'stuff', + // 'trending', + // ); + + // /** @type {'#stuff::#trending::stuff::trending'} */ + // // @ts-expect-error - Unsorted list - infer string + // const d = list.join('::'); + // t.match(d, '#stuff::#trending::stuff::trending'); + + // t.end(); + // }); t.test(type + ': withReplace("1")', (t) => { const list = stringList('f1oo', 'b1ar').withReplace('1', ''); @@ -628,7 +645,7 @@ for (const { type, stringList } of functions) { }); t.test(type + ': reverse()', (t) => { - if (type === 'immutable') { + if (type === 'immutable' || type === 'immutableCjs') { t.throws(() => { stringList('foo', 'bar').reverse(); }); @@ -924,7 +941,7 @@ for (const { type, stringList } of functions) { t.end(); return; } - if (type === 'immutable') { + if (type === 'immutable' || type === 'immutableCjs') { t.throws( () => // @ts-expect-error diff --git a/types/list.d.ts b/types/list.d.ts index 32910d0..b82248e 100644 --- a/types/list.d.ts +++ b/types/list.d.ts @@ -76,27 +76,27 @@ export interface IStringList< : never : never; - withDerivatedSuffix( - chars: S, - ): - | T - | sl.string.DropSuffix< - sl.string.DropSuffix<`${T}${S}${S}`, S>, - `${S}${S}` - > extends infer W extends string - ? MaybeReadonly> - : never; - - withDerivatedPrefix( - chars: S, - ): - | T - | sl.string.DropPrefix< - sl.string.DropPrefix<`${S}${S}${T}`, S>, - `${S}${S}` - > extends infer W extends string - ? MaybeReadonly> - : never; + // withDerivatedSuffix( + // chars: S, + // ): + // | T + // | sl.string.DropSuffix< + // sl.string.DropSuffix<`${T}${S}${S}`, S>, + // `${S}${S}` + // > extends infer W extends string + // ? MaybeReadonly> + // : never; + + // withDerivatedPrefix( + // chars: S, + // ): + // | T + // | sl.string.DropPrefix< + // sl.string.DropPrefix<`${S}${S}${T}`, S>, + // `${S}${S}` + // > extends infer W extends string + // ? MaybeReadonly> + // : never; withReplace( searchValue: S,