diff --git a/.commitlintrc.js b/.commitlintrc.js deleted file mode 100644 index e7e5f387f..000000000 --- a/.commitlintrc.js +++ /dev/null @@ -1,35 +0,0 @@ -export default { - rules: { - 'body-leading-blank': [1, 'always'], - 'footer-leading-blank': [0, 'always'], - 'header-max-length': [2, 'always', 100], - 'scope-case': [2, 'always', 'lower-case'], - - 'subject-case': [ - 2, - 'never', - ['sentence-case', 'start-case', 'pascal-case', 'upper-case'] - ], - 'subject-empty': [2, 'never'], - 'subject-full-stop': [2, 'never', '.'], - 'type-case': [0, 'always', 'lower-case'], - 'type-empty': [2, 'never'], - 'type-enum': [ - 2, - 'always', - [ - 'feat', - 'fix', - 'docs', - 'style', - 'refactor', - 'perf', - 'test', - 'chore', - 'revert', - 'build', - 'WIP' - ] - ] - } -}; \ No newline at end of file diff --git a/.editorconfig b/.editorconfig deleted file mode 100644 index 720f1c139..000000000 --- a/.editorconfig +++ /dev/null @@ -1,10 +0,0 @@ -root = true - -[*.{js,css,scss}] -charset = utf-8 -end_of_line = lf -indent_size = 2 -indent_style = space -insert_final_newline = true -trim_trailing_whitespace = true -max_line_length = 100 diff --git a/.eslintignore b/.eslintignore deleted file mode 100644 index 391a7b66b..000000000 --- a/.eslintignore +++ /dev/null @@ -1,14 +0,0 @@ -build/*.js -config/*.js -dist-docs/ -dist/ -test/ - -node_modules/ - -backstop_data/html_report/ -src/**/__tests__/*.spec.js -src/**/dist/*.js -src/**/examples/ - -src/components/icon/comps/* \ No newline at end of file diff --git a/.eslintrc b/.eslintrc deleted file mode 100644 index 4d22730fc..000000000 --- a/.eslintrc +++ /dev/null @@ -1,29 +0,0 @@ -{ - "root": true, - "parser": "vue-eslint-parser", - "parserOptions": { - "sourceType": "module", - "parser": "@typescript-eslint/parser" - }, - "env": { - "browser": true - }, - "extends": [ - "plugin:vue/strongly-recommended", - "eslint:recommended", - "@vue/typescript/recommended" - ], - "rules": { - "no-use-before-define": 0, - "vue/require-default-prop": 0, - "vue/attributes-order": 0, - "vue/no-multiple-template-root": 0, - "max-len": ["error", { - "code": 100, - "ignoreComments": true, - "ignoreTrailingComments": true - }], - "vue/multiline-html-element-content-newline": 0, - "@typescript-eslint/no-explicit-any": 0 - } -} diff --git a/.gitignore b/.gitignore deleted file mode 100644 index a8eb433ad..000000000 --- a/.gitignore +++ /dev/null @@ -1,55 +0,0 @@ -# Numerous always-ignore extensions -*.diff -*.err -*.log -*.orig -*.rej -*.swo -*.swp -*.vi -*.zip -*~ - -# OS or Editor folders -._* -.cache -.DS_Store -.idea -*.iml -.classpath -.metadata -.project -.settings -.tmproj -*.esproj -*.sublime-project -*.sublime-workspace -nbproject -Thumbs.db -.vscode -jsconfig.json - -# Folders to ignore -node_modules -dist-docs -dist - -# Test results -.nyc_output -backstop_data/bitmaps_reference -backstop_data/bitmaps_backup -backstop_data/bitmaps_test -backstop_data/html_report -test/e2e/reports -test/unit/coverage -coverage/ - -# Build assets -**/dist/* -src/**/styles/themes/* - -src/**/package-lock\.json -unmigrated/ - -## Dev output for hosting -pages \ No newline at end of file diff --git a/.nvmrc b/.nvmrc deleted file mode 100644 index 2edeafb09..000000000 --- a/.nvmrc +++ /dev/null @@ -1 +0,0 @@ -20 \ No newline at end of file diff --git a/.prettierrc.json b/.prettierrc.json deleted file mode 100644 index 51878cea5..000000000 --- a/.prettierrc.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "printWidth": 100, - "tabWidth": 2, - "useTabs": false, - "semi": true, - "singleQuote": true, - "quoteProps": "as-needed", - "jsxSingleQuote": false, - "trailingComma": "all", - "bracketSpacing": true, - "bracketSameLine": false, - "arrowParens": "always", - "proseWrap": "preserve", - "htmlWhitespaceSensitivity": "ignore", - "vueIndentScriptAndStyle": false, - "endOfLine": "auto", - "singleAttributePerLine": true -} diff --git a/.stylelintignore b/.stylelintignore deleted file mode 100644 index d734ef1b0..000000000 --- a/.stylelintignore +++ /dev/null @@ -1,14 +0,0 @@ -# built files -public/ -dist/ -dist-docs/ -backstop_data/ - -node_modules/ - -src/css/settings/brandai.pcss -*.md -*.js -*.svg -*.json -*.bak diff --git a/.stylelintrc b/.stylelintrc deleted file mode 100644 index 1101ec33b..000000000 --- a/.stylelintrc +++ /dev/null @@ -1,19 +0,0 @@ -{ - "extends": "stylelint-config-recommended-scss", - "ignoreFiles": [ - "**/*.js", - "**/*.snap", - "**/*.vars.pcss" - ], - "plugins": [ - "stylelint-scss" - ], - "rules": { - "at-rule-disallowed-list": ["debug"], - "no-empty-source": null, - "no-descending-specificity": null, - "selector-pseudo-class-no-unknown": [true, { - "ignorePseudoClasses": ["global"] - }] - } -} \ No newline at end of file diff --git a/LICENSE b/LICENSE deleted file mode 100644 index d582ada5b..000000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2016 Recreational Equipment, Inc. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/README.md b/README.md deleted file mode 100644 index b145ac455..000000000 --- a/README.md +++ /dev/null @@ -1,64 +0,0 @@ -# REI Cedar Style Framework! -[![codecov](https://codecov.io/gh/rei/rei-cedar/branch/master/graph/badge.svg)](https://codecov.io/gh/rei/rei-cedar) -[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/) - - -Welcome to REI's style framework! The overall goals of this project are to provide a common scaffolding for UI elements, -and a set of themes that build on this scaffolding. We started this project in 2015 as a fork of -[Bootstrap](http://getbootstrap.com/). -The project has evolved into what it is today, and will continue to grow to fit our expanding needs. Feel free to watch -the Cedar grow and learn from what we are doing, or jump in and provide some recommendations. - -## Using Cedar - -See the [Cedar docs](https://cedar.rei.com) for usage instructions. - -## Getting Started - -### Install - -Clone the project. - -`npm install` - -### Run - -`npm run dev` - -Runs locally for development. Has hot reloading, and other nice things related to development. - -## Testing - -### Code Tests - -`npm run unit` - -Runs unit tests. - -`npm run watch` - -Runs unit tests in watch mode. This also allows you to inspect snapshot discrepancies and regenerate the snapshots if appropriate. - -`npm run e2e` - -Runs [Nightwatch](http://nightwatchjs.org/) end-to-end tests and Axe a11y tests. - -Tests run using Chromedriver. To upgrade Chromedriver, determine the latest version of Chrome and Puppeteer that are compatible by visiting [this](https://pptr.dev/supported-browsers) page. - -`npm run test` - -Runs both unit and e2e/accessibility tests. - -## Publishing Prerelease Components - -`npm run prerelease` - -Publishes package to npm with a prerelease tag. You must increment the component's version manually prior to publishing. `--dry-run` flag will run the prerelease process without publishing to npm. - -## Commits - -This project is Commitizen friendly. To install: `npm install -g commitizen` -When creating a pull request run `git cz` rather than `git commit` and follow the prompts. - -This projects Changelogs are generated. -- Generate the Changelog: `npm run changelog` diff --git a/browserTargets.mjs b/browserTargets.mjs deleted file mode 100644 index e9e194f55..000000000 --- a/browserTargets.mjs +++ /dev/null @@ -1,7 +0,0 @@ -export default [ - 'Chrome >= 111', - 'Firefox >= 121', - 'iOS >= 15.6', - 'Safari >= 15.6', - 'Edge >= 120', -]; \ No newline at end of file diff --git a/build/component-variables-transfer.js b/build/component-variables-transfer.js deleted file mode 100644 index 0e274ea8f..000000000 --- a/build/component-variables-transfer.js +++ /dev/null @@ -1,49 +0,0 @@ -const path = require('path'); -const fs = require('fs-extra'); -const glob = require('glob'); - -const DEST_REPO_NAME = 'rei-cedar-component-variables'; -const DEST_PATH = 'dist/scss'; -const SUPPORTED_COMPONENTS = [ - /* global vars */ - 'options.vars.scss', - /* component vars */ - 'CdrButton.vars.scss', - 'CdrCard.vars.scss', - 'CdrChip.vars.scss', - 'CdrBreadcrumb.vars.scss', - 'CdrFormGroup.vars.scss', - 'CdrFormError.vars.scss', - 'CdrGrid.vars.scss', - 'CdrLabelStandalone.vars.scss', - 'CdrLabelWrapper.vars.scss', - 'CdrRadio.vars.scss', - 'CdrCheckbox.vars.scss', - 'CdrLink.vars.scss', - 'CdrInput.vars.scss', - 'CdrSelect.vars.scss', - 'CdrSkeleton.vars.scss', - 'CdrList.vars.scss', - 'CdrTable.vars.scss' -]; - -const destMixinsDir = path.join(__dirname, `../../${DEST_REPO_NAME + path.sep + DEST_PATH}`); - -// get vars files -const files = glob.sync('./**/*.vars.scss', { ignore: ['../**/node_modules/**'] }); - -// copy vars files -files.forEach((f) => { - const fname = path.basename(f).replace(/^_/, ''); // remove `_` prefix from global vars files - if (!SUPPORTED_COMPONENTS.includes(fname)) return console.log(`skipping ${fname}`); - const outDest = `${destMixinsDir}/${fname}`; - fs.copySync(f, outDest); - console.log(`copied ${fname} to ${outDest}`) -}); - -/* iterate over SUPPORTED_COMPONENTS to ensure that vars are loaded in correct order */ -const indexFile = SUPPORTED_COMPONENTS.map(fname => `@import "./${fname}";`).join('\n'); -const singleFile = SUPPORTED_COMPONENTS.map(fname => fs.readFileSync(`${destMixinsDir}/${fname}`, 'utf8')).join('\n'); - -fs.outputFileSync(`${destMixinsDir}/index.scss`, indexFile); -fs.outputFileSync(`${destMixinsDir}/cedar-component-variables.scss`, singleFile); diff --git a/build/copy-css.js b/build/copy-css.js deleted file mode 100644 index 33183733b..000000000 --- a/build/copy-css.js +++ /dev/null @@ -1,12 +0,0 @@ -// Copy cdr-fonts and cdr-reset to root folder. -// Cedar 15 expects these files to be in root. -// For 16, it would be helpful to remove this and have all styles in /style. - -const path = require('path'); -const fs = require('fs-extra'); - -const DIST = 'dist'; - -['cdr-fonts.css', 'cdr-reset.css'].forEach(file => { - fs.copyFileSync(path.join(DIST, '/style', file), path.join(DIST, file)); -}) \ No newline at end of file diff --git a/cedar.mjs b/cedar.mjs new file mode 100644 index 000000000..f38e9874c --- /dev/null +++ b/cedar.mjs @@ -0,0 +1,26454 @@ +(function() { + const t = document.createElement("link").relList; + if (t && t.supports && t.supports("modulepreload")) + return; + for (const o of document.querySelectorAll('link[rel="modulepreload"]')) + r(o); + new MutationObserver((o) => { + for (const c of o) + if (c.type === "childList") + for (const s of c.addedNodes) + s.tagName === "LINK" && s.rel === "modulepreload" && r(s); + }).observe(document, { childList: !0, subtree: !0 }); + function l(o) { + const c = {}; + return o.integrity && (c.integrity = o.integrity), o.referrerPolicy && (c.referrerPolicy = o.referrerPolicy), o.crossOrigin === "use-credentials" ? c.credentials = "include" : o.crossOrigin === "anonymous" ? c.credentials = "omit" : c.credentials = "same-origin", c; + } + function r(o) { + if (o.ep) + return; + o.ep = !0; + const c = l(o); + fetch(o.href, c); + } +})(); +/** +* @vue/shared v3.4.35 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +/*! #__NO_SIDE_EFFECTS__ */ +// @__NO_SIDE_EFFECTS__ +function dr(e, t) { + const l = new Set(e.split(",")); + return (r) => l.has(r); +} +const Ae = {}, jl = [], rt = () => { +}, r0 = () => !1, _o = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter +(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), ur = (e) => e.startsWith("onUpdate:"), Ne = Object.assign, pr = (e, t) => { + const l = e.indexOf(t); + l > -1 && e.splice(l, 1); +}, s0 = Object.prototype.hasOwnProperty, Ee = (e, t) => s0.call(e, t), fe = Array.isArray, Tl = (e) => po(e) === "[object Map]", Wl = (e) => po(e) === "[object Set]", ls = (e) => po(e) === "[object Date]", ge = (e) => typeof e == "function", Xe = (e) => typeof e == "string", vt = (e) => typeof e == "symbol", Je = (e) => e !== null && typeof e == "object", Ra = (e) => (Je(e) || ge(e)) && ge(e.then) && ge(e.catch), va = Object.prototype.toString, po = (e) => va.call(e), a0 = (e) => po(e).slice(8, -1), Ia = (e) => po(e) === "[object Object]", mr = (e) => Xe(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, Gl = /* @__PURE__ */ dr( + // the leading comma is intentional so empty string "" is also included + ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" +), $o = (e) => { + const t = /* @__PURE__ */ Object.create(null); + return (l) => t[l] || (t[l] = e(l)); +}, i0 = /-(\w)/g, Vt = $o((e) => e.replace(i0, (t, l) => l ? l.toUpperCase() : "")), c0 = /\B([A-Z])/g, al = $o( + (e) => e.replace(c0, "-$1").toLowerCase() +), en = $o((e) => e.charAt(0).toUpperCase() + e.slice(1)), To = $o((e) => e ? `on${en(e)}` : ""), ol = (e, t) => !Object.is(e, t), Eo = (e, ...t) => { + for (let l = 0; l < e.length; l++) + e[l](...t); +}, Ka = (e, t, l, r = !1) => { + Object.defineProperty(e, t, { + configurable: !0, + enumerable: !1, + writable: r, + value: l + }); +}, Wo = (e) => { + const t = parseFloat(e); + return isNaN(t) ? e : t; +}, d0 = (e) => { + const t = Xe(e) ? Number(e) : NaN; + return isNaN(t) ? e : t; +}; +let os; +const Ua = () => os || (os = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {}); +function Oe(e) { + if (fe(e)) { + const t = {}; + for (let l = 0; l < e.length; l++) { + const r = e[l], o = Xe(r) ? f0(r) : Oe(r); + if (o) + for (const c in o) + t[c] = o[c]; + } + return t; + } else if (Xe(e) || Je(e)) + return e; +} +const u0 = /;(?![^(]*\))/g, p0 = /:([^]+)/, m0 = /\/\*[^]*?\*\//g; +function f0(e) { + const t = {}; + return e.replace(m0, "").split(u0).forEach((l) => { + if (l) { + const r = l.split(p0); + r.length > 1 && (t[r[0].trim()] = r[1].trim()); + } + }), t; +} +function R(e) { + let t = ""; + if (Xe(e)) + t = e; + else if (fe(e)) + for (let l = 0; l < e.length; l++) { + const r = R(e[l]); + r && (t += r + " "); + } + else if (Je(e)) + for (const l in e) + e[l] && (t += l + " "); + return t.trim(); +} +function U(e) { + if (!e) return null; + let { class: t, style: l } = e; + return t && !Xe(t) && (e.class = R(t)), l && (e.style = Oe(l)), e; +} +const h0 = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly", V0 = /* @__PURE__ */ dr(h0); +function ja(e) { + return !!e || e === ""; +} +function b0(e, t) { + if (e.length !== t.length) return !1; + let l = !0; + for (let r = 0; l && r < e.length; r++) + l = yl(e[r], t[r]); + return l; +} +function yl(e, t) { + if (e === t) return !0; + let l = ls(e), r = ls(t); + if (l || r) + return l && r ? e.getTime() === t.getTime() : !1; + if (l = vt(e), r = vt(t), l || r) + return e === t; + if (l = fe(e), r = fe(t), l || r) + return l && r ? b0(e, t) : !1; + if (l = Je(e), r = Je(t), l || r) { + if (!l || !r) + return !1; + const o = Object.keys(e).length, c = Object.keys(t).length; + if (o !== c) + return !1; + for (const s in e) { + const d = e.hasOwnProperty(s), u = t.hasOwnProperty(s); + if (d && !u || !d && u || !yl(e[s], t[s])) + return !1; + } + } + return String(e) === String(t); +} +function fr(e, t) { + return e.findIndex((l) => yl(l, t)); +} +const Ta = (e) => !!(e && e.__v_isRef === !0), w = (e) => Xe(e) ? e : e == null ? "" : fe(e) || Je(e) && (e.toString === va || !ge(e.toString)) ? Ta(e) ? w(e.value) : JSON.stringify(e, Ea, 2) : String(e), Ea = (e, t) => Ta(t) ? Ea(e, t.value) : Tl(t) ? { + [`Map(${t.size})`]: [...t.entries()].reduce( + (l, [r, o], c) => (l[Sn(r, c) + " =>"] = o, l), + {} + ) +} : Wl(t) ? { + [`Set(${t.size})`]: [...t.values()].map((l) => Sn(l)) +} : vt(t) ? Sn(t) : Je(t) && !fe(t) && !Ia(t) ? String(t) : t, Sn = (e, t = "") => { + var l; + return ( + // Symbol.description in es2019+ so we need to cast here to pass + // the lib: es2016 check + vt(e) ? `Symbol(${(l = e.description) != null ? l : t})` : e + ); +}; +let ft; +class y0 { + constructor(t = !1) { + this.detached = t, this._active = !0, this.effects = [], this.cleanups = [], this.parent = ft, !t && ft && (this.index = (ft.scopes || (ft.scopes = [])).push( + this + ) - 1); + } + get active() { + return this._active; + } + run(t) { + if (this._active) { + const l = ft; + try { + return ft = this, t(); + } finally { + ft = l; + } + } + } + /** + * This should only be called on non-detached scopes + * @internal + */ + on() { + ft = this; + } + /** + * This should only be called on non-detached scopes + * @internal + */ + off() { + ft = this.parent; + } + stop(t) { + if (this._active) { + let l, r; + for (l = 0, r = this.effects.length; l < r; l++) + this.effects[l].stop(); + for (l = 0, r = this.cleanups.length; l < r; l++) + this.cleanups[l](); + if (this.scopes) + for (l = 0, r = this.scopes.length; l < r; l++) + this.scopes[l].stop(!0); + if (!this.detached && this.parent && !t) { + const o = this.parent.scopes.pop(); + o && o !== this && (this.parent.scopes[this.index] = o, o.index = this.index); + } + this.parent = void 0, this._active = !1; + } + } +} +function q0(e, t = ft) { + t && t.active && t.effects.push(e); +} +function k0() { + return ft; +} +let Vl; +class hr { + constructor(t, l, r, o) { + this.fn = t, this.trigger = l, this.scheduler = r, this.active = !0, this.deps = [], this._dirtyLevel = 4, this._trackId = 0, this._runnings = 0, this._shouldSchedule = !1, this._depsLength = 0, q0(this, o); + } + get dirty() { + if (this._dirtyLevel === 2 || this._dirtyLevel === 3) { + this._dirtyLevel = 1, wt(); + for (let t = 0; t < this._depsLength; t++) { + const l = this.deps[t]; + if (l.computed && (g0(l.computed), this._dirtyLevel >= 4)) + break; + } + this._dirtyLevel === 1 && (this._dirtyLevel = 0), Wt(); + } + return this._dirtyLevel >= 4; + } + set dirty(t) { + this._dirtyLevel = t ? 4 : 0; + } + run() { + if (this._dirtyLevel = 0, !this.active) + return this.fn(); + let t = tl, l = Vl; + try { + return tl = !0, Vl = this, this._runnings++, ns(this), this.fn(); + } finally { + rs(this), this._runnings--, Vl = l, tl = t; + } + } + stop() { + this.active && (ns(this), rs(this), this.onStop && this.onStop(), this.active = !1); + } +} +function g0(e) { + return e.value; +} +function ns(e) { + e._trackId++, e._depsLength = 0; +} +function rs(e) { + if (e.deps.length > e._depsLength) { + for (let t = e._depsLength; t < e.deps.length; t++) + La(e.deps[t], e); + e.deps.length = e._depsLength; + } +} +function La(e, t) { + const l = e.get(t); + l !== void 0 && t._trackId !== l && (e.delete(t), e.size === 0 && e.cleanup()); +} +let tl = !0, zn = 0; +const Ca = []; +function wt() { + Ca.push(tl), tl = !1; +} +function Wt() { + const e = Ca.pop(); + tl = e === void 0 ? !0 : e; +} +function Vr() { + zn++; +} +function br() { + for (zn--; !zn && Hn.length; ) + Hn.shift()(); +} +function Ma(e, t, l) { + if (t.get(e) !== e._trackId) { + t.set(e, e._trackId); + const r = e.deps[e._depsLength]; + r !== t ? (r && La(r, e), e.deps[e._depsLength++] = t) : e._depsLength++; + } +} +const Hn = []; +function Ja(e, t, l) { + Vr(); + for (const r of e.keys()) { + let o; + r._dirtyLevel < t && (o ?? (o = e.get(r) === r._trackId)) && (r._shouldSchedule || (r._shouldSchedule = r._dirtyLevel === 0), r._dirtyLevel = t), r._shouldSchedule && (o ?? (o = e.get(r) === r._trackId)) && (r.trigger(), (!r._runnings || r.allowRecurse) && r._dirtyLevel !== 2 && (r._shouldSchedule = !1, r.scheduler && Hn.push(r.scheduler))); + } + br(); +} +const Aa = (e, t) => { + const l = /* @__PURE__ */ new Map(); + return l.cleanup = e, l.computed = t, l; +}, Oo = /* @__PURE__ */ new WeakMap(), bl = Symbol(""), Nn = Symbol(""); +function ot(e, t, l) { + if (tl && Vl) { + let r = Oo.get(e); + r || Oo.set(e, r = /* @__PURE__ */ new Map()); + let o = r.get(l); + o || r.set(l, o = Aa(() => r.delete(l))), Ma( + Vl, + o + ); + } +} +function Ct(e, t, l, r, o, c) { + const s = Oo.get(e); + if (!s) + return; + let d = []; + if (t === "clear") + d = [...s.values()]; + else if (l === "length" && fe(e)) { + const u = Number(r); + s.forEach((m, f) => { + (f === "length" || !vt(f) && f >= u) && d.push(m); + }); + } else + switch (l !== void 0 && d.push(s.get(l)), t) { + case "add": + fe(e) ? mr(l) && d.push(s.get("length")) : (d.push(s.get(bl)), Tl(e) && d.push(s.get(Nn))); + break; + case "delete": + fe(e) || (d.push(s.get(bl)), Tl(e) && d.push(s.get(Nn))); + break; + case "set": + Tl(e) && d.push(s.get(bl)); + break; + } + Vr(); + for (const u of d) + u && Ja( + u, + 4 + ); + br(); +} +function x0(e, t) { + const l = Oo.get(e); + return l && l.get(t); +} +const S0 = /* @__PURE__ */ dr("__proto__,__v_isRef,__isVue"), wa = new Set( + /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(vt) +), ss = /* @__PURE__ */ R0(); +function R0() { + const e = {}; + return ["includes", "indexOf", "lastIndexOf"].forEach((t) => { + e[t] = function(...l) { + const r = Te(this); + for (let c = 0, s = this.length; c < s; c++) + ot(r, "get", c + ""); + const o = r[t](...l); + return o === -1 || o === !1 ? r[t](...l.map(Te)) : o; + }; + }), ["push", "pop", "shift", "unshift", "splice"].forEach((t) => { + e[t] = function(...l) { + wt(), Vr(); + const r = Te(this)[t].apply(this, l); + return br(), Wt(), r; + }; + }), e; +} +function v0(e) { + vt(e) || (e = String(e)); + const t = Te(this); + return ot(t, "has", e), t.hasOwnProperty(e); +} +class Wa { + constructor(t = !1, l = !1) { + this._isReadonly = t, this._isShallow = l; + } + get(t, l, r) { + const o = this._isReadonly, c = this._isShallow; + if (l === "__v_isReactive") + return !o; + if (l === "__v_isReadonly") + return o; + if (l === "__v_isShallow") + return c; + if (l === "__v_raw") + return r === (o ? c ? za : Pa : c ? Za : Xa).get(t) || // receiver is not the reactive proxy, but has the same prototype + // this means the reciever is a user proxy of the reactive proxy + Object.getPrototypeOf(t) === Object.getPrototypeOf(r) ? t : void 0; + const s = fe(t); + if (!o) { + if (s && Ee(ss, l)) + return Reflect.get(ss, l, r); + if (l === "hasOwnProperty") + return v0; + } + const d = Reflect.get(t, l, r); + return (vt(l) ? wa.has(l) : S0(l)) || (o || ot(t, "get", l), c) ? d : Ye(d) ? s && mr(l) ? d : d.value : Je(d) ? o ? Na(d) : on(d) : d; + } +} +class Oa extends Wa { + constructor(t = !1) { + super(!1, t); + } + set(t, l, r, o) { + let c = t[l]; + if (!this._isShallow) { + const u = ql(c); + if (!Ll(r) && !ql(r) && (c = Te(c), r = Te(r)), !fe(t) && Ye(c) && !Ye(r)) + return u ? !1 : (c.value = r, !0); + } + const s = fe(t) && mr(l) ? Number(l) < t.length : Ee(t, l), d = Reflect.set(t, l, r, o); + return t === Te(o) && (s ? ol(r, c) && Ct(t, "set", l, r) : Ct(t, "add", l, r)), d; + } + deleteProperty(t, l) { + const r = Ee(t, l); + t[l]; + const o = Reflect.deleteProperty(t, l); + return o && r && Ct(t, "delete", l, void 0), o; + } + has(t, l) { + const r = Reflect.has(t, l); + return (!vt(l) || !wa.has(l)) && ot(t, "has", l), r; + } + ownKeys(t) { + return ot( + t, + "iterate", + fe(t) ? "length" : bl + ), Reflect.ownKeys(t); + } +} +class Fa extends Wa { + constructor(t = !1) { + super(!0, t); + } + set(t, l) { + return !0; + } + deleteProperty(t, l) { + return !0; + } +} +const I0 = /* @__PURE__ */ new Oa(), K0 = /* @__PURE__ */ new Fa(), U0 = /* @__PURE__ */ new Oa( + !0 +), j0 = /* @__PURE__ */ new Fa(!0), yr = (e) => e, tn = (e) => Reflect.getPrototypeOf(e); +function qo(e, t, l = !1, r = !1) { + e = e.__v_raw; + const o = Te(e), c = Te(t); + l || (ol(t, c) && ot(o, "get", t), ot(o, "get", c)); + const { has: s } = tn(o), d = r ? yr : l ? qr : no; + if (s.call(o, t)) + return d(e.get(t)); + if (s.call(o, c)) + return d(e.get(c)); + e !== o && e.get(t); +} +function ko(e, t = !1) { + const l = this.__v_raw, r = Te(l), o = Te(e); + return t || (ol(e, o) && ot(r, "has", e), ot(r, "has", o)), e === o ? l.has(e) : l.has(e) || l.has(o); +} +function go(e, t = !1) { + return e = e.__v_raw, !t && ot(Te(e), "iterate", bl), Reflect.get(e, "size", e); +} +function as(e, t = !1) { + !t && !Ll(e) && !ql(e) && (e = Te(e)); + const l = Te(this); + return tn(l).has.call(l, e) || (l.add(e), Ct(l, "add", e, e)), this; +} +function is(e, t, l = !1) { + !l && !Ll(t) && !ql(t) && (t = Te(t)); + const r = Te(this), { has: o, get: c } = tn(r); + let s = o.call(r, e); + s || (e = Te(e), s = o.call(r, e)); + const d = c.call(r, e); + return r.set(e, t), s ? ol(t, d) && Ct(r, "set", e, t) : Ct(r, "add", e, t), this; +} +function cs(e) { + const t = Te(this), { has: l, get: r } = tn(t); + let o = l.call(t, e); + o || (e = Te(e), o = l.call(t, e)), r && r.call(t, e); + const c = t.delete(e); + return o && Ct(t, "delete", e, void 0), c; +} +function ds() { + const e = Te(this), t = e.size !== 0, l = e.clear(); + return t && Ct(e, "clear", void 0, void 0), l; +} +function xo(e, t) { + return function(r, o) { + const c = this, s = c.__v_raw, d = Te(s), u = t ? yr : e ? qr : no; + return !e && ot(d, "iterate", bl), s.forEach((m, f) => r.call(o, u(m), u(f), c)); + }; +} +function So(e, t, l) { + return function(...r) { + const o = this.__v_raw, c = Te(o), s = Tl(c), d = e === "entries" || e === Symbol.iterator && s, u = e === "keys" && s, m = o[e](...r), f = l ? yr : t ? qr : no; + return !t && ot( + c, + "iterate", + u ? Nn : bl + ), { + // iterator protocol + next() { + const { value: V, done: y } = m.next(); + return y ? { value: V, done: y } : { + value: d ? [f(V[0]), f(V[1])] : f(V), + done: y + }; + }, + // iterable protocol + [Symbol.iterator]() { + return this; + } + }; + }; +} +function Pt(e) { + return function(...t) { + return e === "delete" ? !1 : e === "clear" ? void 0 : this; + }; +} +function T0() { + const e = { + get(c) { + return qo(this, c); + }, + get size() { + return go(this); + }, + has: ko, + add: as, + set: is, + delete: cs, + clear: ds, + forEach: xo(!1, !1) + }, t = { + get(c) { + return qo(this, c, !1, !0); + }, + get size() { + return go(this); + }, + has: ko, + add(c) { + return as.call(this, c, !0); + }, + set(c, s) { + return is.call(this, c, s, !0); + }, + delete: cs, + clear: ds, + forEach: xo(!1, !0) + }, l = { + get(c) { + return qo(this, c, !0); + }, + get size() { + return go(this, !0); + }, + has(c) { + return ko.call(this, c, !0); + }, + add: Pt("add"), + set: Pt("set"), + delete: Pt("delete"), + clear: Pt("clear"), + forEach: xo(!0, !1) + }, r = { + get(c) { + return qo(this, c, !0, !0); + }, + get size() { + return go(this, !0); + }, + has(c) { + return ko.call(this, c, !0); + }, + add: Pt("add"), + set: Pt("set"), + delete: Pt("delete"), + clear: Pt("clear"), + forEach: xo(!0, !0) + }; + return [ + "keys", + "values", + "entries", + Symbol.iterator + ].forEach((c) => { + e[c] = So(c, !1, !1), l[c] = So(c, !0, !1), t[c] = So(c, !1, !0), r[c] = So( + c, + !0, + !0 + ); + }), [ + e, + l, + t, + r + ]; +} +const [ + E0, + L0, + C0, + M0 +] = /* @__PURE__ */ T0(); +function ln(e, t) { + const l = t ? e ? M0 : C0 : e ? L0 : E0; + return (r, o, c) => o === "__v_isReactive" ? !e : o === "__v_isReadonly" ? e : o === "__v_raw" ? r : Reflect.get( + Ee(l, o) && o in r ? l : r, + o, + c + ); +} +const J0 = { + get: /* @__PURE__ */ ln(!1, !1) +}, A0 = { + get: /* @__PURE__ */ ln(!1, !0) +}, w0 = { + get: /* @__PURE__ */ ln(!0, !1) +}, W0 = { + get: /* @__PURE__ */ ln(!0, !0) +}, Xa = /* @__PURE__ */ new WeakMap(), Za = /* @__PURE__ */ new WeakMap(), Pa = /* @__PURE__ */ new WeakMap(), za = /* @__PURE__ */ new WeakMap(); +function O0(e) { + switch (e) { + case "Object": + case "Array": + return 1; + case "Map": + case "Set": + case "WeakMap": + case "WeakSet": + return 2; + default: + return 0; + } +} +function F0(e) { + return e.__v_skip || !Object.isExtensible(e) ? 0 : O0(a0(e)); +} +function on(e) { + return ql(e) ? e : nn( + e, + !1, + I0, + J0, + Xa + ); +} +function Ha(e) { + return nn( + e, + !1, + U0, + A0, + Za + ); +} +function Na(e) { + return nn( + e, + !0, + K0, + w0, + Pa + ); +} +function Ro(e) { + return nn( + e, + !0, + j0, + W0, + za + ); +} +function nn(e, t, l, r, o) { + if (!Je(e) || e.__v_raw && !(t && e.__v_isReactive)) + return e; + const c = o.get(e); + if (c) + return c; + const s = F0(e); + if (s === 0) + return e; + const d = new Proxy( + e, + s === 2 ? r : l + ); + return o.set(e, d), d; +} +function Yl(e) { + return ql(e) ? Yl(e.__v_raw) : !!(e && e.__v_isReactive); +} +function ql(e) { + return !!(e && e.__v_isReadonly); +} +function Ll(e) { + return !!(e && e.__v_isShallow); +} +function Ga(e) { + return e ? !!e.__v_raw : !1; +} +function Te(e) { + const t = e && e.__v_raw; + return t ? Te(t) : e; +} +function X0(e) { + return Object.isExtensible(e) && Ka(e, "__v_skip", !0), e; +} +const no = (e) => Je(e) ? on(e) : e, qr = (e) => Je(e) ? Na(e) : e; +class Ya { + constructor(t, l, r, o) { + this.getter = t, this._setter = l, this.dep = void 0, this.__v_isRef = !0, this.__v_isReadonly = !1, this.effect = new hr( + () => t(this._value), + () => Lo( + this, + this.effect._dirtyLevel === 2 ? 2 : 3 + ) + ), this.effect.computed = this, this.effect.active = this._cacheable = !o, this.__v_isReadonly = r; + } + get value() { + const t = Te(this); + return (!t._cacheable || t.effect.dirty) && ol(t._value, t._value = t.effect.run()) && Lo(t, 4), Qa(t), t.effect._dirtyLevel >= 2 && Lo(t, 2), t._value; + } + set value(t) { + this._setter(t); + } + // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x + get _dirty() { + return this.effect.dirty; + } + set _dirty(t) { + this.effect.dirty = t; + } + // #endregion +} +function Z0(e, t, l = !1) { + let r, o; + const c = ge(e); + return c ? (r = e, o = rt) : (r = e.get, o = e.set), new Ya(r, o, c || !o, l); +} +function Qa(e) { + var t; + tl && Vl && (e = Te(e), Ma( + Vl, + (t = e.dep) != null ? t : e.dep = Aa( + () => e.dep = void 0, + e instanceof Ya ? e : void 0 + ) + )); +} +function Lo(e, t = 4, l, r) { + e = Te(e); + const o = e.dep; + o && Ja( + o, + t + ); +} +function Ye(e) { + return !!(e && e.__v_isRef === !0); +} +function ne(e) { + return Ba(e, !1); +} +function P0(e) { + return Ba(e, !0); +} +function Ba(e, t) { + return Ye(e) ? e : new z0(e, t); +} +class z0 { + constructor(t, l) { + this.__v_isShallow = l, this.dep = void 0, this.__v_isRef = !0, this._rawValue = l ? t : Te(t), this._value = l ? t : no(t); + } + get value() { + return Qa(this), this._value; + } + set value(t) { + const l = this.__v_isShallow || Ll(t) || ql(t); + t = l ? t : Te(t), ol(t, this._rawValue) && (this._rawValue, this._rawValue = t, this._value = l ? t : no(t), Lo(this, 4)); + } +} +function b(e) { + return Ye(e) ? e.value : e; +} +const H0 = { + get: (e, t, l) => b(Reflect.get(e, t, l)), + set: (e, t, l, r) => { + const o = e[t]; + return Ye(o) && !Ye(l) ? (o.value = l, !0) : Reflect.set(e, t, l, r); + } +}; +function Da(e) { + return Yl(e) ? e : new Proxy(e, H0); +} +class N0 { + constructor(t, l, r) { + this._object = t, this._key = l, this._defaultValue = r, this.__v_isRef = !0; + } + get value() { + const t = this._object[this._key]; + return t === void 0 ? this._defaultValue : t; + } + set value(t) { + this._object[this._key] = t; + } + get dep() { + return x0(Te(this._object), this._key); + } +} +class G0 { + constructor(t) { + this._getter = t, this.__v_isRef = !0, this.__v_isReadonly = !0; + } + get value() { + return this._getter(); + } +} +function Y0(e, t, l) { + return Ye(e) ? e : ge(e) ? new G0(e) : Je(e) && arguments.length > 1 ? Q0(e, t, l) : ne(e); +} +function Q0(e, t, l) { + const r = e[t]; + return Ye(r) ? r : new N0(e, t, l); +} +var Yt = { NODE_ENV: "production" }; +const Ql = []; +let Rn = !1; +function B0(e, ...t) { + if (Rn) return; + Rn = !0, wt(); + const l = Ql.length ? Ql[Ql.length - 1].component : null, r = l && l.appContext.config.warnHandler, o = D0(); + if (r) + Mt( + r, + l, + 11, + [ + // eslint-disable-next-line no-restricted-syntax + e + t.map((c) => { + var s, d; + return (d = (s = c.toString) == null ? void 0 : s.call(c)) != null ? d : JSON.stringify(c); + }).join(""), + l && l.proxy, + o.map( + ({ vnode: c }) => `at <${Oi(l, c.type)}>` + ).join(` +`), + o + ] + ); + else { + const c = [`[Vue warn]: ${e}`, ...t]; + o.length && c.push(` +`, ..._0(o)), console.warn(...c); + } + Wt(), Rn = !1; +} +function D0() { + let e = Ql[Ql.length - 1]; + if (!e) + return []; + const t = []; + for (; e; ) { + const l = t[0]; + l && l.vnode === e ? l.recurseCount++ : t.push({ + vnode: e, + recurseCount: 0 + }); + const r = e.component && e.component.parent; + e = r && r.vnode; + } + return t; +} +function _0(e) { + const t = []; + return e.forEach((l, r) => { + t.push(...r === 0 ? [] : [` +`], ...$0(l)); + }), t; +} +function $0({ vnode: e, recurseCount: t }) { + const l = t > 0 ? `... (${t} recursive calls)` : "", r = e.component ? e.component.parent == null : !1, o = ` at <${Oi( + e.component, + e.type, + r + )}`, c = ">" + l; + return e.props ? [o, ...ep(e.props), c] : [o + c]; +} +function ep(e) { + const t = [], l = Object.keys(e); + return l.slice(0, 3).forEach((r) => { + t.push(..._a(r, e[r])); + }), l.length > 3 && t.push(" ..."), t; +} +function _a(e, t, l) { + return Xe(t) ? (t = JSON.stringify(t), l ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? l ? t : [`${e}=${t}`] : Ye(t) ? (t = _a(e, Te(t.value), !0), l ? t : [`${e}=Ref<`, t, ">"]) : ge(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = Te(t), l ? t : [`${e}=`, t]); +} +function Mt(e, t, l, r) { + try { + return r ? e(...r) : e(); + } catch (o) { + rn(o, t, l); + } +} +function dt(e, t, l, r) { + if (ge(e)) { + const o = Mt(e, t, l, r); + return o && Ra(o) && o.catch((c) => { + rn(c, t, l); + }), o; + } + if (fe(e)) { + const o = []; + for (let c = 0; c < e.length; c++) + o.push(dt(e[c], t, l, r)); + return o; + } +} +function rn(e, t, l, r = !0) { + const o = t ? t.vnode : null; + if (t) { + let c = t.parent; + const s = t.proxy, d = `https://vuejs.org/error-reference/#runtime-${l}`; + for (; c; ) { + const m = c.ec; + if (m) { + for (let f = 0; f < m.length; f++) + if (m[f](e, s, d) === !1) + return; + } + c = c.parent; + } + const u = t.appContext.config.errorHandler; + if (u) { + wt(), Mt( + u, + null, + 10, + [e, s, d] + ), Wt(); + return; + } + } + tp(e, l, o, r); +} +function tp(e, t, l, r = !0) { + console.error(e); +} +let ro = !1, Gn = !1; +const _e = []; +let Rt = 0; +const El = []; +let Qt = null, fl = 0; +const $a = /* @__PURE__ */ Promise.resolve(); +let kr = null; +function ht(e) { + const t = kr || $a; + return e ? t.then(this ? e.bind(this) : e) : t; +} +function lp(e) { + let t = Rt + 1, l = _e.length; + for (; t < l; ) { + const r = t + l >>> 1, o = _e[r], c = so(o); + c < e || c === e && o.pre ? t = r + 1 : l = r; + } + return t; +} +function gr(e) { + (!_e.length || !_e.includes( + e, + ro && e.allowRecurse ? Rt + 1 : Rt + )) && (e.id == null ? _e.push(e) : _e.splice(lp(e.id), 0, e), ei()); +} +function ei() { + !ro && !Gn && (Gn = !0, kr = $a.then(li)); +} +function op(e) { + const t = _e.indexOf(e); + t > Rt && _e.splice(t, 1); +} +function np(e) { + fe(e) ? El.push(...e) : (!Qt || !Qt.includes( + e, + e.allowRecurse ? fl + 1 : fl + )) && El.push(e), ei(); +} +function us(e, t, l = ro ? Rt + 1 : 0) { + for (; l < _e.length; l++) { + const r = _e[l]; + if (r && r.pre) { + if (e && r.id !== e.uid) + continue; + _e.splice(l, 1), l--, r(); + } + } +} +function ti(e) { + if (El.length) { + const t = [...new Set(El)].sort( + (l, r) => so(l) - so(r) + ); + if (El.length = 0, Qt) { + Qt.push(...t); + return; + } + for (Qt = t, fl = 0; fl < Qt.length; fl++) { + const l = Qt[fl]; + l.active !== !1 && l(); + } + Qt = null, fl = 0; + } +} +const so = (e) => e.id == null ? 1 / 0 : e.id, rp = (e, t) => { + const l = so(e) - so(t); + if (l === 0) { + if (e.pre && !t.pre) return -1; + if (t.pre && !e.pre) return 1; + } + return l; +}; +function li(e) { + Gn = !1, ro = !0, _e.sort(rp); + const t = rt; + try { + for (Rt = 0; Rt < _e.length; Rt++) { + const l = _e[Rt]; + l && l.active !== !1 && (Yt.NODE_ENV !== "production" && t(l), Mt( + l, + l.i, + l.i ? 15 : 14 + )); + } + } finally { + Rt = 0, _e.length = 0, ti(), ro = !1, kr = null, (_e.length || El.length) && li(); + } +} +let He = null, sn = null; +function Fo(e) { + const t = He; + return He = e, sn = e && e.type.__scopeId || null, t; +} +function kl(e) { + sn = e; +} +function gl() { + sn = null; +} +function a(e, t = He, l) { + if (!t || e._n) + return e; + const r = (...o) => { + r._d && Ss(-1); + const c = Fo(t); + let s; + try { + s = e(...o); + } finally { + Fo(c), r._d && Ss(1); + } + return s; + }; + return r._n = !0, r._c = !0, r._d = !0, r; +} +function nl(e, t) { + if (He === null) + return e; + const l = hn(He), r = e.dirs || (e.dirs = []); + for (let o = 0; o < t.length; o++) { + let [c, s, d, u = Ae] = t[o]; + c && (ge(c) && (c = { + mounted: c, + updated: c + }), c.deep && $t(s), r.push({ + dir: c, + instance: l, + value: s, + oldValue: void 0, + arg: d, + modifiers: u + })); + } + return e; +} +function il(e, t, l, r) { + const o = e.dirs, c = t && t.dirs; + for (let s = 0; s < o.length; s++) { + const d = o[s]; + c && (d.oldValue = c[s].value); + let u = d.dir[r]; + u && (wt(), dt(u, l, 8, [ + e.el, + d, + e, + t + ]), Wt()); + } +} +const Bt = Symbol("_leaveCb"), vo = Symbol("_enterCb"); +function sp() { + const e = { + isMounted: !1, + isLeaving: !1, + isUnmounting: !1, + leavingVNodes: /* @__PURE__ */ new Map() + }; + return pt(() => { + e.isMounted = !0; + }), ci(() => { + e.isUnmounting = !0; + }), e; +} +const ct = [Function, Array], oi = { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: ct, + onEnter: ct, + onAfterEnter: ct, + onEnterCancelled: ct, + // leave + onBeforeLeave: ct, + onLeave: ct, + onAfterLeave: ct, + onLeaveCancelled: ct, + // appear + onBeforeAppear: ct, + onAppear: ct, + onAfterAppear: ct, + onAppearCancelled: ct +}, ni = (e) => { + const t = e.subTree; + return t.component ? ni(t.component) : t; +}, ap = { + name: "BaseTransition", + props: oi, + setup(e, { slots: t }) { + const l = Ir(), r = sp(); + return () => { + const o = t.default && si(t.default(), !0); + if (!o || !o.length) + return; + let c = o[0]; + if (o.length > 1) { + for (const y of o) + if (y.type !== lt) { + c = y; + break; + } + } + const s = Te(e), { mode: d } = s; + if (r.isLeaving) + return vn(c); + const u = ps(c); + if (!u) + return vn(c); + let m = Yn( + u, + s, + r, + l, + // #11061, ensure enterHooks is fresh after clone + (y) => m = y + ); + Xo(u, m); + const f = l.subTree, V = f && ps(f); + if (V && V.type !== lt && !hl(u, V) && ni(l).type !== lt) { + const y = Yn( + V, + s, + r, + l + ); + if (Xo(V, y), d === "out-in" && u.type !== lt) + return r.isLeaving = !0, y.afterLeave = () => { + r.isLeaving = !1, l.update.active !== !1 && (l.effect.dirty = !0, l.update()); + }, vn(c); + d === "in-out" && u.type !== lt && (y.delayLeave = (v, J, C) => { + const z = ri( + r, + V + ); + z[String(V.key)] = V, v[Bt] = () => { + J(), v[Bt] = void 0, delete m.delayedLeave; + }, m.delayedLeave = C; + }); + } + return c; + }; + } +}, ip = ap; +function ri(e, t) { + const { leavingVNodes: l } = e; + let r = l.get(t.type); + return r || (r = /* @__PURE__ */ Object.create(null), l.set(t.type, r)), r; +} +function Yn(e, t, l, r, o) { + const { + appear: c, + mode: s, + persisted: d = !1, + onBeforeEnter: u, + onEnter: m, + onAfterEnter: f, + onEnterCancelled: V, + onBeforeLeave: y, + onLeave: v, + onAfterLeave: J, + onLeaveCancelled: C, + onBeforeAppear: z, + onAppear: L, + onAfterAppear: O, + onAppearCancelled: F + } = t, Q = String(e.key), de = ri(l, e), P = (D, ue) => { + D && dt( + D, + r, + 9, + ue + ); + }, te = (D, ue) => { + const me = ue[1]; + P(D, ue), fe(D) ? D.every((Y) => Y.length <= 1) && me() : D.length <= 1 && me(); + }, Ve = { + mode: s, + persisted: d, + beforeEnter(D) { + let ue = u; + if (!l.isMounted) + if (c) + ue = z || u; + else + return; + D[Bt] && D[Bt]( + !0 + /* cancelled */ + ); + const me = de[Q]; + me && hl(e, me) && me.el[Bt] && me.el[Bt](), P(ue, [D]); + }, + enter(D) { + let ue = m, me = f, Y = V; + if (!l.isMounted) + if (c) + ue = L || m, me = O || f, Y = F || V; + else + return; + let xe = !1; + const ce = D[vo] = (Se) => { + xe || (xe = !0, Se ? P(Y, [D]) : P(me, [D]), Ve.delayedLeave && Ve.delayedLeave(), D[vo] = void 0); + }; + ue ? te(ue, [D, ce]) : ce(); + }, + leave(D, ue) { + const me = String(e.key); + if (D[vo] && D[vo]( + !0 + /* cancelled */ + ), l.isUnmounting) + return ue(); + P(y, [D]); + let Y = !1; + const xe = D[Bt] = (ce) => { + Y || (Y = !0, ue(), ce ? P(C, [D]) : P(J, [D]), D[Bt] = void 0, de[me] === e && delete de[me]); + }; + de[me] = e, v ? te(v, [D, xe]) : xe(); + }, + clone(D) { + const ue = Yn( + D, + t, + l, + r, + o + ); + return o && o(ue), ue; + } + }; + return Ve; +} +function vn(e) { + if (an(e)) + return e = rl(e), e.children = null, e; +} +function ps(e) { + if (!an(e)) + return e; + const { shapeFlag: t, children: l } = e; + if (l) { + if (t & 16) + return l[0]; + if (t & 32 && ge(l.default)) + return l.default(); + } +} +function Xo(e, t) { + e.shapeFlag & 6 && e.component ? Xo(e.component.subTree, t) : e.shapeFlag & 128 ? (e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback)) : e.transition = t; +} +function si(e, t = !1, l) { + let r = [], o = 0; + for (let c = 0; c < e.length; c++) { + let s = e[c]; + const d = l == null ? s.key : String(l) + String(s.key != null ? s.key : c); + s.type === N ? (s.patchFlag & 128 && o++, r = r.concat( + si(s.children, t, d) + )) : (t || s.type !== lt) && r.push(d != null ? rl(s, { key: d }) : s); + } + if (o > 1) + for (let c = 0; c < r.length; c++) + r[c].patchFlag = -2; + return r; +} +/*! #__NO_SIDE_EFFECTS__ */ +// @__NO_SIDE_EFFECTS__ +function g(e, t) { + return ge(e) ? ( + // #8326: extend call and options.name access are considered side-effects + // by Rollup, so we have to wrap it in a pure-annotated IIFE. + Ne({ name: e.name }, t, { setup: e }) + ) : e; +} +const Bl = (e) => !!e.type.__asyncLoader, an = (e) => e.type.__isKeepAlive; +function cp(e, t) { + ai(e, "a", t); +} +function dp(e, t) { + ai(e, "da", t); +} +function ai(e, t, l = Ze) { + const r = e.__wdc || (e.__wdc = () => { + let o = l; + for (; o; ) { + if (o.isDeactivated) + return; + o = o.parent; + } + return e(); + }); + if (cn(t, r, l), l) { + let o = l.parent; + for (; o && o.parent; ) + an(o.parent.vnode) && up(r, t, l, o), o = o.parent; + } +} +function up(e, t, l, r) { + const o = cn( + t, + e, + r, + !0 + /* prepend */ + ); + dn(() => { + pr(r[t], o); + }, l); +} +function cn(e, t, l = Ze, r = !1) { + if (l) { + const o = l[e] || (l[e] = []), c = t.__weh || (t.__weh = (...s) => { + wt(); + const d = mo(l), u = dt(t, l, e, s); + return d(), Wt(), u; + }); + return r ? o.unshift(c) : o.push(c), c; + } +} +const Ot = (e) => (t, l = Ze) => { + (!fn || e === "sp") && cn(e, (...r) => t(...r), l); +}, pp = Ot("bm"), pt = Ot("m"), mp = Ot("bu"), ii = Ot("u"), ci = Ot("bum"), dn = Ot("um"), fp = Ot("sp"), hp = Ot( + "rtg" +), Vp = Ot( + "rtc" +); +function bp(e, t = Ze) { + cn("ec", e, t); +} +const di = "components"; +function K(e, t) { + return pi(di, e, !0, t) || e; +} +const ui = Symbol.for("v-ndc"); +function Ue(e) { + return Xe(e) ? pi(di, e, !1) || e : e || ui; +} +function pi(e, t, l = !0, r = !1) { + const o = He || Ze; + if (o) { + const c = o.type; + { + const d = Wi( + c, + !1 + ); + if (d && (d === t || d === Vt(t) || d === en(Vt(t)))) + return c; + } + const s = ( + // local registration + // check instance[type] first which is resolved for options API + ms(o[e] || c[e], t) || // global registration + ms(o.appContext[e], t) + ); + return !s && r ? c : s; + } +} +function ms(e, t) { + return e && (e[t] || e[Vt(t)] || e[en(Vt(t))]); +} +function oe(e, t, l, r) { + let o; + const c = l; + if (fe(e) || Xe(e)) { + o = new Array(e.length); + for (let s = 0, d = e.length; s < d; s++) + o[s] = t(e[s], s, void 0, c); + } else if (typeof e == "number") { + o = new Array(e); + for (let s = 0; s < e; s++) + o[s] = t(s + 1, s, void 0, c); + } else if (Je(e)) + if (e[Symbol.iterator]) + o = Array.from( + e, + (s, d) => t(s, d, void 0, c) + ); + else { + const s = Object.keys(e); + o = new Array(s.length); + for (let d = 0, u = s.length; d < u; d++) { + const m = s[d]; + o[d] = t(e[m], m, d, c); + } + } + else + o = []; + return o; +} +function Cl(e, t) { + for (let l = 0; l < t.length; l++) { + const r = t[l]; + if (fe(r)) + for (let o = 0; o < r.length; o++) + e[r[o].name] = r[o].fn; + else r && (e[r.name] = r.key ? (...o) => { + const c = r.fn(...o); + return c && (c.key = r.key), c; + } : r.fn); + } + return e; +} +function q(e, t, l = {}, r, o) { + if (He.isCE || He.parent && Bl(He.parent) && He.parent.isCE) + return t !== "default" && (l.name = t), i("slot", l, r && r()); + let c = e[t]; + c && c._c && (c._d = !1), p(); + const s = c && mi(c(l)), d = k( + N, + { + key: (l.key || // slot content array of a dynamic conditional slot may have a branch + // key attached in the `createSlots` helper, respect that + s && s.key || `_${t}`) + // #7256 force differentiate fallback content from actual content + (!s && r ? "_fb" : "") + }, + s || (r ? r() : []), + s && e._ === 1 ? 64 : -2 + ); + return !o && d.scopeId && (d.slotScopeIds = [d.scopeId + "-s"]), c && c._c && (c._d = !0), d; +} +function mi(e) { + return e.some((t) => Po(t) ? !(t.type === lt || t.type === N && !mi(t.children)) : !0) ? e : null; +} +function yp(e, t) { + const l = {}; + for (const r in e) + l[To(r)] = e[r]; + return l; +} +const Qn = (e) => e ? Ji(e) ? hn(e) : Qn(e.parent) : null, Dl = ( + // Move PURE marker to new line to workaround compiler discarding it + // due to type annotation + /* @__PURE__ */ Ne(/* @__PURE__ */ Object.create(null), { + $: (e) => e, + $el: (e) => e.vnode.el, + $data: (e) => e.data, + $props: (e) => e.props, + $attrs: (e) => e.attrs, + $slots: (e) => e.slots, + $refs: (e) => e.refs, + $parent: (e) => Qn(e.parent), + $root: (e) => Qn(e.root), + $emit: (e) => e.emit, + $options: (e) => xr(e), + $forceUpdate: (e) => e.f || (e.f = () => { + e.effect.dirty = !0, gr(e.update); + }), + $nextTick: (e) => e.n || (e.n = ht.bind(e.proxy)), + $watch: (e) => Pp.bind(e) + }) +), In = (e, t) => e !== Ae && !e.__isScriptSetup && Ee(e, t), qp = { + get({ _: e }, t) { + if (t === "__v_skip") + return !0; + const { ctx: l, setupState: r, data: o, props: c, accessCache: s, type: d, appContext: u } = e; + let m; + if (t[0] !== "$") { + const v = s[t]; + if (v !== void 0) + switch (v) { + case 1: + return r[t]; + case 2: + return o[t]; + case 4: + return l[t]; + case 3: + return c[t]; + } + else { + if (In(r, t)) + return s[t] = 1, r[t]; + if (o !== Ae && Ee(o, t)) + return s[t] = 2, o[t]; + if ( + // only cache other properties when instance has declared (thus stable) + // props + (m = e.propsOptions[0]) && Ee(m, t) + ) + return s[t] = 3, c[t]; + if (l !== Ae && Ee(l, t)) + return s[t] = 4, l[t]; + Bn && (s[t] = 0); + } + } + const f = Dl[t]; + let V, y; + if (f) + return t === "$attrs" && ot(e.attrs, "get", ""), f(e); + if ( + // css module (injected by vue-loader) + (V = d.__cssModules) && (V = V[t]) + ) + return V; + if (l !== Ae && Ee(l, t)) + return s[t] = 4, l[t]; + if ( + // global properties + y = u.config.globalProperties, Ee(y, t) + ) + return y[t]; + }, + set({ _: e }, t, l) { + const { data: r, setupState: o, ctx: c } = e; + return In(o, t) ? (o[t] = l, !0) : r !== Ae && Ee(r, t) ? (r[t] = l, !0) : Ee(e.props, t) || t[0] === "$" && t.slice(1) in e ? !1 : (c[t] = l, !0); + }, + has({ + _: { data: e, setupState: t, accessCache: l, ctx: r, appContext: o, propsOptions: c } + }, s) { + let d; + return !!l[s] || e !== Ae && Ee(e, s) || In(t, s) || (d = c[0]) && Ee(d, s) || Ee(r, s) || Ee(Dl, s) || Ee(o.config.globalProperties, s); + }, + defineProperty(e, t, l) { + return l.get != null ? e._.accessCache[t] = 0 : Ee(l, "value") && this.set(e, t, l.value, null), Reflect.defineProperty(e, t, l); + } +}; +function Ft() { + return fi().slots; +} +function un() { + return fi().attrs; +} +function fi() { + const e = Ir(); + return e.setupContext || (e.setupContext = wi(e)); +} +function fs(e) { + return fe(e) ? e.reduce( + (t, l) => (t[l] = null, t), + {} + ) : e; +} +let Bn = !0; +function kp(e) { + const t = xr(e), l = e.proxy, r = e.ctx; + Bn = !1, t.beforeCreate && hs(t.beforeCreate, e, "bc"); + const { + // state + data: o, + computed: c, + methods: s, + watch: d, + provide: u, + inject: m, + // lifecycle + created: f, + beforeMount: V, + mounted: y, + beforeUpdate: v, + updated: J, + activated: C, + deactivated: z, + beforeDestroy: L, + beforeUnmount: O, + destroyed: F, + unmounted: Q, + render: de, + renderTracked: P, + renderTriggered: te, + errorCaptured: Ve, + serverPrefetch: D, + // public API + expose: ue, + inheritAttrs: me, + // assets + components: Y, + directives: xe, + filters: ce + } = t; + if (m && gp(m, r, null), s) + for (const Re in s) { + const ve = s[Re]; + ge(ve) && (r[Re] = ve.bind(l)); + } + if (o) { + const Re = o.call(l, l); + Je(Re) && (e.data = on(Re)); + } + if (Bn = !0, c) + for (const Re in c) { + const ve = c[Re], Ge = ge(ve) ? ve.bind(l, l) : ge(ve.get) ? ve.get.bind(l, l) : rt, qt = !ge(ve) && ge(ve.set) ? ve.set.bind(l) : rt, it = E({ + get: Ge, + set: qt + }); + Object.defineProperty(r, Re, { + enumerable: !0, + configurable: !0, + get: () => it.value, + set: (Be) => it.value = Be + }); + } + if (d) + for (const Re in d) + hi(d[Re], r, l, Re); + if (u) { + const Re = ge(u) ? u.call(l) : u; + Reflect.ownKeys(Re).forEach((ve) => { + ll(ve, Re[ve]); + }); + } + f && hs(f, e, "c"); + function Ie(Re, ve) { + fe(ve) ? ve.forEach((Ge) => Re(Ge.bind(l))) : ve && Re(ve.bind(l)); + } + if (Ie(pp, V), Ie(pt, y), Ie(mp, v), Ie(ii, J), Ie(cp, C), Ie(dp, z), Ie(bp, Ve), Ie(Vp, P), Ie(hp, te), Ie(ci, O), Ie(dn, Q), Ie(fp, D), fe(ue)) + if (ue.length) { + const Re = e.exposed || (e.exposed = {}); + ue.forEach((ve) => { + Object.defineProperty(Re, ve, { + get: () => l[ve], + set: (Ge) => l[ve] = Ge + }); + }); + } else e.exposed || (e.exposed = {}); + de && e.render === rt && (e.render = de), me != null && (e.inheritAttrs = me), Y && (e.components = Y), xe && (e.directives = xe); +} +function gp(e, t, l = rt) { + fe(e) && (e = Dn(e)); + for (const r in e) { + const o = e[r]; + let c; + Je(o) ? "default" in o ? c = at( + o.from || r, + o.default, + !0 + ) : c = at(o.from || r) : c = at(o), Ye(c) ? Object.defineProperty(t, r, { + enumerable: !0, + configurable: !0, + get: () => c.value, + set: (s) => c.value = s + }) : t[r] = c; + } +} +function hs(e, t, l) { + dt( + fe(e) ? e.map((r) => r.bind(t.proxy)) : e.bind(t.proxy), + t, + l + ); +} +function hi(e, t, l, r) { + const o = r.includes(".") ? Ei(l, r) : () => l[r]; + if (Xe(e)) { + const c = t[e]; + ge(c) && et(o, c); + } else if (ge(e)) + et(o, e.bind(l)); + else if (Je(e)) + if (fe(e)) + e.forEach((c) => hi(c, t, l, r)); + else { + const c = ge(e.handler) ? e.handler.bind(l) : t[e.handler]; + ge(c) && et(o, c, e); + } +} +function xr(e) { + const t = e.type, { mixins: l, extends: r } = t, { + mixins: o, + optionsCache: c, + config: { optionMergeStrategies: s } + } = e.appContext, d = c.get(t); + let u; + return d ? u = d : !o.length && !l && !r ? u = t : (u = {}, o.length && o.forEach( + (m) => Zo(u, m, s, !0) + ), Zo(u, t, s)), Je(t) && c.set(t, u), u; +} +function Zo(e, t, l, r = !1) { + const { mixins: o, extends: c } = t; + c && Zo(e, c, l, !0), o && o.forEach( + (s) => Zo(e, s, l, !0) + ); + for (const s in t) + if (!(r && s === "expose")) { + const d = xp[s] || l && l[s]; + e[s] = d ? d(e[s], t[s]) : t[s]; + } + return e; +} +const xp = { + data: Vs, + props: bs, + emits: bs, + // objects + methods: Nl, + computed: Nl, + // lifecycle + beforeCreate: $e, + created: $e, + beforeMount: $e, + mounted: $e, + beforeUpdate: $e, + updated: $e, + beforeDestroy: $e, + beforeUnmount: $e, + destroyed: $e, + unmounted: $e, + activated: $e, + deactivated: $e, + errorCaptured: $e, + serverPrefetch: $e, + // assets + components: Nl, + directives: Nl, + // watch + watch: Rp, + // provide / inject + provide: Vs, + inject: Sp +}; +function Vs(e, t) { + return t ? e ? function() { + return Ne( + ge(e) ? e.call(this, this) : e, + ge(t) ? t.call(this, this) : t + ); + } : t : e; +} +function Sp(e, t) { + return Nl(Dn(e), Dn(t)); +} +function Dn(e) { + if (fe(e)) { + const t = {}; + for (let l = 0; l < e.length; l++) + t[e[l]] = e[l]; + return t; + } + return e; +} +function $e(e, t) { + return e ? [...new Set([].concat(e, t))] : t; +} +function Nl(e, t) { + return e ? Ne(/* @__PURE__ */ Object.create(null), e, t) : t; +} +function bs(e, t) { + return e ? fe(e) && fe(t) ? [.../* @__PURE__ */ new Set([...e, ...t])] : Ne( + /* @__PURE__ */ Object.create(null), + fs(e), + fs(t ?? {}) + ) : t; +} +function Rp(e, t) { + if (!e) return t; + if (!t) return e; + const l = Ne(/* @__PURE__ */ Object.create(null), e); + for (const r in t) + l[r] = $e(e[r], t[r]); + return l; +} +function Vi() { + return { + app: null, + config: { + isNativeTag: r0, + performance: !1, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: void 0, + warnHandler: void 0, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: /* @__PURE__ */ Object.create(null), + optionsCache: /* @__PURE__ */ new WeakMap(), + propsCache: /* @__PURE__ */ new WeakMap(), + emitsCache: /* @__PURE__ */ new WeakMap() + }; +} +let vp = 0; +function Ip(e, t) { + return function(r, o = null) { + ge(r) || (r = Ne({}, r)), o != null && !Je(o) && (o = null); + const c = Vi(), s = /* @__PURE__ */ new WeakSet(); + let d = !1; + const u = c.app = { + _uid: vp++, + _component: r, + _props: o, + _container: null, + _context: c, + _instance: null, + version: c2, + get config() { + return c.config; + }, + set config(m) { + }, + use(m, ...f) { + return s.has(m) || (m && ge(m.install) ? (s.add(m), m.install(u, ...f)) : ge(m) && (s.add(m), m(u, ...f))), u; + }, + mixin(m) { + return c.mixins.includes(m) || c.mixins.push(m), u; + }, + component(m, f) { + return f ? (c.components[m] = f, u) : c.components[m]; + }, + directive(m, f) { + return f ? (c.directives[m] = f, u) : c.directives[m]; + }, + mount(m, f, V) { + if (!d) { + const y = i(r, o); + return y.appContext = c, V === !0 ? V = "svg" : V === !1 && (V = void 0), f && t ? t(y, m) : e(y, m, V), d = !0, u._container = m, m.__vue_app__ = u, hn(y.component); + } + }, + unmount() { + d && (e(null, u._container), delete u._container.__vue_app__); + }, + provide(m, f) { + return c.provides[m] = f, u; + }, + runWithContext(m) { + const f = _l; + _l = u; + try { + return m(); + } finally { + _l = f; + } + } + }; + return u; + }; +} +let _l = null; +function ll(e, t) { + if (Ze) { + let l = Ze.provides; + const r = Ze.parent && Ze.parent.provides; + r === l && (l = Ze.provides = Object.create(r)), l[e] = t; + } +} +function at(e, t, l = !1) { + const r = Ze || He; + if (r || _l) { + const o = r ? r.parent == null ? r.vnode.appContext && r.vnode.appContext.provides : r.parent.provides : _l._context.provides; + if (o && e in o) + return o[e]; + if (arguments.length > 1) + return l && ge(t) ? t.call(r && r.proxy) : t; + } +} +const bi = {}, yi = () => Object.create(bi), qi = (e) => Object.getPrototypeOf(e) === bi; +function Kp(e, t, l, r = !1) { + const o = {}, c = yi(); + e.propsDefaults = /* @__PURE__ */ Object.create(null), ki(e, t, o, c); + for (const s in e.propsOptions[0]) + s in o || (o[s] = void 0); + l ? e.props = r ? o : Ha(o) : e.type.props ? e.props = o : e.props = c, e.attrs = c; +} +function Up(e, t, l, r) { + const { + props: o, + attrs: c, + vnode: { patchFlag: s } + } = e, d = Te(o), [u] = e.propsOptions; + let m = !1; + if ( + // always force full diff in dev + // - #1942 if hmr is enabled with sfc component + // - vite#872 non-sfc component used by sfc component + (r || s > 0) && !(s & 16) + ) { + if (s & 8) { + const f = e.vnode.dynamicProps; + for (let V = 0; V < f.length; V++) { + let y = f[V]; + if (pn(e.emitsOptions, y)) + continue; + const v = t[y]; + if (u) + if (Ee(c, y)) + v !== c[y] && (c[y] = v, m = !0); + else { + const J = Vt(y); + o[J] = _n( + u, + d, + J, + v, + e, + !1 + ); + } + else + v !== c[y] && (c[y] = v, m = !0); + } + } + } else { + ki(e, t, o, c) && (m = !0); + let f; + for (const V in d) + (!t || // for camelCase + !Ee(t, V) && // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + ((f = al(V)) === V || !Ee(t, f))) && (u ? l && // for camelCase + (l[V] !== void 0 || // for kebab-case + l[f] !== void 0) && (o[V] = _n( + u, + d, + V, + void 0, + e, + !0 + )) : delete o[V]); + if (c !== d) + for (const V in c) + (!t || !Ee(t, V)) && (delete c[V], m = !0); + } + m && Ct(e.attrs, "set", ""); +} +function ki(e, t, l, r) { + const [o, c] = e.propsOptions; + let s = !1, d; + if (t) + for (let u in t) { + if (Gl(u)) + continue; + const m = t[u]; + let f; + o && Ee(o, f = Vt(u)) ? !c || !c.includes(f) ? l[f] = m : (d || (d = {}))[f] = m : pn(e.emitsOptions, u) || (!(u in r) || m !== r[u]) && (r[u] = m, s = !0); + } + if (c) { + const u = Te(l), m = d || Ae; + for (let f = 0; f < c.length; f++) { + const V = c[f]; + l[V] = _n( + o, + u, + V, + m[V], + e, + !Ee(m, V) + ); + } + } + return s; +} +function _n(e, t, l, r, o, c) { + const s = e[l]; + if (s != null) { + const d = Ee(s, "default"); + if (d && r === void 0) { + const u = s.default; + if (s.type !== Function && !s.skipFactory && ge(u)) { + const { propsDefaults: m } = o; + if (l in m) + r = m[l]; + else { + const f = mo(o); + r = m[l] = u.call( + null, + t + ), f(); + } + } else + r = u; + } + s[ + 0 + /* shouldCast */ + ] && (c && !d ? r = !1 : s[ + 1 + /* shouldCastTrue */ + ] && (r === "" || r === al(l)) && (r = !0)); + } + return r; +} +const jp = /* @__PURE__ */ new WeakMap(); +function gi(e, t, l = !1) { + const r = l ? jp : t.propsCache, o = r.get(e); + if (o) + return o; + const c = e.props, s = {}, d = []; + let u = !1; + if (!ge(e)) { + const f = (V) => { + u = !0; + const [y, v] = gi(V, t, !0); + Ne(s, y), v && d.push(...v); + }; + !l && t.mixins.length && t.mixins.forEach(f), e.extends && f(e.extends), e.mixins && e.mixins.forEach(f); + } + if (!c && !u) + return Je(e) && r.set(e, jl), jl; + if (fe(c)) + for (let f = 0; f < c.length; f++) { + const V = Vt(c[f]); + ys(V) && (s[V] = Ae); + } + else if (c) + for (const f in c) { + const V = Vt(f); + if (ys(V)) { + const y = c[f], v = s[V] = fe(y) || ge(y) ? { type: y } : Ne({}, y), J = v.type; + let C = !1, z = !0; + if (fe(J)) + for (let L = 0; L < J.length; ++L) { + const O = J[L], F = ge(O) && O.name; + if (F === "Boolean") { + C = !0; + break; + } else F === "String" && (z = !1); + } + else + C = ge(J) && J.name === "Boolean"; + v[ + 0 + /* shouldCast */ + ] = C, v[ + 1 + /* shouldCastTrue */ + ] = z, (C || Ee(v, "default")) && d.push(V); + } + } + const m = [s, d]; + return Je(e) && r.set(e, m), m; +} +function ys(e) { + return e[0] !== "$" && !Gl(e); +} +const xi = (e) => e[0] === "_" || e === "$stable", Sr = (e) => fe(e) ? e.map(St) : [St(e)], Tp = (e, t, l) => { + if (t._n) + return t; + const r = a((...o) => (Yt.NODE_ENV !== "production" && Ze && (!l || (l.root, Ze.root)), Sr(t(...o))), l); + return r._c = !1, r; +}, Si = (e, t, l) => { + const r = e._ctx; + for (const o in e) { + if (xi(o)) continue; + const c = e[o]; + if (ge(c)) + t[o] = Tp(o, c, r); + else if (c != null) { + const s = Sr(c); + t[o] = () => s; + } + } +}, Ri = (e, t) => { + const l = Sr(t); + e.slots.default = () => l; +}, vi = (e, t, l) => { + for (const r in t) + (l || r !== "_") && (e[r] = t[r]); +}, Ep = (e, t, l) => { + const r = e.slots = yi(); + if (e.vnode.shapeFlag & 32) { + const o = t._; + o ? (vi(r, t, l), l && Ka(r, "_", o, !0)) : Si(t, r); + } else t && Ri(e, t); +}, Lp = (e, t, l) => { + const { vnode: r, slots: o } = e; + let c = !0, s = Ae; + if (r.shapeFlag & 32) { + const d = t._; + d ? l && d === 1 ? c = !1 : vi(o, t, l) : (c = !t.$stable, Si(t, o)), s = t; + } else t && (Ri(e, t), s = { default: 1 }); + if (c) + for (const d in o) + !xi(d) && s[d] == null && delete o[d]; +}; +function $n(e, t, l, r, o = !1) { + if (fe(e)) { + e.forEach( + (y, v) => $n( + y, + t && (fe(t) ? t[v] : t), + l, + r, + o + ) + ); + return; + } + if (Bl(r) && !o) + return; + const c = r.shapeFlag & 4 ? hn(r.component) : r.el, s = o ? null : c, { i: d, r: u } = e, m = t && t.r, f = d.refs === Ae ? d.refs = {} : d.refs, V = d.setupState; + if (m != null && m !== u && (Xe(m) ? (f[m] = null, Ee(V, m) && (V[m] = null)) : Ye(m) && (m.value = null)), ge(u)) + Mt(u, d, 12, [s, f]); + else { + const y = Xe(u), v = Ye(u); + if (y || v) { + const J = () => { + if (e.f) { + const C = y ? Ee(V, u) ? V[u] : f[u] : u.value; + o ? fe(C) && pr(C, c) : fe(C) ? C.includes(c) || C.push(c) : y ? (f[u] = [c], Ee(V, u) && (V[u] = f[u])) : (u.value = [c], e.k && (f[e.k] = u.value)); + } else y ? (f[u] = s, Ee(V, u) && (V[u] = s)) : v && (u.value = s, e.k && (f[e.k] = s)); + }; + s ? (J.id = -1, tt(J, l)) : J(); + } + } +} +const Ii = Symbol("_vte"), Cp = (e) => e.__isTeleport, $l = (e) => e && (e.disabled || e.disabled === ""), qs = (e) => typeof SVGElement < "u" && e instanceof SVGElement, ks = (e) => typeof MathMLElement == "function" && e instanceof MathMLElement, er = (e, t) => { + const l = e && e.to; + return Xe(l) ? t ? t(l) : null : l; +}, Mp = { + name: "Teleport", + __isTeleport: !0, + process(e, t, l, r, o, c, s, d, u, m) { + const { + mc: f, + pc: V, + pbc: y, + o: { insert: v, querySelector: J, createText: C, createComment: z } + } = m, L = $l(t.props); + let { shapeFlag: O, children: F, dynamicChildren: Q } = t; + if (e == null) { + const de = t.el = C(""), P = t.anchor = C(""); + v(de, l, r), v(P, l, r); + const te = t.target = er(t.props, J), Ve = Ui(te, t, C, v); + te && (s === "svg" || qs(te) ? s = "svg" : (s === "mathml" || ks(te)) && (s = "mathml")); + const D = (ue, me) => { + O & 16 && f( + F, + ue, + me, + o, + c, + s, + d, + u + ); + }; + L ? D(l, P) : te && D(te, Ve); + } else { + t.el = e.el, t.targetStart = e.targetStart; + const de = t.anchor = e.anchor, P = t.target = e.target, te = t.targetAnchor = e.targetAnchor, Ve = $l(e.props), D = Ve ? l : P, ue = Ve ? de : te; + if (s === "svg" || qs(P) ? s = "svg" : (s === "mathml" || ks(P)) && (s = "mathml"), Q ? (y( + e.dynamicChildren, + Q, + D, + o, + c, + s, + d + ), Rr(e, t, !0)) : u || V( + e, + t, + D, + ue, + o, + c, + s, + d, + !1 + ), L) + Ve ? t.props && e.props && t.props.to !== e.props.to && (t.props.to = e.props.to) : Io( + t, + l, + de, + m, + 1 + ); + else if ((t.props && t.props.to) !== (e.props && e.props.to)) { + const me = t.target = er( + t.props, + J + ); + me && Io( + t, + me, + null, + m, + 0 + ); + } else Ve && Io( + t, + P, + te, + m, + 1 + ); + } + Ki(t); + }, + remove(e, t, l, { um: r, o: { remove: o } }, c) { + const { + shapeFlag: s, + children: d, + anchor: u, + targetStart: m, + targetAnchor: f, + target: V, + props: y + } = e; + if (V && (o(m), o(f)), c && o(u), s & 16) { + const v = c || !$l(y); + for (let J = 0; J < d.length; J++) { + const C = d[J]; + r( + C, + t, + l, + v, + !!C.dynamicChildren + ); + } + } + }, + move: Io, + hydrate: Jp +}; +function Io(e, t, l, { o: { insert: r }, m: o }, c = 2) { + c === 0 && r(e.targetAnchor, t, l); + const { el: s, anchor: d, shapeFlag: u, children: m, props: f } = e, V = c === 2; + if (V && r(s, t, l), (!V || $l(f)) && u & 16) + for (let y = 0; y < m.length; y++) + o( + m[y], + t, + l, + 2 + ); + V && r(d, t, l); +} +function Jp(e, t, l, r, o, c, { + o: { nextSibling: s, parentNode: d, querySelector: u, insert: m, createText: f } +}, V) { + const y = t.target = er( + t.props, + u + ); + if (y) { + const v = y._lpa || y.firstChild; + if (t.shapeFlag & 16) + if ($l(t.props)) + t.anchor = V( + s(e), + t, + d(e), + l, + r, + o, + c + ), t.targetStart = v, t.targetAnchor = v && s(v); + else { + t.anchor = s(e); + let J = v; + for (; J; ) { + if (J && J.nodeType === 8) { + if (J.data === "teleport start anchor") + t.targetStart = J; + else if (J.data === "teleport anchor") { + t.targetAnchor = J, y._lpa = t.targetAnchor && s(t.targetAnchor); + break; + } + } + J = s(J); + } + t.targetAnchor || Ui(y, t, f, m), V( + v && s(v), + t, + y, + l, + r, + o, + c + ); + } + Ki(t); + } + return t.anchor && s(t.anchor); +} +const Ap = Mp; +function Ki(e) { + const t = e.ctx; + if (t && t.ut) { + let l = e.children[0].el; + for (; l && l !== e.targetAnchor; ) + l.nodeType === 1 && l.setAttribute("data-v-owner", t.uid), l = l.nextSibling; + t.ut(); + } +} +function Ui(e, t, l, r) { + const o = t.targetStart = l(""), c = t.targetAnchor = l(""); + return o[Ii] = c, e && (r(o, e), r(c, e)), c; +} +const tt = Dp; +function wp(e) { + return Wp(e); +} +function Wp(e, t) { + const l = Ua(); + l.__VUE__ = !0; + const { + insert: r, + remove: o, + patchProp: c, + createElement: s, + createText: d, + createComment: u, + setText: m, + setElementText: f, + parentNode: V, + nextSibling: y, + setScopeId: v = rt, + insertStaticContent: J + } = e, C = (S, I, M, Z = null, X = null, G = null, le = void 0, _ = null, $ = !!I.dynamicChildren) => { + if (S === I) + return; + S && !hl(S, I) && (Z = W(S), Be(S, X, G, !0), S = null), I.patchFlag === -2 && ($ = !1, I.dynamicChildren = null); + const { type: H, ref: re, shapeFlag: he } = I; + switch (H) { + case mn: + z(S, I, M, Z); + break; + case lt: + L(S, I, M, Z); + break; + case jn: + S == null && O(I, M, Z, le); + break; + case N: + Y( + S, + I, + M, + Z, + X, + G, + le, + _, + $ + ); + break; + default: + he & 1 ? de( + S, + I, + M, + Z, + X, + G, + le, + _, + $ + ) : he & 6 ? xe( + S, + I, + M, + Z, + X, + G, + le, + _, + $ + ) : (he & 64 || he & 128) && H.process( + S, + I, + M, + Z, + X, + G, + le, + _, + $, + ae + ); + } + re != null && X && $n(re, S && S.ref, G, I || S, !I); + }, z = (S, I, M, Z) => { + if (S == null) + r( + I.el = d(I.children), + M, + Z + ); + else { + const X = I.el = S.el; + I.children !== S.children && m(X, I.children); + } + }, L = (S, I, M, Z) => { + S == null ? r( + I.el = u(I.children || ""), + M, + Z + ) : I.el = S.el; + }, O = (S, I, M, Z) => { + [S.el, S.anchor] = J( + S.children, + I, + M, + Z, + S.el, + S.anchor + ); + }, F = ({ el: S, anchor: I }, M, Z) => { + let X; + for (; S && S !== I; ) + X = y(S), r(S, M, Z), S = X; + r(I, M, Z); + }, Q = ({ el: S, anchor: I }) => { + let M; + for (; S && S !== I; ) + M = y(S), o(S), S = M; + o(I); + }, de = (S, I, M, Z, X, G, le, _, $) => { + I.type === "svg" ? le = "svg" : I.type === "math" && (le = "mathml"), S == null ? P( + I, + M, + Z, + X, + G, + le, + _, + $ + ) : D( + S, + I, + X, + G, + le, + _, + $ + ); + }, P = (S, I, M, Z, X, G, le, _) => { + let $, H; + const { props: re, shapeFlag: he, transition: pe, dirs: Ke } = S; + if ($ = S.el = s( + S.type, + G, + re && re.is, + re + ), he & 8 ? f($, S.children) : he & 16 && Ve( + S.children, + $, + null, + Z, + X, + Kn(S, G), + le, + _ + ), Ke && il(S, null, Z, "created"), te($, S, S.scopeId, le, Z), re) { + for (const Fe in re) + Fe !== "value" && !Gl(Fe) && c($, Fe, null, re[Fe], G, Z); + "value" in re && c($, "value", null, re.value, G), (H = re.onVnodeBeforeMount) && gt(H, Z, S); + } + Ke && il(S, null, Z, "beforeMount"); + const je = Op(X, pe); + je && pe.beforeEnter($), r($, I, M), ((H = re && re.onVnodeMounted) || je || Ke) && tt(() => { + H && gt(H, Z, S), je && pe.enter($), Ke && il(S, null, Z, "mounted"); + }, X); + }, te = (S, I, M, Z, X) => { + if (M && v(S, M), Z) + for (let G = 0; G < Z.length; G++) + v(S, Z[G]); + if (X) { + let G = X.subTree; + if (I === G) { + const le = X.vnode; + te( + S, + le, + le.scopeId, + le.slotScopeIds, + X.parent + ); + } + } + }, Ve = (S, I, M, Z, X, G, le, _, $ = 0) => { + for (let H = $; H < S.length; H++) { + const re = S[H] = _ ? Dt(S[H]) : St(S[H]); + C( + null, + re, + I, + M, + Z, + X, + G, + le, + _ + ); + } + }, D = (S, I, M, Z, X, G, le) => { + const _ = I.el = S.el; + let { patchFlag: $, dynamicChildren: H, dirs: re } = I; + $ |= S.patchFlag & 16; + const he = S.props || Ae, pe = I.props || Ae; + let Ke; + if (M && cl(M, !1), (Ke = pe.onVnodeBeforeUpdate) && gt(Ke, M, I, S), re && il(I, S, M, "beforeUpdate"), M && cl(M, !0), (he.innerHTML && pe.innerHTML == null || he.textContent && pe.textContent == null) && f(_, ""), H ? ue( + S.dynamicChildren, + H, + _, + M, + Z, + Kn(I, X), + G + ) : le || ve( + S, + I, + _, + null, + M, + Z, + Kn(I, X), + G, + !1 + ), $ > 0) { + if ($ & 16) + me(_, he, pe, M, X); + else if ($ & 2 && he.class !== pe.class && c(_, "class", null, pe.class, X), $ & 4 && c(_, "style", he.style, pe.style, X), $ & 8) { + const je = I.dynamicProps; + for (let Fe = 0; Fe < je.length; Fe++) { + const Ce = je[Fe], ze = he[Ce], mt = pe[Ce]; + (mt !== ze || Ce === "value") && c(_, Ce, ze, mt, X, M); + } + } + $ & 1 && S.children !== I.children && f(_, I.children); + } else !le && H == null && me(_, he, pe, M, X); + ((Ke = pe.onVnodeUpdated) || re) && tt(() => { + Ke && gt(Ke, M, I, S), re && il(I, S, M, "updated"); + }, Z); + }, ue = (S, I, M, Z, X, G, le) => { + for (let _ = 0; _ < I.length; _++) { + const $ = S[_], H = I[_], re = ( + // oldVNode may be an errored async setup() component inside Suspense + // which will not have a mounted element + $.el && // - In the case of a Fragment, we need to provide the actual parent + // of the Fragment itself so it can move its children. + ($.type === N || // - In the case of different nodes, there is going to be a replacement + // which also requires the correct parent container + !hl($, H) || // - In the case of a component, it could contain anything. + $.shapeFlag & 70) ? V($.el) : ( + // In other cases, the parent container is not actually used so we + // just pass the block element here to avoid a DOM parentNode call. + M + ) + ); + C( + $, + H, + re, + null, + Z, + X, + G, + le, + !0 + ); + } + }, me = (S, I, M, Z, X) => { + if (I !== M) { + if (I !== Ae) + for (const G in I) + !Gl(G) && !(G in M) && c( + S, + G, + I[G], + null, + X, + Z + ); + for (const G in M) { + if (Gl(G)) continue; + const le = M[G], _ = I[G]; + le !== _ && G !== "value" && c(S, G, _, le, X, Z); + } + "value" in M && c(S, "value", I.value, M.value, X); + } + }, Y = (S, I, M, Z, X, G, le, _, $) => { + const H = I.el = S ? S.el : d(""), re = I.anchor = S ? S.anchor : d(""); + let { patchFlag: he, dynamicChildren: pe, slotScopeIds: Ke } = I; + Ke && (_ = _ ? _.concat(Ke) : Ke), S == null ? (r(H, M, Z), r(re, M, Z), Ve( + // #10007 + // such fragment like `<>` will be compiled into + // a fragment which doesn't have a children. + // In this case fallback to an empty array + I.children || [], + M, + re, + X, + G, + le, + _, + $ + )) : he > 0 && he & 64 && pe && // #2715 the previous fragment could've been a BAILed one as a result + // of renderSlot() with no valid children + S.dynamicChildren ? (ue( + S.dynamicChildren, + pe, + M, + X, + G, + le, + _ + ), // #2080 if the stable fragment has a key, it's a