diff --git a/docs/.vuepress/.cache/deps/@vue_devtools-api.js b/docs/.vuepress/.cache/deps/@vue_devtools-api.js index 1f022d4..d4333c3 100644 --- a/docs/.vuepress/.cache/deps/@vue_devtools-api.js +++ b/docs/.vuepress/.cache/deps/@vue_devtools-api.js @@ -2,7 +2,7 @@ import { isPerformanceSupported, now, setupDevtoolsPlugin -} from "./chunk-UKCZNIRO.js"; +} from "./chunk-NTV4DQBC.js"; export { isPerformanceSupported, now, diff --git a/docs/.vuepress/.cache/deps/@vuepress_shared.js.map b/docs/.vuepress/.cache/deps/@vuepress_shared.js.map index 80d07ce..4775e4a 100644 --- a/docs/.vuepress/.cache/deps/@vuepress_shared.js.map +++ b/docs/.vuepress/.cache/deps/@vuepress_shared.js.map @@ -1,7 +1,7 @@ { "version": 3, "sources": ["../../../../node_modules/@vuepress/shared/dist/index.js"], - "sourcesContent": ["// src/utils/links/isLinkWithProtocol.ts\nvar isLinkWithProtocol = (link) => /^[a-z][a-z0-9+.-]*:/.test(link) || link.startsWith(\"//\");\n\n// src/utils/links/isLinkExternal.ts\nvar markdownLinkRegexp = /.md((\\?|#).*)?$/;\nvar isLinkExternal = (link, base = \"/\") => isLinkWithProtocol(link) || // absolute link that does not start with `base` and does not end with `.md`\nlink.startsWith(\"/\") && !link.startsWith(base) && !markdownLinkRegexp.test(link);\n\n// src/utils/links/isLinkHttp.ts\nvar isLinkHttp = (link) => /^(https?:)?\\/\\//.test(link);\n\n// src/utils/routes/inferRoutePath.ts\nvar inferRoutePath = (path) => {\n if (!path || path.endsWith(\"/\")) return path;\n let routePath = path.replace(/(^|\\/)README.md$/i, \"$1index.html\");\n if (routePath.endsWith(\".md\")) {\n routePath = routePath.substring(0, routePath.length - 3) + \".html\";\n } else if (!routePath.endsWith(\".html\")) {\n routePath = routePath + \".html\";\n }\n if (routePath.endsWith(\"/index.html\")) {\n routePath = routePath.substring(0, routePath.length - 10);\n }\n return routePath;\n};\n\n// src/utils/routes/normalizeRoutePath.ts\nvar FAKE_HOST = \"http://.\";\nvar normalizeRoutePath = (pathname, current) => {\n if (!pathname.startsWith(\"/\") && current) {\n const loc = current.slice(0, current.lastIndexOf(\"/\"));\n return inferRoutePath(new URL(`${loc}/${pathname}`, FAKE_HOST).pathname);\n }\n return inferRoutePath(pathname);\n};\n\n// src/utils/routes/resolveLocalePath.ts\nvar resolveLocalePath = (locales, routePath) => {\n const localePaths = Object.keys(locales).sort((a, b) => {\n const levelDelta = b.split(\"/\").length - a.split(\"/\").length;\n if (levelDelta !== 0) {\n return levelDelta;\n }\n return b.length - a.length;\n });\n for (const localePath of localePaths) {\n if (routePath.startsWith(localePath)) {\n return localePath;\n }\n }\n return \"/\";\n};\n\n// src/utils/routes/resolveRoutePathFromUrl.ts\nvar resolveRoutePathFromUrl = (url, base = \"/\") => {\n const pathname = url.replace(/^(?:https?:)?\\/\\/[^/]*/, \"\");\n return pathname.startsWith(base) ? `/${pathname.slice(base.length)}` : pathname;\n};\n\n// src/utils/routes/splitPath.ts\nvar SPLIT_CHAR_REGEXP = /(#|\\?)/;\nvar splitPath = (path) => {\n const [pathname, ...hashAndQueries] = path.split(SPLIT_CHAR_REGEXP);\n return {\n pathname,\n hashAndQueries: hashAndQueries.join(\"\")\n };\n};\n\n// src/utils/resolveHeadIdentifier.ts\nvar TAGS_ALLOWED = [\"link\", \"meta\", \"script\", \"style\", \"noscript\", \"template\"];\nvar TAGS_UNIQUE = [\"title\", \"base\"];\nvar resolveHeadIdentifier = ([tag, attrs, content]) => {\n if (TAGS_UNIQUE.includes(tag)) {\n return tag;\n }\n if (!TAGS_ALLOWED.includes(tag)) {\n return null;\n }\n if (tag === \"meta\" && attrs.name) {\n return `${tag}.${attrs.name}`;\n }\n if (tag === \"template\" && attrs.id) {\n return `${tag}.${attrs.id}`;\n }\n return JSON.stringify([\n tag,\n Object.entries(attrs).map(([key, value]) => {\n if (typeof value === \"boolean\") {\n return value ? [key, \"\"] : null;\n }\n return [key, value];\n }).filter((item) => item != null).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)),\n content\n ]);\n};\n\n// src/utils/dedupeHead.ts\nvar dedupeHead = (head) => {\n const identifierSet = /* @__PURE__ */ new Set();\n const result = [];\n head.forEach((item) => {\n const identifier = resolveHeadIdentifier(item);\n if (identifier && !identifierSet.has(identifier)) {\n identifierSet.add(identifier);\n result.push(item);\n }\n });\n return result;\n};\n\n// src/utils/ensureLeadingSlash.ts\nvar ensureLeadingSlash = (str) => str[0] === \"/\" ? str : `/${str}`;\n\n// src/utils/ensureEndingSlash.ts\nvar ensureEndingSlash = (str) => str[str.length - 1] === \"/\" || str.endsWith(\".html\") ? str : `${str}/`;\n\n// src/utils/formatDateString.ts\nvar formatDateString = (str, defaultDateString = \"\") => {\n const dateMatch = str.match(/\\b(\\d{4})-(\\d{1,2})-(\\d{1,2})\\b/);\n if (dateMatch === null) {\n return defaultDateString;\n }\n const [, yearStr, monthStr, dayStr] = dateMatch;\n return [yearStr, monthStr.padStart(2, \"0\"), dayStr.padStart(2, \"0\")].join(\"-\");\n};\n\n// src/utils/omit.ts\nvar omit = (obj, ...keys) => {\n const result = { ...obj };\n for (const key of keys) {\n delete result[key];\n }\n return result;\n};\n\n// src/utils/removeEndingSlash.ts\nvar removeEndingSlash = (str) => str[str.length - 1] === \"/\" ? str.slice(0, -1) : str;\n\n// src/utils/removeLeadingSlash.ts\nvar removeLeadingSlash = (str) => str[0] === \"/\" ? str.slice(1) : str;\n\n// src/utils/typeGuards.ts\nvar isFunction = (val) => typeof val === \"function\";\nvar isPlainObject = (val) => Object.prototype.toString.call(val) === \"[object Object]\";\nvar isString = (val) => typeof val === \"string\";\nexport {\n dedupeHead,\n ensureEndingSlash,\n ensureLeadingSlash,\n formatDateString,\n inferRoutePath,\n isFunction,\n isLinkExternal,\n isLinkHttp,\n isLinkWithProtocol,\n isPlainObject,\n isString,\n normalizeRoutePath,\n omit,\n removeEndingSlash,\n removeLeadingSlash,\n resolveHeadIdentifier,\n resolveLocalePath,\n resolveRoutePathFromUrl,\n splitPath\n};\n"], + "sourcesContent": ["// src/utils/links/isLinkWithProtocol.ts\r\nvar isLinkWithProtocol = (link) => /^[a-z][a-z0-9+.-]*:/.test(link) || link.startsWith(\"//\");\r\n\r\n// src/utils/links/isLinkExternal.ts\r\nvar markdownLinkRegexp = /.md((\\?|#).*)?$/;\r\nvar isLinkExternal = (link, base = \"/\") => isLinkWithProtocol(link) || // absolute link that does not start with `base` and does not end with `.md`\r\nlink.startsWith(\"/\") && !link.startsWith(base) && !markdownLinkRegexp.test(link);\r\n\r\n// src/utils/links/isLinkHttp.ts\r\nvar isLinkHttp = (link) => /^(https?:)?\\/\\//.test(link);\r\n\r\n// src/utils/routes/inferRoutePath.ts\r\nvar inferRoutePath = (path) => {\r\n if (!path || path.endsWith(\"/\")) return path;\r\n let routePath = path.replace(/(^|\\/)README.md$/i, \"$1index.html\");\r\n if (routePath.endsWith(\".md\")) {\r\n routePath = routePath.substring(0, routePath.length - 3) + \".html\";\r\n } else if (!routePath.endsWith(\".html\")) {\r\n routePath = routePath + \".html\";\r\n }\r\n if (routePath.endsWith(\"/index.html\")) {\r\n routePath = routePath.substring(0, routePath.length - 10);\r\n }\r\n return routePath;\r\n};\r\n\r\n// src/utils/routes/normalizeRoutePath.ts\r\nvar FAKE_HOST = \"http://.\";\r\nvar normalizeRoutePath = (pathname, current) => {\r\n if (!pathname.startsWith(\"/\") && current) {\r\n const loc = current.slice(0, current.lastIndexOf(\"/\"));\r\n return inferRoutePath(new URL(`${loc}/${pathname}`, FAKE_HOST).pathname);\r\n }\r\n return inferRoutePath(pathname);\r\n};\r\n\r\n// src/utils/routes/resolveLocalePath.ts\r\nvar resolveLocalePath = (locales, routePath) => {\r\n const localePaths = Object.keys(locales).sort((a, b) => {\r\n const levelDelta = b.split(\"/\").length - a.split(\"/\").length;\r\n if (levelDelta !== 0) {\r\n return levelDelta;\r\n }\r\n return b.length - a.length;\r\n });\r\n for (const localePath of localePaths) {\r\n if (routePath.startsWith(localePath)) {\r\n return localePath;\r\n }\r\n }\r\n return \"/\";\r\n};\r\n\r\n// src/utils/routes/resolveRoutePathFromUrl.ts\r\nvar resolveRoutePathFromUrl = (url, base = \"/\") => {\r\n const pathname = url.replace(/^(?:https?:)?\\/\\/[^/]*/, \"\");\r\n return pathname.startsWith(base) ? `/${pathname.slice(base.length)}` : pathname;\r\n};\r\n\r\n// src/utils/routes/splitPath.ts\r\nvar SPLIT_CHAR_REGEXP = /(#|\\?)/;\r\nvar splitPath = (path) => {\r\n const [pathname, ...hashAndQueries] = path.split(SPLIT_CHAR_REGEXP);\r\n return {\r\n pathname,\r\n hashAndQueries: hashAndQueries.join(\"\")\r\n };\r\n};\r\n\r\n// src/utils/resolveHeadIdentifier.ts\r\nvar TAGS_ALLOWED = [\"link\", \"meta\", \"script\", \"style\", \"noscript\", \"template\"];\r\nvar TAGS_UNIQUE = [\"title\", \"base\"];\r\nvar resolveHeadIdentifier = ([tag, attrs, content]) => {\r\n if (TAGS_UNIQUE.includes(tag)) {\r\n return tag;\r\n }\r\n if (!TAGS_ALLOWED.includes(tag)) {\r\n return null;\r\n }\r\n if (tag === \"meta\" && attrs.name) {\r\n return `${tag}.${attrs.name}`;\r\n }\r\n if (tag === \"template\" && attrs.id) {\r\n return `${tag}.${attrs.id}`;\r\n }\r\n return JSON.stringify([\r\n tag,\r\n Object.entries(attrs).map(([key, value]) => {\r\n if (typeof value === \"boolean\") {\r\n return value ? [key, \"\"] : null;\r\n }\r\n return [key, value];\r\n }).filter((item) => item != null).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)),\r\n content\r\n ]);\r\n};\r\n\r\n// src/utils/dedupeHead.ts\r\nvar dedupeHead = (head) => {\r\n const identifierSet = /* @__PURE__ */ new Set();\r\n const result = [];\r\n head.forEach((item) => {\r\n const identifier = resolveHeadIdentifier(item);\r\n if (identifier && !identifierSet.has(identifier)) {\r\n identifierSet.add(identifier);\r\n result.push(item);\r\n }\r\n });\r\n return result;\r\n};\r\n\r\n// src/utils/ensureLeadingSlash.ts\r\nvar ensureLeadingSlash = (str) => str[0] === \"/\" ? str : `/${str}`;\r\n\r\n// src/utils/ensureEndingSlash.ts\r\nvar ensureEndingSlash = (str) => str[str.length - 1] === \"/\" || str.endsWith(\".html\") ? str : `${str}/`;\r\n\r\n// src/utils/formatDateString.ts\r\nvar formatDateString = (str, defaultDateString = \"\") => {\r\n const dateMatch = str.match(/\\b(\\d{4})-(\\d{1,2})-(\\d{1,2})\\b/);\r\n if (dateMatch === null) {\r\n return defaultDateString;\r\n }\r\n const [, yearStr, monthStr, dayStr] = dateMatch;\r\n return [yearStr, monthStr.padStart(2, \"0\"), dayStr.padStart(2, \"0\")].join(\"-\");\r\n};\r\n\r\n// src/utils/omit.ts\r\nvar omit = (obj, ...keys) => {\r\n const result = { ...obj };\r\n for (const key of keys) {\r\n delete result[key];\r\n }\r\n return result;\r\n};\r\n\r\n// src/utils/removeEndingSlash.ts\r\nvar removeEndingSlash = (str) => str[str.length - 1] === \"/\" ? str.slice(0, -1) : str;\r\n\r\n// src/utils/removeLeadingSlash.ts\r\nvar removeLeadingSlash = (str) => str[0] === \"/\" ? str.slice(1) : str;\r\n\r\n// src/utils/typeGuards.ts\r\nvar isFunction = (val) => typeof val === \"function\";\r\nvar isPlainObject = (val) => Object.prototype.toString.call(val) === \"[object Object]\";\r\nvar isString = (val) => typeof val === \"string\";\r\nexport {\r\n dedupeHead,\r\n ensureEndingSlash,\r\n ensureLeadingSlash,\r\n formatDateString,\r\n inferRoutePath,\r\n isFunction,\r\n isLinkExternal,\r\n isLinkHttp,\r\n isLinkWithProtocol,\r\n isPlainObject,\r\n isString,\r\n normalizeRoutePath,\r\n omit,\r\n removeEndingSlash,\r\n removeLeadingSlash,\r\n resolveHeadIdentifier,\r\n resolveLocalePath,\r\n resolveRoutePathFromUrl,\r\n splitPath\r\n};\r\n"], "mappings": ";AACA,IAAI,qBAAqB,CAAC,SAAS,sBAAsB,KAAK,IAAI,KAAK,KAAK,WAAW,IAAI;AAG3F,IAAI,qBAAqB;AACzB,IAAI,iBAAiB,CAAC,MAAM,OAAO,QAAQ,mBAAmB,IAAI;AAClE,KAAK,WAAW,GAAG,KAAK,CAAC,KAAK,WAAW,IAAI,KAAK,CAAC,mBAAmB,KAAK,IAAI;AAG/E,IAAI,aAAa,CAAC,SAAS,kBAAkB,KAAK,IAAI;AAGtD,IAAI,iBAAiB,CAAC,SAAS;AAC7B,MAAI,CAAC,QAAQ,KAAK,SAAS,GAAG,EAAG,QAAO;AACxC,MAAI,YAAY,KAAK,QAAQ,qBAAqB,cAAc;AAChE,MAAI,UAAU,SAAS,KAAK,GAAG;AAC7B,gBAAY,UAAU,UAAU,GAAG,UAAU,SAAS,CAAC,IAAI;AAAA,EAC7D,WAAW,CAAC,UAAU,SAAS,OAAO,GAAG;AACvC,gBAAY,YAAY;AAAA,EAC1B;AACA,MAAI,UAAU,SAAS,aAAa,GAAG;AACrC,gBAAY,UAAU,UAAU,GAAG,UAAU,SAAS,EAAE;AAAA,EAC1D;AACA,SAAO;AACT;AAGA,IAAI,YAAY;AAChB,IAAI,qBAAqB,CAAC,UAAU,YAAY;AAC9C,MAAI,CAAC,SAAS,WAAW,GAAG,KAAK,SAAS;AACxC,UAAM,MAAM,QAAQ,MAAM,GAAG,QAAQ,YAAY,GAAG,CAAC;AACrD,WAAO,eAAe,IAAI,IAAI,GAAG,GAAG,IAAI,QAAQ,IAAI,SAAS,EAAE,QAAQ;AAAA,EACzE;AACA,SAAO,eAAe,QAAQ;AAChC;AAGA,IAAI,oBAAoB,CAAC,SAAS,cAAc;AAC9C,QAAM,cAAc,OAAO,KAAK,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM;AACtD,UAAM,aAAa,EAAE,MAAM,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,EAAE;AACtD,QAAI,eAAe,GAAG;AACpB,aAAO;AAAA,IACT;AACA,WAAO,EAAE,SAAS,EAAE;AAAA,EACtB,CAAC;AACD,aAAW,cAAc,aAAa;AACpC,QAAI,UAAU,WAAW,UAAU,GAAG;AACpC,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAGA,IAAI,0BAA0B,CAAC,KAAK,OAAO,QAAQ;AACjD,QAAM,WAAW,IAAI,QAAQ,0BAA0B,EAAE;AACzD,SAAO,SAAS,WAAW,IAAI,IAAI,IAAI,SAAS,MAAM,KAAK,MAAM,CAAC,KAAK;AACzE;AAGA,IAAI,oBAAoB;AACxB,IAAI,YAAY,CAAC,SAAS;AACxB,QAAM,CAAC,UAAU,GAAG,cAAc,IAAI,KAAK,MAAM,iBAAiB;AAClE,SAAO;AAAA,IACL;AAAA,IACA,gBAAgB,eAAe,KAAK,EAAE;AAAA,EACxC;AACF;AAGA,IAAI,eAAe,CAAC,QAAQ,QAAQ,UAAU,SAAS,YAAY,UAAU;AAC7E,IAAI,cAAc,CAAC,SAAS,MAAM;AAClC,IAAI,wBAAwB,CAAC,CAAC,KAAK,OAAO,OAAO,MAAM;AACrD,MAAI,YAAY,SAAS,GAAG,GAAG;AAC7B,WAAO;AAAA,EACT;AACA,MAAI,CAAC,aAAa,SAAS,GAAG,GAAG;AAC/B,WAAO;AAAA,EACT;AACA,MAAI,QAAQ,UAAU,MAAM,MAAM;AAChC,WAAO,GAAG,GAAG,IAAI,MAAM,IAAI;AAAA,EAC7B;AACA,MAAI,QAAQ,cAAc,MAAM,IAAI;AAClC,WAAO,GAAG,GAAG,IAAI,MAAM,EAAE;AAAA,EAC3B;AACA,SAAO,KAAK,UAAU;AAAA,IACpB;AAAA,IACA,OAAO,QAAQ,KAAK,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM;AAC1C,UAAI,OAAO,UAAU,WAAW;AAC9B,eAAO,QAAQ,CAAC,KAAK,EAAE,IAAI;AAAA,MAC7B;AACA,aAAO,CAAC,KAAK,KAAK;AAAA,IACpB,CAAC,EAAE,OAAO,CAAC,SAAS,QAAQ,IAAI,EAAE,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,MAAM,KAAK,cAAc,IAAI,CAAC;AAAA,IACnF;AAAA,EACF,CAAC;AACH;AAGA,IAAI,aAAa,CAAC,SAAS;AACzB,QAAM,gBAAgC,oBAAI,IAAI;AAC9C,QAAM,SAAS,CAAC;AAChB,OAAK,QAAQ,CAAC,SAAS;AACrB,UAAM,aAAa,sBAAsB,IAAI;AAC7C,QAAI,cAAc,CAAC,cAAc,IAAI,UAAU,GAAG;AAChD,oBAAc,IAAI,UAAU;AAC5B,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAGA,IAAI,qBAAqB,CAAC,QAAQ,IAAI,CAAC,MAAM,MAAM,MAAM,IAAI,GAAG;AAGhE,IAAI,oBAAoB,CAAC,QAAQ,IAAI,IAAI,SAAS,CAAC,MAAM,OAAO,IAAI,SAAS,OAAO,IAAI,MAAM,GAAG,GAAG;AAGpG,IAAI,mBAAmB,CAAC,KAAK,oBAAoB,OAAO;AACtD,QAAM,YAAY,IAAI,MAAM,iCAAiC;AAC7D,MAAI,cAAc,MAAM;AACtB,WAAO;AAAA,EACT;AACA,QAAM,CAAC,EAAE,SAAS,UAAU,MAAM,IAAI;AACtC,SAAO,CAAC,SAAS,SAAS,SAAS,GAAG,GAAG,GAAG,OAAO,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,GAAG;AAC/E;AAGA,IAAI,OAAO,CAAC,QAAQ,SAAS;AAC3B,QAAM,SAAS,EAAE,GAAG,IAAI;AACxB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,SAAO;AACT;AAGA,IAAI,oBAAoB,CAAC,QAAQ,IAAI,IAAI,SAAS,CAAC,MAAM,MAAM,IAAI,MAAM,GAAG,EAAE,IAAI;AAGlF,IAAI,qBAAqB,CAAC,QAAQ,IAAI,CAAC,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI;AAGlE,IAAI,aAAa,CAAC,QAAQ,OAAO,QAAQ;AACzC,IAAI,gBAAgB,CAAC,QAAQ,OAAO,UAAU,SAAS,KAAK,GAAG,MAAM;AACrE,IAAI,WAAW,CAAC,QAAQ,OAAO,QAAQ;", "names": [] } diff --git a/docs/.vuepress/.cache/deps/_metadata.json b/docs/.vuepress/.cache/deps/_metadata.json index 5e512aa..88940fe 100644 --- a/docs/.vuepress/.cache/deps/_metadata.json +++ b/docs/.vuepress/.cache/deps/_metadata.json @@ -1,40 +1,40 @@ { - "hash": "78a82a1c", - "configHash": "ef6a287c", - "lockfileHash": "b781e717", - "browserHash": "e62197b4", + "hash": "89ee783f", + "configHash": "1edb3381", + "lockfileHash": "907bcbf2", + "browserHash": "3fa51eb6", "optimized": { "@vue/devtools-api": { "src": "../../../../node_modules/@vue/devtools-api/lib/esm/index.js", "file": "@vue_devtools-api.js", - "fileHash": "e8b02faa", + "fileHash": "d59aa06c", "needsInterop": false }, "@vuepress/shared": { "src": "../../../../node_modules/@vuepress/shared/dist/index.js", "file": "@vuepress_shared.js", - "fileHash": "e10ff55e", + "fileHash": "ae8230a1", "needsInterop": false }, "vue": { "src": "../../../../node_modules/vue/dist/vue.runtime.esm-bundler.js", "file": "vue.js", - "fileHash": "410a45c2", + "fileHash": "f279aba4", "needsInterop": false }, "vue-router": { "src": "../../../../node_modules/vue-router/dist/vue-router.esm-bundler.js", "file": "vue-router.js", - "fileHash": "6fe1e35d", + "fileHash": "c28aa327", "needsInterop": false } }, "chunks": { - "chunk-UKCZNIRO": { - "file": "chunk-UKCZNIRO.js" + "chunk-NTV4DQBC": { + "file": "chunk-NTV4DQBC.js" }, - "chunk-CNGU7YNB": { - "file": "chunk-CNGU7YNB.js" + "chunk-7Z6MG4UG": { + "file": "chunk-7Z6MG4UG.js" } } } \ No newline at end of file diff --git a/docs/.vuepress/.cache/deps/chunk-CNGU7YNB.js b/docs/.vuepress/.cache/deps/chunk-7Z6MG4UG.js similarity index 99% rename from docs/.vuepress/.cache/deps/chunk-CNGU7YNB.js rename to docs/.vuepress/.cache/deps/chunk-7Z6MG4UG.js index d4be6a5..2cc3c10 100644 --- a/docs/.vuepress/.cache/deps/chunk-CNGU7YNB.js +++ b/docs/.vuepress/.cache/deps/chunk-7Z6MG4UG.js @@ -11472,4 +11472,4 @@ vue/dist/vue.runtime.esm-bundler.js: * @license MIT **) */ -//# sourceMappingURL=chunk-CNGU7YNB.js.map +//# sourceMappingURL=chunk-7Z6MG4UG.js.map diff --git a/docs/.vuepress/.cache/deps/chunk-7Z6MG4UG.js.map b/docs/.vuepress/.cache/deps/chunk-7Z6MG4UG.js.map new file mode 100644 index 0000000..a9feb83 --- /dev/null +++ b/docs/.vuepress/.cache/deps/chunk-7Z6MG4UG.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../../node_modules/@vue/shared/dist/shared.esm-bundler.js", "../../../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js", "../../../../node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js", "../../../../node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js", "../../../../node_modules/vue/dist/vue.runtime.esm-bundler.js"], + "sourcesContent": ["/**\r\n* @vue/shared v3.4.36\r\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\r\n* @license MIT\r\n**/\r\n/*! #__NO_SIDE_EFFECTS__ */\r\n// @__NO_SIDE_EFFECTS__\r\nfunction makeMap(str, expectsLowerCase) {\r\n const set = new Set(str.split(\",\"));\r\n return expectsLowerCase ? (val) => set.has(val.toLowerCase()) : (val) => set.has(val);\r\n}\r\n\r\nconst EMPTY_OBJ = !!(process.env.NODE_ENV !== \"production\") ? Object.freeze({}) : {};\r\nconst EMPTY_ARR = !!(process.env.NODE_ENV !== \"production\") ? Object.freeze([]) : [];\r\nconst NOOP = () => {\r\n};\r\nconst NO = () => false;\r\nconst isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter\r\n(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);\r\nconst isModelListener = (key) => key.startsWith(\"onUpdate:\");\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n const i = arr.indexOf(el);\r\n if (i > -1) {\r\n arr.splice(i, 1);\r\n }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isMap = (val) => toTypeString(val) === \"[object Map]\";\r\nconst isSet = (val) => toTypeString(val) === \"[object Set]\";\r\nconst isDate = (val) => toTypeString(val) === \"[object Date]\";\r\nconst isRegExp = (val) => toTypeString(val) === \"[object RegExp]\";\r\nconst isFunction = (val) => typeof val === \"function\";\r\nconst isString = (val) => typeof val === \"string\";\r\nconst isSymbol = (val) => typeof val === \"symbol\";\r\nconst isObject = (val) => val !== null && typeof val === \"object\";\r\nconst isPromise = (val) => {\r\n return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n return toTypeString(value).slice(8, -1);\r\n};\r\nconst isPlainObject = (val) => toTypeString(val) === \"[object Object]\";\r\nconst isIntegerKey = (key) => isString(key) && key !== \"NaN\" && key[0] !== \"-\" && \"\" + parseInt(key, 10) === key;\r\nconst isReservedProp = /* @__PURE__ */ makeMap(\r\n // the leading comma is intentional so empty string \"\" is also included\r\n \",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted\"\r\n);\r\nconst isBuiltInDirective = /* @__PURE__ */ makeMap(\r\n \"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo\"\r\n);\r\nconst cacheStringFunction = (fn) => {\r\n const cache = /* @__PURE__ */ Object.create(null);\r\n return (str) => {\r\n const hit = cache[str];\r\n return hit || (cache[str] = fn(str));\r\n };\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\nconst camelize = cacheStringFunction((str) => {\r\n return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : \"\");\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\nconst hyphenate = cacheStringFunction(\r\n (str) => str.replace(hyphenateRE, \"-$1\").toLowerCase()\r\n);\r\nconst capitalize = cacheStringFunction((str) => {\r\n return str.charAt(0).toUpperCase() + str.slice(1);\r\n});\r\nconst toHandlerKey = cacheStringFunction((str) => {\r\n const s = str ? `on${capitalize(str)}` : ``;\r\n return s;\r\n});\r\nconst hasChanged = (value, oldValue) => !Object.is(value, oldValue);\r\nconst invokeArrayFns = (fns, ...arg) => {\r\n for (let i = 0; i < fns.length; i++) {\r\n fns[i](...arg);\r\n }\r\n};\r\nconst def = (obj, key, value, writable = false) => {\r\n Object.defineProperty(obj, key, {\r\n configurable: true,\r\n enumerable: false,\r\n writable,\r\n value\r\n });\r\n};\r\nconst looseToNumber = (val) => {\r\n const n = parseFloat(val);\r\n return isNaN(n) ? val : n;\r\n};\r\nconst toNumber = (val) => {\r\n const n = isString(val) ? Number(val) : NaN;\r\n return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n return _globalThis || (_globalThis = typeof globalThis !== \"undefined\" ? globalThis : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : typeof global !== \"undefined\" ? global : {});\r\n};\r\nconst identRE = /^[_$a-zA-Z\\xA0-\\uFFFF][_$a-zA-Z0-9\\xA0-\\uFFFF]*$/;\r\nfunction genPropsAccessExp(name) {\r\n return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;\r\n}\r\n\r\nconst PatchFlags = {\r\n \"TEXT\": 1,\r\n \"1\": \"TEXT\",\r\n \"CLASS\": 2,\r\n \"2\": \"CLASS\",\r\n \"STYLE\": 4,\r\n \"4\": \"STYLE\",\r\n \"PROPS\": 8,\r\n \"8\": \"PROPS\",\r\n \"FULL_PROPS\": 16,\r\n \"16\": \"FULL_PROPS\",\r\n \"NEED_HYDRATION\": 32,\r\n \"32\": \"NEED_HYDRATION\",\r\n \"STABLE_FRAGMENT\": 64,\r\n \"64\": \"STABLE_FRAGMENT\",\r\n \"KEYED_FRAGMENT\": 128,\r\n \"128\": \"KEYED_FRAGMENT\",\r\n \"UNKEYED_FRAGMENT\": 256,\r\n \"256\": \"UNKEYED_FRAGMENT\",\r\n \"NEED_PATCH\": 512,\r\n \"512\": \"NEED_PATCH\",\r\n \"DYNAMIC_SLOTS\": 1024,\r\n \"1024\": \"DYNAMIC_SLOTS\",\r\n \"DEV_ROOT_FRAGMENT\": 2048,\r\n \"2048\": \"DEV_ROOT_FRAGMENT\",\r\n \"HOISTED\": -1,\r\n \"-1\": \"HOISTED\",\r\n \"BAIL\": -2,\r\n \"-2\": \"BAIL\"\r\n};\r\nconst PatchFlagNames = {\r\n [1]: `TEXT`,\r\n [2]: `CLASS`,\r\n [4]: `STYLE`,\r\n [8]: `PROPS`,\r\n [16]: `FULL_PROPS`,\r\n [32]: `NEED_HYDRATION`,\r\n [64]: `STABLE_FRAGMENT`,\r\n [128]: `KEYED_FRAGMENT`,\r\n [256]: `UNKEYED_FRAGMENT`,\r\n [512]: `NEED_PATCH`,\r\n [1024]: `DYNAMIC_SLOTS`,\r\n [2048]: `DEV_ROOT_FRAGMENT`,\r\n [-1]: `HOISTED`,\r\n [-2]: `BAIL`\r\n};\r\n\r\nconst ShapeFlags = {\r\n \"ELEMENT\": 1,\r\n \"1\": \"ELEMENT\",\r\n \"FUNCTIONAL_COMPONENT\": 2,\r\n \"2\": \"FUNCTIONAL_COMPONENT\",\r\n \"STATEFUL_COMPONENT\": 4,\r\n \"4\": \"STATEFUL_COMPONENT\",\r\n \"TEXT_CHILDREN\": 8,\r\n \"8\": \"TEXT_CHILDREN\",\r\n \"ARRAY_CHILDREN\": 16,\r\n \"16\": \"ARRAY_CHILDREN\",\r\n \"SLOTS_CHILDREN\": 32,\r\n \"32\": \"SLOTS_CHILDREN\",\r\n \"TELEPORT\": 64,\r\n \"64\": \"TELEPORT\",\r\n \"SUSPENSE\": 128,\r\n \"128\": \"SUSPENSE\",\r\n \"COMPONENT_SHOULD_KEEP_ALIVE\": 256,\r\n \"256\": \"COMPONENT_SHOULD_KEEP_ALIVE\",\r\n \"COMPONENT_KEPT_ALIVE\": 512,\r\n \"512\": \"COMPONENT_KEPT_ALIVE\",\r\n \"COMPONENT\": 6,\r\n \"6\": \"COMPONENT\"\r\n};\r\n\r\nconst SlotFlags = {\r\n \"STABLE\": 1,\r\n \"1\": \"STABLE\",\r\n \"DYNAMIC\": 2,\r\n \"2\": \"DYNAMIC\",\r\n \"FORWARDED\": 3,\r\n \"3\": \"FORWARDED\"\r\n};\r\nconst slotFlagsText = {\r\n [1]: \"STABLE\",\r\n [2]: \"DYNAMIC\",\r\n [3]: \"FORWARDED\"\r\n};\r\n\r\nconst GLOBALS_ALLOWED = \"Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error\";\r\nconst isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);\r\nconst isGloballyWhitelisted = isGloballyAllowed;\r\n\r\nconst range = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n start = Math.max(0, Math.min(start, source.length));\r\n end = Math.max(0, Math.min(end, source.length));\r\n if (start > end) return \"\";\r\n let lines = source.split(/(\\r?\\n)/);\r\n const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);\r\n lines = lines.filter((_, idx) => idx % 2 === 0);\r\n let count = 0;\r\n const res = [];\r\n for (let i = 0; i < lines.length; i++) {\r\n count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);\r\n if (count >= start) {\r\n for (let j = i - range; j <= i + range || end > count; j++) {\r\n if (j < 0 || j >= lines.length) continue;\r\n const line = j + 1;\r\n res.push(\r\n `${line}${\" \".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`\r\n );\r\n const lineLength = lines[j].length;\r\n const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;\r\n if (j === i) {\r\n const pad = start - (count - (lineLength + newLineSeqLength));\r\n const length = Math.max(\r\n 1,\r\n end > count ? lineLength - pad : end - start\r\n );\r\n res.push(` | ` + \" \".repeat(pad) + \"^\".repeat(length));\r\n } else if (j > i) {\r\n if (end > count) {\r\n const length = Math.max(Math.min(end - count, lineLength), 1);\r\n res.push(` | ` + \"^\".repeat(length));\r\n }\r\n count += lineLength + newLineSeqLength;\r\n }\r\n }\r\n break;\r\n }\r\n }\r\n return res.join(\"\\n\");\r\n}\r\n\r\nfunction normalizeStyle(value) {\r\n if (isArray(value)) {\r\n const res = {};\r\n for (let i = 0; i < value.length; i++) {\r\n const item = value[i];\r\n const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);\r\n if (normalized) {\r\n for (const key in normalized) {\r\n res[key] = normalized[key];\r\n }\r\n }\r\n }\r\n return res;\r\n } else if (isString(value) || isObject(value)) {\r\n return value;\r\n }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:([^]+)/;\r\nconst styleCommentRE = /\\/\\*[^]*?\\*\\//g;\r\nfunction parseStringStyle(cssText) {\r\n const ret = {};\r\n cssText.replace(styleCommentRE, \"\").split(listDelimiterRE).forEach((item) => {\r\n if (item) {\r\n const tmp = item.split(propertyDelimiterRE);\r\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n }\r\n });\r\n return ret;\r\n}\r\nfunction stringifyStyle(styles) {\r\n let ret = \"\";\r\n if (!styles || isString(styles)) {\r\n return ret;\r\n }\r\n for (const key in styles) {\r\n const value = styles[key];\r\n if (isString(value) || typeof value === \"number\") {\r\n const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\r\n ret += `${normalizedKey}:${value};`;\r\n }\r\n }\r\n return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n let res = \"\";\r\n if (isString(value)) {\r\n res = value;\r\n } else if (isArray(value)) {\r\n for (let i = 0; i < value.length; i++) {\r\n const normalized = normalizeClass(value[i]);\r\n if (normalized) {\r\n res += normalized + \" \";\r\n }\r\n }\r\n } else if (isObject(value)) {\r\n for (const name in value) {\r\n if (value[name]) {\r\n res += name + \" \";\r\n }\r\n }\r\n }\r\n return res.trim();\r\n}\r\nfunction normalizeProps(props) {\r\n if (!props) return null;\r\n let { class: klass, style } = props;\r\n if (klass && !isString(klass)) {\r\n props.class = normalizeClass(klass);\r\n }\r\n if (style) {\r\n props.style = normalizeStyle(style);\r\n }\r\n return props;\r\n}\r\n\r\nconst HTML_TAGS = \"html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot\";\r\nconst SVG_TAGS = \"svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view\";\r\nconst MATH_TAGS = \"annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics\";\r\nconst VOID_TAGS = \"area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr\";\r\nconst isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);\r\nconst isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);\r\nconst isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);\r\nconst isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);\r\n\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);\r\nconst isBooleanAttr = /* @__PURE__ */ makeMap(\r\n specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`\r\n);\r\nfunction includeBooleanAttr(value) {\r\n return !!value || value === \"\";\r\n}\r\nconst unsafeAttrCharRE = /[>/=\"'\\u0009\\u000a\\u000c\\u0020]/;\r\nconst attrValidationCache = {};\r\nfunction isSSRSafeAttrName(name) {\r\n if (attrValidationCache.hasOwnProperty(name)) {\r\n return attrValidationCache[name];\r\n }\r\n const isUnsafe = unsafeAttrCharRE.test(name);\r\n if (isUnsafe) {\r\n console.error(`unsafe attribute name: ${name}`);\r\n }\r\n return attrValidationCache[name] = !isUnsafe;\r\n}\r\nconst propsToAttrMap = {\r\n acceptCharset: \"accept-charset\",\r\n className: \"class\",\r\n htmlFor: \"for\",\r\n httpEquiv: \"http-equiv\"\r\n};\r\nconst isKnownHtmlAttr = /* @__PURE__ */ makeMap(\r\n `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`\r\n);\r\nconst isKnownSvgAttr = /* @__PURE__ */ makeMap(\r\n `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`\r\n);\r\nfunction isRenderableAttrValue(value) {\r\n if (value == null) {\r\n return false;\r\n }\r\n const type = typeof value;\r\n return type === \"string\" || type === \"number\" || type === \"boolean\";\r\n}\r\n\r\nconst escapeRE = /[\"'&<>]/;\r\nfunction escapeHtml(string) {\r\n const str = \"\" + string;\r\n const match = escapeRE.exec(str);\r\n if (!match) {\r\n return str;\r\n }\r\n let html = \"\";\r\n let escaped;\r\n let index;\r\n let lastIndex = 0;\r\n for (index = match.index; index < str.length; index++) {\r\n switch (str.charCodeAt(index)) {\r\n case 34:\r\n escaped = \""\";\r\n break;\r\n case 38:\r\n escaped = \"&\";\r\n break;\r\n case 39:\r\n escaped = \"'\";\r\n break;\r\n case 60:\r\n escaped = \"<\";\r\n break;\r\n case 62:\r\n escaped = \">\";\r\n break;\r\n default:\r\n continue;\r\n }\r\n if (lastIndex !== index) {\r\n html += str.slice(lastIndex, index);\r\n }\r\n lastIndex = index + 1;\r\n html += escaped;\r\n }\r\n return lastIndex !== index ? html + str.slice(lastIndex, index) : html;\r\n}\r\nconst commentStripRE = /^-?>||--!>| looseEqual(item, val));\r\n}\r\n\r\nconst isRef = (val) => {\r\n return !!(val && val.__v_isRef === true);\r\n};\r\nconst toDisplayString = (val) => {\r\n return isString(val) ? val : val == null ? \"\" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);\r\n};\r\nconst replacer = (_key, val) => {\r\n if (isRef(val)) {\r\n return replacer(_key, val.value);\r\n } else if (isMap(val)) {\r\n return {\r\n [`Map(${val.size})`]: [...val.entries()].reduce(\r\n (entries, [key, val2], i) => {\r\n entries[stringifySymbol(key, i) + \" =>\"] = val2;\r\n return entries;\r\n },\r\n {}\r\n )\r\n };\r\n } else if (isSet(val)) {\r\n return {\r\n [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))\r\n };\r\n } else if (isSymbol(val)) {\r\n return stringifySymbol(val);\r\n } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\r\n return String(val);\r\n }\r\n return val;\r\n};\r\nconst stringifySymbol = (v, i = \"\") => {\r\n var _a;\r\n return (\r\n // Symbol.description in es2019+ so we need to cast here to pass\r\n // the lib: es2016 check\r\n isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v\r\n );\r\n};\r\n\r\nexport { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, PatchFlags, ShapeFlags, SlotFlags, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, genPropsAccessExp, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, includeBooleanAttr, invokeArrayFns, isArray, isBooleanAttr, isBuiltInDirective, isDate, isFunction, isGloballyAllowed, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isKnownHtmlAttr, isKnownSvgAttr, isMap, isMathMLTag, isModelListener, isObject, isOn, isPlainObject, isPromise, isRegExp, isRenderableAttrValue, isReservedProp, isSSRSafeAttrName, isSVGTag, isSet, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, looseToNumber, makeMap, normalizeClass, normalizeProps, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, slotFlagsText, stringifyStyle, toDisplayString, toHandlerKey, toNumber, toRawType, toTypeString };\r\n", "/**\r\n* @vue/reactivity v3.4.36\r\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\r\n* @license MIT\r\n**/\r\nimport { NOOP, extend, isArray, isSymbol, isMap, isIntegerKey, hasOwn, hasChanged, isObject, makeMap, capitalize, toRawType, def, isFunction } from '@vue/shared';\r\n\r\nfunction warn(msg, ...args) {\r\n console.warn(`[Vue warn] ${msg}`, ...args);\r\n}\r\n\r\nlet activeEffectScope;\r\nclass EffectScope {\r\n constructor(detached = false) {\r\n this.detached = detached;\r\n /**\r\n * @internal\r\n */\r\n this._active = true;\r\n /**\r\n * @internal\r\n */\r\n this.effects = [];\r\n /**\r\n * @internal\r\n */\r\n this.cleanups = [];\r\n this.parent = activeEffectScope;\r\n if (!detached && activeEffectScope) {\r\n this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(\r\n this\r\n ) - 1;\r\n }\r\n }\r\n get active() {\r\n return this._active;\r\n }\r\n run(fn) {\r\n if (this._active) {\r\n const currentEffectScope = activeEffectScope;\r\n try {\r\n activeEffectScope = this;\r\n return fn();\r\n } finally {\r\n activeEffectScope = currentEffectScope;\r\n }\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn(`cannot run an inactive effect scope.`);\r\n }\r\n }\r\n /**\r\n * This should only be called on non-detached scopes\r\n * @internal\r\n */\r\n on() {\r\n activeEffectScope = this;\r\n }\r\n /**\r\n * This should only be called on non-detached scopes\r\n * @internal\r\n */\r\n off() {\r\n activeEffectScope = this.parent;\r\n }\r\n stop(fromParent) {\r\n if (this._active) {\r\n let i, l;\r\n for (i = 0, l = this.effects.length; i < l; i++) {\r\n this.effects[i].stop();\r\n }\r\n for (i = 0, l = this.cleanups.length; i < l; i++) {\r\n this.cleanups[i]();\r\n }\r\n if (this.scopes) {\r\n for (i = 0, l = this.scopes.length; i < l; i++) {\r\n this.scopes[i].stop(true);\r\n }\r\n }\r\n if (!this.detached && this.parent && !fromParent) {\r\n const last = this.parent.scopes.pop();\r\n if (last && last !== this) {\r\n this.parent.scopes[this.index] = last;\r\n last.index = this.index;\r\n }\r\n }\r\n this.parent = void 0;\r\n this._active = false;\r\n }\r\n }\r\n}\r\nfunction effectScope(detached) {\r\n return new EffectScope(detached);\r\n}\r\nfunction recordEffectScope(effect, scope = activeEffectScope) {\r\n if (scope && scope.active) {\r\n scope.effects.push(effect);\r\n }\r\n}\r\nfunction getCurrentScope() {\r\n return activeEffectScope;\r\n}\r\nfunction onScopeDispose(fn) {\r\n if (activeEffectScope) {\r\n activeEffectScope.cleanups.push(fn);\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn(\r\n `onScopeDispose() is called when there is no active effect scope to be associated with.`\r\n );\r\n }\r\n}\r\n\r\nlet activeEffect;\r\nclass ReactiveEffect {\r\n constructor(fn, trigger, scheduler, scope) {\r\n this.fn = fn;\r\n this.trigger = trigger;\r\n this.scheduler = scheduler;\r\n this.active = true;\r\n this.deps = [];\r\n /**\r\n * @internal\r\n */\r\n this._dirtyLevel = 4;\r\n /**\r\n * @internal\r\n */\r\n this._trackId = 0;\r\n /**\r\n * @internal\r\n */\r\n this._runnings = 0;\r\n /**\r\n * @internal\r\n */\r\n this._shouldSchedule = false;\r\n /**\r\n * @internal\r\n */\r\n this._depsLength = 0;\r\n recordEffectScope(this, scope);\r\n }\r\n get dirty() {\r\n if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {\r\n this._dirtyLevel = 1;\r\n pauseTracking();\r\n for (let i = 0; i < this._depsLength; i++) {\r\n const dep = this.deps[i];\r\n if (dep.computed) {\r\n triggerComputed(dep.computed);\r\n if (this._dirtyLevel >= 4) {\r\n break;\r\n }\r\n }\r\n }\r\n if (this._dirtyLevel === 1) {\r\n this._dirtyLevel = 0;\r\n }\r\n resetTracking();\r\n }\r\n return this._dirtyLevel >= 4;\r\n }\r\n set dirty(v) {\r\n this._dirtyLevel = v ? 4 : 0;\r\n }\r\n run() {\r\n this._dirtyLevel = 0;\r\n if (!this.active) {\r\n return this.fn();\r\n }\r\n let lastShouldTrack = shouldTrack;\r\n let lastEffect = activeEffect;\r\n try {\r\n shouldTrack = true;\r\n activeEffect = this;\r\n this._runnings++;\r\n preCleanupEffect(this);\r\n return this.fn();\r\n } finally {\r\n postCleanupEffect(this);\r\n this._runnings--;\r\n activeEffect = lastEffect;\r\n shouldTrack = lastShouldTrack;\r\n }\r\n }\r\n stop() {\r\n if (this.active) {\r\n preCleanupEffect(this);\r\n postCleanupEffect(this);\r\n this.onStop && this.onStop();\r\n this.active = false;\r\n }\r\n }\r\n}\r\nfunction triggerComputed(computed) {\r\n return computed.value;\r\n}\r\nfunction preCleanupEffect(effect2) {\r\n effect2._trackId++;\r\n effect2._depsLength = 0;\r\n}\r\nfunction postCleanupEffect(effect2) {\r\n if (effect2.deps.length > effect2._depsLength) {\r\n for (let i = effect2._depsLength; i < effect2.deps.length; i++) {\r\n cleanupDepEffect(effect2.deps[i], effect2);\r\n }\r\n effect2.deps.length = effect2._depsLength;\r\n }\r\n}\r\nfunction cleanupDepEffect(dep, effect2) {\r\n const trackId = dep.get(effect2);\r\n if (trackId !== void 0 && effect2._trackId !== trackId) {\r\n dep.delete(effect2);\r\n if (dep.size === 0) {\r\n dep.cleanup();\r\n }\r\n }\r\n}\r\nfunction effect(fn, options) {\r\n if (fn.effect instanceof ReactiveEffect) {\r\n fn = fn.effect.fn;\r\n }\r\n const _effect = new ReactiveEffect(fn, NOOP, () => {\r\n if (_effect.dirty) {\r\n _effect.run();\r\n }\r\n });\r\n if (options) {\r\n extend(_effect, options);\r\n if (options.scope) recordEffectScope(_effect, options.scope);\r\n }\r\n if (!options || !options.lazy) {\r\n _effect.run();\r\n }\r\n const runner = _effect.run.bind(_effect);\r\n runner.effect = _effect;\r\n return runner;\r\n}\r\nfunction stop(runner) {\r\n runner.effect.stop();\r\n}\r\nlet shouldTrack = true;\r\nlet pauseScheduleStack = 0;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n trackStack.push(shouldTrack);\r\n shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n const last = trackStack.pop();\r\n shouldTrack = last === void 0 ? true : last;\r\n}\r\nfunction pauseScheduling() {\r\n pauseScheduleStack++;\r\n}\r\nfunction resetScheduling() {\r\n pauseScheduleStack--;\r\n while (!pauseScheduleStack && queueEffectSchedulers.length) {\r\n queueEffectSchedulers.shift()();\r\n }\r\n}\r\nfunction trackEffect(effect2, dep, debuggerEventExtraInfo) {\r\n var _a;\r\n if (dep.get(effect2) !== effect2._trackId) {\r\n dep.set(effect2, effect2._trackId);\r\n const oldDep = effect2.deps[effect2._depsLength];\r\n if (oldDep !== dep) {\r\n if (oldDep) {\r\n cleanupDepEffect(oldDep, effect2);\r\n }\r\n effect2.deps[effect2._depsLength++] = dep;\r\n } else {\r\n effect2._depsLength++;\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));\r\n }\r\n }\r\n}\r\nconst queueEffectSchedulers = [];\r\nfunction triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {\r\n var _a;\r\n pauseScheduling();\r\n for (const effect2 of dep.keys()) {\r\n let tracking;\r\n if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {\r\n effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);\r\n effect2._dirtyLevel = dirtyLevel;\r\n }\r\n if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));\r\n }\r\n effect2.trigger();\r\n if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {\r\n effect2._shouldSchedule = false;\r\n if (effect2.scheduler) {\r\n queueEffectSchedulers.push(effect2.scheduler);\r\n }\r\n }\r\n }\r\n }\r\n resetScheduling();\r\n}\r\n\r\nconst createDep = (cleanup, computed) => {\r\n const dep = /* @__PURE__ */ new Map();\r\n dep.cleanup = cleanup;\r\n dep.computed = computed;\r\n return dep;\r\n};\r\n\r\nconst targetMap = /* @__PURE__ */ new WeakMap();\r\nconst ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== \"production\") ? \"iterate\" : \"\");\r\nconst MAP_KEY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== \"production\") ? \"Map key iterate\" : \"\");\r\nfunction track(target, type, key) {\r\n if (shouldTrack && activeEffect) {\r\n let depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n targetMap.set(target, depsMap = /* @__PURE__ */ new Map());\r\n }\r\n let dep = depsMap.get(key);\r\n if (!dep) {\r\n depsMap.set(key, dep = createDep(() => depsMap.delete(key)));\r\n }\r\n trackEffect(\r\n activeEffect,\r\n dep,\r\n !!(process.env.NODE_ENV !== \"production\") ? {\r\n target,\r\n type,\r\n key\r\n } : void 0\r\n );\r\n }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n const depsMap = targetMap.get(target);\r\n if (!depsMap) {\r\n return;\r\n }\r\n let deps = [];\r\n if (type === \"clear\") {\r\n deps = [...depsMap.values()];\r\n } else if (key === \"length\" && isArray(target)) {\r\n const newLength = Number(newValue);\r\n depsMap.forEach((dep, key2) => {\r\n if (key2 === \"length\" || !isSymbol(key2) && key2 >= newLength) {\r\n deps.push(dep);\r\n }\r\n });\r\n } else {\r\n if (key !== void 0) {\r\n deps.push(depsMap.get(key));\r\n }\r\n switch (type) {\r\n case \"add\":\r\n if (!isArray(target)) {\r\n deps.push(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n } else if (isIntegerKey(key)) {\r\n deps.push(depsMap.get(\"length\"));\r\n }\r\n break;\r\n case \"delete\":\r\n if (!isArray(target)) {\r\n deps.push(depsMap.get(ITERATE_KEY));\r\n if (isMap(target)) {\r\n deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n }\r\n }\r\n break;\r\n case \"set\":\r\n if (isMap(target)) {\r\n deps.push(depsMap.get(ITERATE_KEY));\r\n }\r\n break;\r\n }\r\n }\r\n pauseScheduling();\r\n for (const dep of deps) {\r\n if (dep) {\r\n triggerEffects(\r\n dep,\r\n 4,\r\n !!(process.env.NODE_ENV !== \"production\") ? {\r\n target,\r\n type,\r\n key,\r\n newValue,\r\n oldValue,\r\n oldTarget\r\n } : void 0\r\n );\r\n }\r\n }\r\n resetScheduling();\r\n}\r\nfunction getDepFromReactive(object, key) {\r\n const depsMap = targetMap.get(object);\r\n return depsMap && depsMap.get(key);\r\n}\r\n\r\nconst isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);\r\nconst builtInSymbols = new Set(\r\n /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== \"arguments\" && key !== \"caller\").map((key) => Symbol[key]).filter(isSymbol)\r\n);\r\nconst arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();\r\nfunction createArrayInstrumentations() {\r\n const instrumentations = {};\r\n [\"includes\", \"indexOf\", \"lastIndexOf\"].forEach((key) => {\r\n instrumentations[key] = function(...args) {\r\n const arr = toRaw(this);\r\n for (let i = 0, l = this.length; i < l; i++) {\r\n track(arr, \"get\", i + \"\");\r\n }\r\n const res = arr[key](...args);\r\n if (res === -1 || res === false) {\r\n return arr[key](...args.map(toRaw));\r\n } else {\r\n return res;\r\n }\r\n };\r\n });\r\n [\"push\", \"pop\", \"shift\", \"unshift\", \"splice\"].forEach((key) => {\r\n instrumentations[key] = function(...args) {\r\n pauseTracking();\r\n pauseScheduling();\r\n const res = toRaw(this)[key].apply(this, args);\r\n resetScheduling();\r\n resetTracking();\r\n return res;\r\n };\r\n });\r\n return instrumentations;\r\n}\r\nfunction hasOwnProperty(key) {\r\n if (!isSymbol(key)) key = String(key);\r\n const obj = toRaw(this);\r\n track(obj, \"has\", key);\r\n return obj.hasOwnProperty(key);\r\n}\r\nclass BaseReactiveHandler {\r\n constructor(_isReadonly = false, _isShallow = false) {\r\n this._isReadonly = _isReadonly;\r\n this._isShallow = _isShallow;\r\n }\r\n get(target, key, receiver) {\r\n const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;\r\n if (key === \"__v_isReactive\") {\r\n return !isReadonly2;\r\n } else if (key === \"__v_isReadonly\") {\r\n return isReadonly2;\r\n } else if (key === \"__v_isShallow\") {\r\n return isShallow2;\r\n } else if (key === \"__v_raw\") {\r\n if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype\r\n // this means the reciever is a user proxy of the reactive proxy\r\n Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {\r\n return target;\r\n }\r\n return;\r\n }\r\n const targetIsArray = isArray(target);\r\n if (!isReadonly2) {\r\n if (targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n return Reflect.get(arrayInstrumentations, key, receiver);\r\n }\r\n if (key === \"hasOwnProperty\") {\r\n return hasOwnProperty;\r\n }\r\n }\r\n const res = Reflect.get(target, key, receiver);\r\n if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {\r\n return res;\r\n }\r\n if (!isReadonly2) {\r\n track(target, \"get\", key);\r\n }\r\n if (isShallow2) {\r\n return res;\r\n }\r\n if (isRef(res)) {\r\n return targetIsArray && isIntegerKey(key) ? res : res.value;\r\n }\r\n if (isObject(res)) {\r\n return isReadonly2 ? readonly(res) : reactive(res);\r\n }\r\n return res;\r\n }\r\n}\r\nclass MutableReactiveHandler extends BaseReactiveHandler {\r\n constructor(isShallow2 = false) {\r\n super(false, isShallow2);\r\n }\r\n set(target, key, value, receiver) {\r\n let oldValue = target[key];\r\n if (!this._isShallow) {\r\n const isOldValueReadonly = isReadonly(oldValue);\r\n if (!isShallow(value) && !isReadonly(value)) {\r\n oldValue = toRaw(oldValue);\r\n value = toRaw(value);\r\n }\r\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n if (isOldValueReadonly) {\r\n return false;\r\n } else {\r\n oldValue.value = value;\r\n return true;\r\n }\r\n }\r\n }\r\n const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);\r\n const result = Reflect.set(target, key, value, receiver);\r\n if (target === toRaw(receiver)) {\r\n if (!hadKey) {\r\n trigger(target, \"add\", key, value);\r\n } else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\", key, value, oldValue);\r\n }\r\n }\r\n return result;\r\n }\r\n deleteProperty(target, key) {\r\n const hadKey = hasOwn(target, key);\r\n const oldValue = target[key];\r\n const result = Reflect.deleteProperty(target, key);\r\n if (result && hadKey) {\r\n trigger(target, \"delete\", key, void 0, oldValue);\r\n }\r\n return result;\r\n }\r\n has(target, key) {\r\n const result = Reflect.has(target, key);\r\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n track(target, \"has\", key);\r\n }\r\n return result;\r\n }\r\n ownKeys(target) {\r\n track(\r\n target,\r\n \"iterate\",\r\n isArray(target) ? \"length\" : ITERATE_KEY\r\n );\r\n return Reflect.ownKeys(target);\r\n }\r\n}\r\nclass ReadonlyReactiveHandler extends BaseReactiveHandler {\r\n constructor(isShallow2 = false) {\r\n super(true, isShallow2);\r\n }\r\n set(target, key) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn(\r\n `Set operation on key \"${String(key)}\" failed: target is readonly.`,\r\n target\r\n );\r\n }\r\n return true;\r\n }\r\n deleteProperty(target, key) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn(\r\n `Delete operation on key \"${String(key)}\" failed: target is readonly.`,\r\n target\r\n );\r\n }\r\n return true;\r\n }\r\n}\r\nconst mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();\r\nconst readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();\r\nconst shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(\r\n true\r\n);\r\nconst shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);\r\n\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get(target, key, isReadonly2 = false, isShallow2 = false) {\r\n target = target[\"__v_raw\"];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (!isReadonly2) {\r\n if (hasChanged(key, rawKey)) {\r\n track(rawTarget, \"get\", key);\r\n }\r\n track(rawTarget, \"get\", rawKey);\r\n }\r\n const { has: has2 } = getProto(rawTarget);\r\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\r\n if (has2.call(rawTarget, key)) {\r\n return wrap(target.get(key));\r\n } else if (has2.call(rawTarget, rawKey)) {\r\n return wrap(target.get(rawKey));\r\n } else if (target !== rawTarget) {\r\n target.get(key);\r\n }\r\n}\r\nfunction has(key, isReadonly2 = false) {\r\n const target = this[\"__v_raw\"];\r\n const rawTarget = toRaw(target);\r\n const rawKey = toRaw(key);\r\n if (!isReadonly2) {\r\n if (hasChanged(key, rawKey)) {\r\n track(rawTarget, \"has\", key);\r\n }\r\n track(rawTarget, \"has\", rawKey);\r\n }\r\n return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly2 = false) {\r\n target = target[\"__v_raw\"];\r\n !isReadonly2 && track(toRaw(target), \"iterate\", ITERATE_KEY);\r\n return Reflect.get(target, \"size\", target);\r\n}\r\nfunction add(value, _isShallow = false) {\r\n if (!_isShallow && !isShallow(value) && !isReadonly(value)) {\r\n value = toRaw(value);\r\n }\r\n const target = toRaw(this);\r\n const proto = getProto(target);\r\n const hadKey = proto.has.call(target, value);\r\n if (!hadKey) {\r\n target.add(value);\r\n trigger(target, \"add\", value, value);\r\n }\r\n return this;\r\n}\r\nfunction set(key, value, _isShallow = false) {\r\n if (!_isShallow && !isShallow(value) && !isReadonly(value)) {\r\n value = toRaw(value);\r\n }\r\n const target = toRaw(this);\r\n const { has: has2, get: get2 } = getProto(target);\r\n let hadKey = has2.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has2.call(target, key);\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n checkIdentityKeys(target, has2, key);\r\n }\r\n const oldValue = get2.call(target, key);\r\n target.set(key, value);\r\n if (!hadKey) {\r\n trigger(target, \"add\", key, value);\r\n } else if (hasChanged(value, oldValue)) {\r\n trigger(target, \"set\", key, value, oldValue);\r\n }\r\n return this;\r\n}\r\nfunction deleteEntry(key) {\r\n const target = toRaw(this);\r\n const { has: has2, get: get2 } = getProto(target);\r\n let hadKey = has2.call(target, key);\r\n if (!hadKey) {\r\n key = toRaw(key);\r\n hadKey = has2.call(target, key);\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n checkIdentityKeys(target, has2, key);\r\n }\r\n const oldValue = get2 ? get2.call(target, key) : void 0;\r\n const result = target.delete(key);\r\n if (hadKey) {\r\n trigger(target, \"delete\", key, void 0, oldValue);\r\n }\r\n return result;\r\n}\r\nfunction clear() {\r\n const target = toRaw(this);\r\n const hadItems = target.size !== 0;\r\n const oldTarget = !!(process.env.NODE_ENV !== \"production\") ? isMap(target) ? new Map(target) : new Set(target) : void 0;\r\n const result = target.clear();\r\n if (hadItems) {\r\n trigger(target, \"clear\", void 0, void 0, oldTarget);\r\n }\r\n return result;\r\n}\r\nfunction createForEach(isReadonly2, isShallow2) {\r\n return function forEach(callback, thisArg) {\r\n const observed = this;\r\n const target = observed[\"__v_raw\"];\r\n const rawTarget = toRaw(target);\r\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\r\n !isReadonly2 && track(rawTarget, \"iterate\", ITERATE_KEY);\r\n return target.forEach((value, key) => {\r\n return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n });\r\n };\r\n}\r\nfunction createIterableMethod(method, isReadonly2, isShallow2) {\r\n return function(...args) {\r\n const target = this[\"__v_raw\"];\r\n const rawTarget = toRaw(target);\r\n const targetIsMap = isMap(rawTarget);\r\n const isPair = method === \"entries\" || method === Symbol.iterator && targetIsMap;\r\n const isKeyOnly = method === \"keys\" && targetIsMap;\r\n const innerIterator = target[method](...args);\r\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\r\n !isReadonly2 && track(\r\n rawTarget,\r\n \"iterate\",\r\n isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY\r\n );\r\n return {\r\n // iterator protocol\r\n next() {\r\n const { value, done } = innerIterator.next();\r\n return done ? { value, done } : {\r\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n done\r\n };\r\n },\r\n // iterable protocol\r\n [Symbol.iterator]() {\r\n return this;\r\n }\r\n };\r\n };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n return function(...args) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n warn(\r\n `${capitalize(type)} operation ${key}failed: target is readonly.`,\r\n toRaw(this)\r\n );\r\n }\r\n return type === \"delete\" ? false : type === \"clear\" ? void 0 : this;\r\n };\r\n}\r\nfunction createInstrumentations() {\r\n const mutableInstrumentations2 = {\r\n get(key) {\r\n return get(this, key);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has,\r\n add,\r\n set,\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, false)\r\n };\r\n const shallowInstrumentations2 = {\r\n get(key) {\r\n return get(this, key, false, true);\r\n },\r\n get size() {\r\n return size(this);\r\n },\r\n has,\r\n add(value) {\r\n return add.call(this, value, true);\r\n },\r\n set(key, value) {\r\n return set.call(this, key, value, true);\r\n },\r\n delete: deleteEntry,\r\n clear,\r\n forEach: createForEach(false, true)\r\n };\r\n const readonlyInstrumentations2 = {\r\n get(key) {\r\n return get(this, key, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\"),\r\n set: createReadonlyMethod(\"set\"),\r\n delete: createReadonlyMethod(\"delete\"),\r\n clear: createReadonlyMethod(\"clear\"),\r\n forEach: createForEach(true, false)\r\n };\r\n const shallowReadonlyInstrumentations2 = {\r\n get(key) {\r\n return get(this, key, true, true);\r\n },\r\n get size() {\r\n return size(this, true);\r\n },\r\n has(key) {\r\n return has.call(this, key, true);\r\n },\r\n add: createReadonlyMethod(\"add\"),\r\n set: createReadonlyMethod(\"set\"),\r\n delete: createReadonlyMethod(\"delete\"),\r\n clear: createReadonlyMethod(\"clear\"),\r\n forEach: createForEach(true, true)\r\n };\r\n const iteratorMethods = [\r\n \"keys\",\r\n \"values\",\r\n \"entries\",\r\n Symbol.iterator\r\n ];\r\n iteratorMethods.forEach((method) => {\r\n mutableInstrumentations2[method] = createIterableMethod(method, false, false);\r\n readonlyInstrumentations2[method] = createIterableMethod(method, true, false);\r\n shallowInstrumentations2[method] = createIterableMethod(method, false, true);\r\n shallowReadonlyInstrumentations2[method] = createIterableMethod(\r\n method,\r\n true,\r\n true\r\n );\r\n });\r\n return [\r\n mutableInstrumentations2,\r\n readonlyInstrumentations2,\r\n shallowInstrumentations2,\r\n shallowReadonlyInstrumentations2\r\n ];\r\n}\r\nconst [\r\n mutableInstrumentations,\r\n readonlyInstrumentations,\r\n shallowInstrumentations,\r\n shallowReadonlyInstrumentations\r\n] = /* @__PURE__ */ createInstrumentations();\r\nfunction createInstrumentationGetter(isReadonly2, shallow) {\r\n const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;\r\n return (target, key, receiver) => {\r\n if (key === \"__v_isReactive\") {\r\n return !isReadonly2;\r\n } else if (key === \"__v_isReadonly\") {\r\n return isReadonly2;\r\n } else if (key === \"__v_raw\") {\r\n return target;\r\n }\r\n return Reflect.get(\r\n hasOwn(instrumentations, key) && key in target ? instrumentations : target,\r\n key,\r\n receiver\r\n );\r\n };\r\n}\r\nconst mutableCollectionHandlers = {\r\n get: /* @__PURE__ */ createInstrumentationGetter(false, false)\r\n};\r\nconst shallowCollectionHandlers = {\r\n get: /* @__PURE__ */ createInstrumentationGetter(false, true)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n get: /* @__PURE__ */ createInstrumentationGetter(true, false)\r\n};\r\nconst shallowReadonlyCollectionHandlers = {\r\n get: /* @__PURE__ */ createInstrumentationGetter(true, true)\r\n};\r\nfunction checkIdentityKeys(target, has2, key) {\r\n const rawKey = toRaw(key);\r\n if (rawKey !== key && has2.call(target, rawKey)) {\r\n const type = toRawType(target);\r\n warn(\r\n `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`\r\n );\r\n }\r\n}\r\n\r\nconst reactiveMap = /* @__PURE__ */ new WeakMap();\r\nconst shallowReactiveMap = /* @__PURE__ */ new WeakMap();\r\nconst readonlyMap = /* @__PURE__ */ new WeakMap();\r\nconst shallowReadonlyMap = /* @__PURE__ */ new WeakMap();\r\nfunction targetTypeMap(rawType) {\r\n switch (rawType) {\r\n case \"Object\":\r\n case \"Array\":\r\n return 1 /* COMMON */;\r\n case \"Map\":\r\n case \"Set\":\r\n case \"WeakMap\":\r\n case \"WeakSet\":\r\n return 2 /* COLLECTION */;\r\n default:\r\n return 0 /* INVALID */;\r\n }\r\n}\r\nfunction getTargetType(value) {\r\n return value[\"__v_skip\"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n if (isReadonly(target)) {\r\n return target;\r\n }\r\n return createReactiveObject(\r\n target,\r\n false,\r\n mutableHandlers,\r\n mutableCollectionHandlers,\r\n reactiveMap\r\n );\r\n}\r\nfunction shallowReactive(target) {\r\n return createReactiveObject(\r\n target,\r\n false,\r\n shallowReactiveHandlers,\r\n shallowCollectionHandlers,\r\n shallowReactiveMap\r\n );\r\n}\r\nfunction readonly(target) {\r\n return createReactiveObject(\r\n target,\r\n true,\r\n readonlyHandlers,\r\n readonlyCollectionHandlers,\r\n readonlyMap\r\n );\r\n}\r\nfunction shallowReadonly(target) {\r\n return createReactiveObject(\r\n target,\r\n true,\r\n shallowReadonlyHandlers,\r\n shallowReadonlyCollectionHandlers,\r\n shallowReadonlyMap\r\n );\r\n}\r\nfunction createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {\r\n if (!isObject(target)) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn(\r\n `value cannot be made ${isReadonly2 ? \"readonly\" : \"reactive\"}: ${String(\r\n target\r\n )}`\r\n );\r\n }\r\n return target;\r\n }\r\n if (target[\"__v_raw\"] && !(isReadonly2 && target[\"__v_isReactive\"])) {\r\n return target;\r\n }\r\n const existingProxy = proxyMap.get(target);\r\n if (existingProxy) {\r\n return existingProxy;\r\n }\r\n const targetType = getTargetType(target);\r\n if (targetType === 0 /* INVALID */) {\r\n return target;\r\n }\r\n const proxy = new Proxy(\r\n target,\r\n targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers\r\n );\r\n proxyMap.set(target, proxy);\r\n return proxy;\r\n}\r\nfunction isReactive(value) {\r\n if (isReadonly(value)) {\r\n return isReactive(value[\"__v_raw\"]);\r\n }\r\n return !!(value && value[\"__v_isReactive\"]);\r\n}\r\nfunction isReadonly(value) {\r\n return !!(value && value[\"__v_isReadonly\"]);\r\n}\r\nfunction isShallow(value) {\r\n return !!(value && value[\"__v_isShallow\"]);\r\n}\r\nfunction isProxy(value) {\r\n return value ? !!value[\"__v_raw\"] : false;\r\n}\r\nfunction toRaw(observed) {\r\n const raw = observed && observed[\"__v_raw\"];\r\n return raw ? toRaw(raw) : observed;\r\n}\r\nfunction markRaw(value) {\r\n if (Object.isExtensible(value)) {\r\n def(value, \"__v_skip\", true);\r\n }\r\n return value;\r\n}\r\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\n\r\nconst COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided. Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;\r\nclass ComputedRefImpl {\r\n constructor(getter, _setter, isReadonly, isSSR) {\r\n this.getter = getter;\r\n this._setter = _setter;\r\n this.dep = void 0;\r\n this.__v_isRef = true;\r\n this[\"__v_isReadonly\"] = false;\r\n this.effect = new ReactiveEffect(\r\n () => getter(this._value),\r\n () => triggerRefValue(\r\n this,\r\n this.effect._dirtyLevel === 2 ? 2 : 3\r\n )\r\n );\r\n this.effect.computed = this;\r\n this.effect.active = this._cacheable = !isSSR;\r\n this[\"__v_isReadonly\"] = isReadonly;\r\n }\r\n get value() {\r\n const self = toRaw(this);\r\n if ((!self._cacheable || self.effect.dirty) && hasChanged(self._value, self._value = self.effect.run())) {\r\n triggerRefValue(self, 4);\r\n }\r\n trackRefValue(self);\r\n if (self.effect._dirtyLevel >= 2) {\r\n if (!!(process.env.NODE_ENV !== \"production\") && this._warnRecursive) {\r\n warn(COMPUTED_SIDE_EFFECT_WARN, `\r\n\r\ngetter: `, this.getter);\r\n }\r\n triggerRefValue(self, 2);\r\n }\r\n return self._value;\r\n }\r\n set value(newValue) {\r\n this._setter(newValue);\r\n }\r\n // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x\r\n get _dirty() {\r\n return this.effect.dirty;\r\n }\r\n set _dirty(v) {\r\n this.effect.dirty = v;\r\n }\r\n // #endregion\r\n}\r\nfunction computed(getterOrOptions, debugOptions, isSSR = false) {\r\n let getter;\r\n let setter;\r\n const onlyGetter = isFunction(getterOrOptions);\r\n if (onlyGetter) {\r\n getter = getterOrOptions;\r\n setter = !!(process.env.NODE_ENV !== \"production\") ? () => {\r\n warn(\"Write operation failed: computed value is readonly\");\r\n } : NOOP;\r\n } else {\r\n getter = getterOrOptions.get;\r\n setter = getterOrOptions.set;\r\n }\r\n const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);\r\n if (!!(process.env.NODE_ENV !== \"production\") && debugOptions && !isSSR) {\r\n cRef.effect.onTrack = debugOptions.onTrack;\r\n cRef.effect.onTrigger = debugOptions.onTrigger;\r\n }\r\n return cRef;\r\n}\r\n\r\nfunction trackRefValue(ref2) {\r\n var _a;\r\n if (shouldTrack && activeEffect) {\r\n ref2 = toRaw(ref2);\r\n trackEffect(\r\n activeEffect,\r\n (_a = ref2.dep) != null ? _a : ref2.dep = createDep(\r\n () => ref2.dep = void 0,\r\n ref2 instanceof ComputedRefImpl ? ref2 : void 0\r\n ),\r\n !!(process.env.NODE_ENV !== \"production\") ? {\r\n target: ref2,\r\n type: \"get\",\r\n key: \"value\"\r\n } : void 0\r\n );\r\n }\r\n}\r\nfunction triggerRefValue(ref2, dirtyLevel = 4, newVal, oldVal) {\r\n ref2 = toRaw(ref2);\r\n const dep = ref2.dep;\r\n if (dep) {\r\n triggerEffects(\r\n dep,\r\n dirtyLevel,\r\n !!(process.env.NODE_ENV !== \"production\") ? {\r\n target: ref2,\r\n type: \"set\",\r\n key: \"value\",\r\n newValue: newVal,\r\n oldValue: oldVal\r\n } : void 0\r\n );\r\n }\r\n}\r\nfunction isRef(r) {\r\n return !!(r && r.__v_isRef === true);\r\n}\r\nfunction ref(value) {\r\n return createRef(value, false);\r\n}\r\nfunction shallowRef(value) {\r\n return createRef(value, true);\r\n}\r\nfunction createRef(rawValue, shallow) {\r\n if (isRef(rawValue)) {\r\n return rawValue;\r\n }\r\n return new RefImpl(rawValue, shallow);\r\n}\r\nclass RefImpl {\r\n constructor(value, __v_isShallow) {\r\n this.__v_isShallow = __v_isShallow;\r\n this.dep = void 0;\r\n this.__v_isRef = true;\r\n this._rawValue = __v_isShallow ? value : toRaw(value);\r\n this._value = __v_isShallow ? value : toReactive(value);\r\n }\r\n get value() {\r\n trackRefValue(this);\r\n return this._value;\r\n }\r\n set value(newVal) {\r\n const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);\r\n newVal = useDirectValue ? newVal : toRaw(newVal);\r\n if (hasChanged(newVal, this._rawValue)) {\r\n const oldVal = this._rawValue;\r\n this._rawValue = newVal;\r\n this._value = useDirectValue ? newVal : toReactive(newVal);\r\n triggerRefValue(this, 4, newVal, oldVal);\r\n }\r\n }\r\n}\r\nfunction triggerRef(ref2) {\r\n triggerRefValue(ref2, 4, !!(process.env.NODE_ENV !== \"production\") ? ref2.value : void 0);\r\n}\r\nfunction unref(ref2) {\r\n return isRef(ref2) ? ref2.value : ref2;\r\n}\r\nfunction toValue(source) {\r\n return isFunction(source) ? source() : unref(source);\r\n}\r\nconst shallowUnwrapHandlers = {\r\n get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),\r\n set: (target, key, value, receiver) => {\r\n const oldValue = target[key];\r\n if (isRef(oldValue) && !isRef(value)) {\r\n oldValue.value = value;\r\n return true;\r\n } else {\r\n return Reflect.set(target, key, value, receiver);\r\n }\r\n }\r\n};\r\nfunction proxyRefs(objectWithRefs) {\r\n return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);\r\n}\r\nclass CustomRefImpl {\r\n constructor(factory) {\r\n this.dep = void 0;\r\n this.__v_isRef = true;\r\n const { get, set } = factory(\r\n () => trackRefValue(this),\r\n () => triggerRefValue(this)\r\n );\r\n this._get = get;\r\n this._set = set;\r\n }\r\n get value() {\r\n return this._get();\r\n }\r\n set value(newVal) {\r\n this._set(newVal);\r\n }\r\n}\r\nfunction customRef(factory) {\r\n return new CustomRefImpl(factory);\r\n}\r\nfunction toRefs(object) {\r\n if (!!(process.env.NODE_ENV !== \"production\") && !isProxy(object)) {\r\n warn(`toRefs() expects a reactive object but received a plain one.`);\r\n }\r\n const ret = isArray(object) ? new Array(object.length) : {};\r\n for (const key in object) {\r\n ret[key] = propertyToRef(object, key);\r\n }\r\n return ret;\r\n}\r\nclass ObjectRefImpl {\r\n constructor(_object, _key, _defaultValue) {\r\n this._object = _object;\r\n this._key = _key;\r\n this._defaultValue = _defaultValue;\r\n this.__v_isRef = true;\r\n }\r\n get value() {\r\n const val = this._object[this._key];\r\n return val === void 0 ? this._defaultValue : val;\r\n }\r\n set value(newVal) {\r\n this._object[this._key] = newVal;\r\n }\r\n get dep() {\r\n return getDepFromReactive(toRaw(this._object), this._key);\r\n }\r\n}\r\nclass GetterRefImpl {\r\n constructor(_getter) {\r\n this._getter = _getter;\r\n this.__v_isRef = true;\r\n this.__v_isReadonly = true;\r\n }\r\n get value() {\r\n return this._getter();\r\n }\r\n}\r\nfunction toRef(source, key, defaultValue) {\r\n if (isRef(source)) {\r\n return source;\r\n } else if (isFunction(source)) {\r\n return new GetterRefImpl(source);\r\n } else if (isObject(source) && arguments.length > 1) {\r\n return propertyToRef(source, key, defaultValue);\r\n } else {\r\n return ref(source);\r\n }\r\n}\r\nfunction propertyToRef(source, key, defaultValue) {\r\n const val = source[key];\r\n return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);\r\n}\r\n\r\nconst deferredComputed = computed;\r\n\r\nconst TrackOpTypes = {\r\n \"GET\": \"get\",\r\n \"HAS\": \"has\",\r\n \"ITERATE\": \"iterate\"\r\n};\r\nconst TriggerOpTypes = {\r\n \"SET\": \"set\",\r\n \"ADD\": \"add\",\r\n \"DELETE\": \"delete\",\r\n \"CLEAR\": \"clear\"\r\n};\r\nconst ReactiveFlags = {\r\n \"SKIP\": \"__v_skip\",\r\n \"IS_REACTIVE\": \"__v_isReactive\",\r\n \"IS_READONLY\": \"__v_isReadonly\",\r\n \"IS_SHALLOW\": \"__v_isShallow\",\r\n \"RAW\": \"__v_raw\"\r\n};\r\n\r\nexport { EffectScope, ITERATE_KEY, ReactiveEffect, ReactiveFlags, TrackOpTypes, TriggerOpTypes, computed, customRef, deferredComputed, effect, effectScope, enableTracking, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, pauseScheduling, pauseTracking, proxyRefs, reactive, readonly, ref, resetScheduling, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, track, trigger, triggerRef, unref };\r\n", "/**\r\n* @vue/runtime-core v3.4.36\r\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\r\n* @license MIT\r\n**/\r\nimport { pauseTracking, resetTracking, isRef, toRaw, ref, shallowReadonly, track, reactive, shallowReactive, trigger, isReactive, ReactiveEffect, isShallow, getCurrentScope, customRef, isProxy, proxyRefs, markRaw, EffectScope, computed as computed$1, isReadonly } from '@vue/reactivity';\r\nexport { EffectScope, ReactiveEffect, TrackOpTypes, TriggerOpTypes, customRef, effect, effectScope, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';\r\nimport { isString, isFunction, isPromise, isArray, NOOP, getGlobalThis, extend, isBuiltInDirective, EMPTY_OBJ, isObject, remove, isRegExp, invokeArrayFns, toHandlerKey, capitalize, camelize, hasOwn, isGloballyAllowed, NO, hyphenate, isReservedProp, EMPTY_ARR, toRawType, makeMap, def, isOn, normalizeClass, stringifyStyle, normalizeStyle, isKnownSvgAttr, isBooleanAttr, isKnownHtmlAttr, includeBooleanAttr, isRenderableAttrValue, hasChanged, isSet, isMap, isPlainObject, looseToNumber, isModelListener, toNumber } from '@vue/shared';\r\nexport { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';\r\n\r\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n stack.pop();\r\n}\r\nlet isWarning = false;\r\nfunction warn$1(msg, ...args) {\r\n if (isWarning) return;\r\n isWarning = true;\r\n pauseTracking();\r\n const instance = stack.length ? stack[stack.length - 1].component : null;\r\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n const trace = getComponentTrace();\r\n if (appWarnHandler) {\r\n callWithErrorHandling(\r\n appWarnHandler,\r\n instance,\r\n 11,\r\n [\r\n // eslint-disable-next-line no-restricted-syntax\r\n msg + args.map((a) => {\r\n var _a, _b;\r\n return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);\r\n }).join(\"\"),\r\n instance && instance.proxy,\r\n trace.map(\r\n ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`\r\n ).join(\"\\n\"),\r\n trace\r\n ]\r\n );\r\n } else {\r\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n if (trace.length && // avoid spamming console during tests\r\n true) {\r\n warnArgs.push(`\r\n`, ...formatTrace(trace));\r\n }\r\n console.warn(...warnArgs);\r\n }\r\n resetTracking();\r\n isWarning = false;\r\n}\r\nfunction getComponentTrace() {\r\n let currentVNode = stack[stack.length - 1];\r\n if (!currentVNode) {\r\n return [];\r\n }\r\n const normalizedStack = [];\r\n while (currentVNode) {\r\n const last = normalizedStack[0];\r\n if (last && last.vnode === currentVNode) {\r\n last.recurseCount++;\r\n } else {\r\n normalizedStack.push({\r\n vnode: currentVNode,\r\n recurseCount: 0\r\n });\r\n }\r\n const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n currentVNode = parentInstance && parentInstance.vnode;\r\n }\r\n return normalizedStack;\r\n}\r\nfunction formatTrace(trace) {\r\n const logs = [];\r\n trace.forEach((entry, i) => {\r\n logs.push(...i === 0 ? [] : [`\r\n`], ...formatTraceEntry(entry));\r\n });\r\n return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n const open = ` at <${formatComponentName(\r\n vnode.component,\r\n vnode.type,\r\n isRoot\r\n )}`;\r\n const close = `>` + postfix;\r\n return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];\r\n}\r\nfunction formatProps(props) {\r\n const res = [];\r\n const keys = Object.keys(props);\r\n keys.slice(0, 3).forEach((key) => {\r\n res.push(...formatProp(key, props[key]));\r\n });\r\n if (keys.length > 3) {\r\n res.push(` ...`);\r\n }\r\n return res;\r\n}\r\nfunction formatProp(key, value, raw) {\r\n if (isString(value)) {\r\n value = JSON.stringify(value);\r\n return raw ? value : [`${key}=${value}`];\r\n } else if (typeof value === \"number\" || typeof value === \"boolean\" || value == null) {\r\n return raw ? value : [`${key}=${value}`];\r\n } else if (isRef(value)) {\r\n value = formatProp(key, toRaw(value.value), true);\r\n return raw ? value : [`${key}=Ref<`, value, `>`];\r\n } else if (isFunction(value)) {\r\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n } else {\r\n value = toRaw(value);\r\n return raw ? value : [`${key}=`, value];\r\n }\r\n}\r\nfunction assertNumber(val, type) {\r\n if (!!!(process.env.NODE_ENV !== \"production\")) return;\r\n if (val === void 0) {\r\n return;\r\n } else if (typeof val !== \"number\") {\r\n warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);\r\n } else if (isNaN(val)) {\r\n warn$1(`${type} is NaN - the duration expression might be incorrect.`);\r\n }\r\n}\r\n\r\nconst ErrorCodes = {\r\n \"SETUP_FUNCTION\": 0,\r\n \"0\": \"SETUP_FUNCTION\",\r\n \"RENDER_FUNCTION\": 1,\r\n \"1\": \"RENDER_FUNCTION\",\r\n \"WATCH_GETTER\": 2,\r\n \"2\": \"WATCH_GETTER\",\r\n \"WATCH_CALLBACK\": 3,\r\n \"3\": \"WATCH_CALLBACK\",\r\n \"WATCH_CLEANUP\": 4,\r\n \"4\": \"WATCH_CLEANUP\",\r\n \"NATIVE_EVENT_HANDLER\": 5,\r\n \"5\": \"NATIVE_EVENT_HANDLER\",\r\n \"COMPONENT_EVENT_HANDLER\": 6,\r\n \"6\": \"COMPONENT_EVENT_HANDLER\",\r\n \"VNODE_HOOK\": 7,\r\n \"7\": \"VNODE_HOOK\",\r\n \"DIRECTIVE_HOOK\": 8,\r\n \"8\": \"DIRECTIVE_HOOK\",\r\n \"TRANSITION_HOOK\": 9,\r\n \"9\": \"TRANSITION_HOOK\",\r\n \"APP_ERROR_HANDLER\": 10,\r\n \"10\": \"APP_ERROR_HANDLER\",\r\n \"APP_WARN_HANDLER\": 11,\r\n \"11\": \"APP_WARN_HANDLER\",\r\n \"FUNCTION_REF\": 12,\r\n \"12\": \"FUNCTION_REF\",\r\n \"ASYNC_COMPONENT_LOADER\": 13,\r\n \"13\": \"ASYNC_COMPONENT_LOADER\",\r\n \"SCHEDULER\": 14,\r\n \"14\": \"SCHEDULER\",\r\n \"COMPONENT_UPDATE\": 15,\r\n \"15\": \"COMPONENT_UPDATE\"\r\n};\r\nconst ErrorTypeStrings$1 = {\r\n [\"sp\"]: \"serverPrefetch hook\",\r\n [\"bc\"]: \"beforeCreate hook\",\r\n [\"c\"]: \"created hook\",\r\n [\"bm\"]: \"beforeMount hook\",\r\n [\"m\"]: \"mounted hook\",\r\n [\"bu\"]: \"beforeUpdate hook\",\r\n [\"u\"]: \"updated\",\r\n [\"bum\"]: \"beforeUnmount hook\",\r\n [\"um\"]: \"unmounted hook\",\r\n [\"a\"]: \"activated hook\",\r\n [\"da\"]: \"deactivated hook\",\r\n [\"ec\"]: \"errorCaptured hook\",\r\n [\"rtc\"]: \"renderTracked hook\",\r\n [\"rtg\"]: \"renderTriggered hook\",\r\n [0]: \"setup function\",\r\n [1]: \"render function\",\r\n [2]: \"watcher getter\",\r\n [3]: \"watcher callback\",\r\n [4]: \"watcher cleanup function\",\r\n [5]: \"native event handler\",\r\n [6]: \"component event handler\",\r\n [7]: \"vnode hook\",\r\n [8]: \"directive hook\",\r\n [9]: \"transition hook\",\r\n [10]: \"app errorHandler\",\r\n [11]: \"app warnHandler\",\r\n [12]: \"ref function\",\r\n [13]: \"async component loader\",\r\n [14]: \"scheduler flush\",\r\n [15]: \"component update\"\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n try {\r\n return args ? fn(...args) : fn();\r\n } catch (err) {\r\n handleError(err, instance, type);\r\n }\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n if (isFunction(fn)) {\r\n const res = callWithErrorHandling(fn, instance, type, args);\r\n if (res && isPromise(res)) {\r\n res.catch((err) => {\r\n handleError(err, instance, type);\r\n });\r\n }\r\n return res;\r\n }\r\n if (isArray(fn)) {\r\n const values = [];\r\n for (let i = 0; i < fn.length; i++) {\r\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n }\r\n return values;\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn$1(\r\n `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`\r\n );\r\n }\r\n}\r\nfunction handleError(err, instance, type, throwInDev = true) {\r\n const contextVNode = instance ? instance.vnode : null;\r\n if (instance) {\r\n let cur = instance.parent;\r\n const exposedInstance = instance.proxy;\r\n const errorInfo = !!(process.env.NODE_ENV !== \"production\") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;\r\n while (cur) {\r\n const errorCapturedHooks = cur.ec;\r\n if (errorCapturedHooks) {\r\n for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\r\n return;\r\n }\r\n }\r\n }\r\n cur = cur.parent;\r\n }\r\n const appErrorHandler = instance.appContext.config.errorHandler;\r\n if (appErrorHandler) {\r\n pauseTracking();\r\n callWithErrorHandling(\r\n appErrorHandler,\r\n null,\r\n 10,\r\n [err, exposedInstance, errorInfo]\r\n );\r\n resetTracking();\r\n return;\r\n }\r\n }\r\n logError(err, type, contextVNode, throwInDev);\r\n}\r\nfunction logError(err, type, contextVNode, throwInDev = true) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n const info = ErrorTypeStrings$1[type];\r\n if (contextVNode) {\r\n pushWarningContext(contextVNode);\r\n }\r\n warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n if (contextVNode) {\r\n popWarningContext();\r\n }\r\n if (throwInDev) {\r\n throw err;\r\n } else {\r\n console.error(err);\r\n }\r\n } else {\r\n console.error(err);\r\n }\r\n}\r\n\r\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = /* @__PURE__ */ Promise.resolve();\r\nlet currentFlushPromise = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n const p = currentFlushPromise || resolvedPromise;\r\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\r\n}\r\nfunction findInsertionIndex(id) {\r\n let start = flushIndex + 1;\r\n let end = queue.length;\r\n while (start < end) {\r\n const middle = start + end >>> 1;\r\n const middleJob = queue[middle];\r\n const middleJobId = getId(middleJob);\r\n if (middleJobId < id || middleJobId === id && middleJob.pre) {\r\n start = middle + 1;\r\n } else {\r\n end = middle;\r\n }\r\n }\r\n return start;\r\n}\r\nfunction queueJob(job) {\r\n if (!queue.length || !queue.includes(\r\n job,\r\n isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex\r\n )) {\r\n if (job.id == null) {\r\n queue.push(job);\r\n } else {\r\n queue.splice(findInsertionIndex(job.id), 0, job);\r\n }\r\n queueFlush();\r\n }\r\n}\r\nfunction queueFlush() {\r\n if (!isFlushing && !isFlushPending) {\r\n isFlushPending = true;\r\n currentFlushPromise = resolvedPromise.then(flushJobs);\r\n }\r\n}\r\nfunction invalidateJob(job) {\r\n const i = queue.indexOf(job);\r\n if (i > flushIndex) {\r\n queue.splice(i, 1);\r\n }\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n if (!isArray(cb)) {\r\n if (!activePostFlushCbs || !activePostFlushCbs.includes(\r\n cb,\r\n cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex\r\n )) {\r\n pendingPostFlushCbs.push(cb);\r\n }\r\n } else {\r\n pendingPostFlushCbs.push(...cb);\r\n }\r\n queueFlush();\r\n}\r\nfunction flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n seen = seen || /* @__PURE__ */ new Map();\r\n }\r\n for (; i < queue.length; i++) {\r\n const cb = queue[i];\r\n if (cb && cb.pre) {\r\n if (instance && cb.id !== instance.uid) {\r\n continue;\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\") && checkRecursiveUpdates(seen, cb)) {\r\n continue;\r\n }\r\n queue.splice(i, 1);\r\n i--;\r\n cb();\r\n }\r\n }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n if (pendingPostFlushCbs.length) {\r\n const deduped = [...new Set(pendingPostFlushCbs)].sort(\r\n (a, b) => getId(a) - getId(b)\r\n );\r\n pendingPostFlushCbs.length = 0;\r\n if (activePostFlushCbs) {\r\n activePostFlushCbs.push(...deduped);\r\n return;\r\n }\r\n activePostFlushCbs = deduped;\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n seen = seen || /* @__PURE__ */ new Map();\r\n }\r\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n const cb = activePostFlushCbs[postFlushIndex];\r\n if (!!(process.env.NODE_ENV !== \"production\") && checkRecursiveUpdates(seen, cb)) {\r\n continue;\r\n }\r\n if (cb.active !== false) cb();\r\n }\r\n activePostFlushCbs = null;\r\n postFlushIndex = 0;\r\n }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nconst comparator = (a, b) => {\r\n const diff = getId(a) - getId(b);\r\n if (diff === 0) {\r\n if (a.pre && !b.pre) return -1;\r\n if (b.pre && !a.pre) return 1;\r\n }\r\n return diff;\r\n};\r\nfunction flushJobs(seen) {\r\n isFlushPending = false;\r\n isFlushing = true;\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n seen = seen || /* @__PURE__ */ new Map();\r\n }\r\n queue.sort(comparator);\r\n const check = !!(process.env.NODE_ENV !== \"production\") ? (job) => checkRecursiveUpdates(seen, job) : NOOP;\r\n try {\r\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n const job = queue[flushIndex];\r\n if (job && job.active !== false) {\r\n if (!!(process.env.NODE_ENV !== \"production\") && check(job)) {\r\n continue;\r\n }\r\n callWithErrorHandling(\r\n job,\r\n job.i,\r\n job.i ? 15 : 14\r\n );\r\n }\r\n }\r\n } finally {\r\n flushIndex = 0;\r\n queue.length = 0;\r\n flushPostFlushCbs(seen);\r\n isFlushing = false;\r\n currentFlushPromise = null;\r\n if (queue.length || pendingPostFlushCbs.length) {\r\n flushJobs(seen);\r\n }\r\n }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n if (!seen.has(fn)) {\r\n seen.set(fn, 1);\r\n } else {\r\n const count = seen.get(fn);\r\n if (count > RECURSION_LIMIT) {\r\n const instance = fn.i;\r\n const componentName = instance && getComponentName(instance.type);\r\n handleError(\r\n `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,\r\n null,\r\n 10\r\n );\r\n return true;\r\n } else {\r\n seen.set(fn, count + 1);\r\n }\r\n }\r\n}\r\n\r\nlet isHmrUpdating = false;\r\nconst hmrDirtyComponents = /* @__PURE__ */ new Map();\r\nif (!!(process.env.NODE_ENV !== \"production\")) {\r\n getGlobalThis().__VUE_HMR_RUNTIME__ = {\r\n createRecord: tryWrap(createRecord),\r\n rerender: tryWrap(rerender),\r\n reload: tryWrap(reload)\r\n };\r\n}\r\nconst map = /* @__PURE__ */ new Map();\r\nfunction registerHMR(instance) {\r\n const id = instance.type.__hmrId;\r\n let record = map.get(id);\r\n if (!record) {\r\n createRecord(id, instance.type);\r\n record = map.get(id);\r\n }\r\n record.instances.add(instance);\r\n}\r\nfunction unregisterHMR(instance) {\r\n map.get(instance.type.__hmrId).instances.delete(instance);\r\n}\r\nfunction createRecord(id, initialDef) {\r\n if (map.has(id)) {\r\n return false;\r\n }\r\n map.set(id, {\r\n initialDef: normalizeClassComponent(initialDef),\r\n instances: /* @__PURE__ */ new Set()\r\n });\r\n return true;\r\n}\r\nfunction normalizeClassComponent(component) {\r\n return isClassComponent(component) ? component.__vccOpts : component;\r\n}\r\nfunction rerender(id, newRender) {\r\n const record = map.get(id);\r\n if (!record) {\r\n return;\r\n }\r\n record.initialDef.render = newRender;\r\n [...record.instances].forEach((instance) => {\r\n if (newRender) {\r\n instance.render = newRender;\r\n normalizeClassComponent(instance.type).render = newRender;\r\n }\r\n instance.renderCache = [];\r\n isHmrUpdating = true;\r\n instance.effect.dirty = true;\r\n instance.update();\r\n isHmrUpdating = false;\r\n });\r\n}\r\nfunction reload(id, newComp) {\r\n const record = map.get(id);\r\n if (!record) return;\r\n newComp = normalizeClassComponent(newComp);\r\n updateComponentDef(record.initialDef, newComp);\r\n const instances = [...record.instances];\r\n for (let i = 0; i < instances.length; i++) {\r\n const instance = instances[i];\r\n const oldComp = normalizeClassComponent(instance.type);\r\n let dirtyInstances = hmrDirtyComponents.get(oldComp);\r\n if (!dirtyInstances) {\r\n if (oldComp !== record.initialDef) {\r\n updateComponentDef(oldComp, newComp);\r\n }\r\n hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());\r\n }\r\n dirtyInstances.add(instance);\r\n instance.appContext.propsCache.delete(instance.type);\r\n instance.appContext.emitsCache.delete(instance.type);\r\n instance.appContext.optionsCache.delete(instance.type);\r\n if (instance.ceReload) {\r\n dirtyInstances.add(instance);\r\n instance.ceReload(newComp.styles);\r\n dirtyInstances.delete(instance);\r\n } else if (instance.parent) {\r\n instance.parent.effect.dirty = true;\r\n queueJob(() => {\r\n instance.parent.update();\r\n dirtyInstances.delete(instance);\r\n });\r\n } else if (instance.appContext.reload) {\r\n instance.appContext.reload();\r\n } else if (typeof window !== \"undefined\") {\r\n window.location.reload();\r\n } else {\r\n console.warn(\r\n \"[HMR] Root or manually mounted instance modified. Full reload required.\"\r\n );\r\n }\r\n }\r\n queuePostFlushCb(() => {\r\n hmrDirtyComponents.clear();\r\n });\r\n}\r\nfunction updateComponentDef(oldComp, newComp) {\r\n extend(oldComp, newComp);\r\n for (const key in oldComp) {\r\n if (key !== \"__file\" && !(key in newComp)) {\r\n delete oldComp[key];\r\n }\r\n }\r\n}\r\nfunction tryWrap(fn) {\r\n return (id, arg) => {\r\n try {\r\n return fn(id, arg);\r\n } catch (e) {\r\n console.error(e);\r\n console.warn(\r\n `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`\r\n );\r\n }\r\n };\r\n}\r\n\r\nlet devtools$1;\r\nlet buffer = [];\r\nlet devtoolsNotInstalled = false;\r\nfunction emit$1(event, ...args) {\r\n if (devtools$1) {\r\n devtools$1.emit(event, ...args);\r\n } else if (!devtoolsNotInstalled) {\r\n buffer.push({ event, args });\r\n }\r\n}\r\nfunction setDevtoolsHook$1(hook, target) {\r\n var _a, _b;\r\n devtools$1 = hook;\r\n if (devtools$1) {\r\n devtools$1.enabled = true;\r\n buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));\r\n buffer = [];\r\n } else if (\r\n // handle late devtools injection - only do this if we are in an actual\r\n // browser environment to avoid the timer handle stalling test runner exit\r\n // (#4815)\r\n typeof window !== \"undefined\" && // some envs mock window but not fully\r\n window.HTMLElement && // also exclude jsdom\r\n // eslint-disable-next-line no-restricted-syntax\r\n !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes(\"jsdom\"))\r\n ) {\r\n const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];\r\n replay.push((newHook) => {\r\n setDevtoolsHook$1(newHook, target);\r\n });\r\n setTimeout(() => {\r\n if (!devtools$1) {\r\n target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;\r\n devtoolsNotInstalled = true;\r\n buffer = [];\r\n }\r\n }, 3e3);\r\n } else {\r\n devtoolsNotInstalled = true;\r\n buffer = [];\r\n }\r\n}\r\nfunction devtoolsInitApp(app, version) {\r\n emit$1(\"app:init\" /* APP_INIT */, app, version, {\r\n Fragment,\r\n Text,\r\n Comment,\r\n Static\r\n });\r\n}\r\nfunction devtoolsUnmountApp(app) {\r\n emit$1(\"app:unmount\" /* APP_UNMOUNT */, app);\r\n}\r\nconst devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(\r\n \"component:added\" /* COMPONENT_ADDED */\r\n);\r\nconst devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook(\"component:updated\" /* COMPONENT_UPDATED */);\r\nconst _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(\r\n \"component:removed\" /* COMPONENT_REMOVED */\r\n);\r\nconst devtoolsComponentRemoved = (component) => {\r\n if (devtools$1 && typeof devtools$1.cleanupBuffer === \"function\" && // remove the component if it wasn't buffered\r\n !devtools$1.cleanupBuffer(component)) {\r\n _devtoolsComponentRemoved(component);\r\n }\r\n};\r\n/*! #__NO_SIDE_EFFECTS__ */\r\n// @__NO_SIDE_EFFECTS__\r\nfunction createDevtoolsComponentHook(hook) {\r\n return (component) => {\r\n emit$1(\r\n hook,\r\n component.appContext.app,\r\n component.uid,\r\n component.parent ? component.parent.uid : void 0,\r\n component\r\n );\r\n };\r\n}\r\nconst devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(\r\n \"perf:start\" /* PERFORMANCE_START */\r\n);\r\nconst devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(\r\n \"perf:end\" /* PERFORMANCE_END */\r\n);\r\nfunction createDevtoolsPerformanceHook(hook) {\r\n return (component, type, time) => {\r\n emit$1(hook, component.appContext.app, component.uid, component, type, time);\r\n };\r\n}\r\nfunction devtoolsComponentEmit(component, event, params) {\r\n emit$1(\r\n \"component:emit\" /* COMPONENT_EMIT */,\r\n component.appContext.app,\r\n component,\r\n event,\r\n params\r\n );\r\n}\r\n\r\nlet currentRenderingInstance = null;\r\nlet currentScopeId = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n const prev = currentRenderingInstance;\r\n currentRenderingInstance = instance;\r\n currentScopeId = instance && instance.type.__scopeId || null;\r\n return prev;\r\n}\r\nfunction pushScopeId(id) {\r\n currentScopeId = id;\r\n}\r\nfunction popScopeId() {\r\n currentScopeId = null;\r\n}\r\nconst withScopeId = (_id) => withCtx;\r\nfunction withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {\r\n if (!ctx) return fn;\r\n if (fn._n) {\r\n return fn;\r\n }\r\n const renderFnWithContext = (...args) => {\r\n if (renderFnWithContext._d) {\r\n setBlockTracking(-1);\r\n }\r\n const prevInstance = setCurrentRenderingInstance(ctx);\r\n let res;\r\n try {\r\n res = fn(...args);\r\n } finally {\r\n setCurrentRenderingInstance(prevInstance);\r\n if (renderFnWithContext._d) {\r\n setBlockTracking(1);\r\n }\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\") || __VUE_PROD_DEVTOOLS__) {\r\n devtoolsComponentUpdated(ctx);\r\n }\r\n return res;\r\n };\r\n renderFnWithContext._n = true;\r\n renderFnWithContext._c = true;\r\n renderFnWithContext._d = true;\r\n return renderFnWithContext;\r\n}\r\n\r\nfunction validateDirectiveName(name) {\r\n if (isBuiltInDirective(name)) {\r\n warn$1(\"Do not use built-in directive ids as custom directive id: \" + name);\r\n }\r\n}\r\nfunction withDirectives(vnode, directives) {\r\n if (currentRenderingInstance === null) {\r\n !!(process.env.NODE_ENV !== \"production\") && warn$1(`withDirectives can only be used inside render functions.`);\r\n return vnode;\r\n }\r\n const instance = getComponentPublicInstance(currentRenderingInstance);\r\n const bindings = vnode.dirs || (vnode.dirs = []);\r\n for (let i = 0; i < directives.length; i++) {\r\n let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];\r\n if (dir) {\r\n if (isFunction(dir)) {\r\n dir = {\r\n mounted: dir,\r\n updated: dir\r\n };\r\n }\r\n if (dir.deep) {\r\n traverse(value);\r\n }\r\n bindings.push({\r\n dir,\r\n instance,\r\n value,\r\n oldValue: void 0,\r\n arg,\r\n modifiers\r\n });\r\n }\r\n }\r\n return vnode;\r\n}\r\nfunction invokeDirectiveHook(vnode, prevVNode, instance, name) {\r\n const bindings = vnode.dirs;\r\n const oldBindings = prevVNode && prevVNode.dirs;\r\n for (let i = 0; i < bindings.length; i++) {\r\n const binding = bindings[i];\r\n if (oldBindings) {\r\n binding.oldValue = oldBindings[i].value;\r\n }\r\n let hook = binding.dir[name];\r\n if (hook) {\r\n pauseTracking();\r\n callWithAsyncErrorHandling(hook, instance, 8, [\r\n vnode.el,\r\n binding,\r\n vnode,\r\n prevVNode\r\n ]);\r\n resetTracking();\r\n }\r\n }\r\n}\r\n\r\nconst leaveCbKey = Symbol(\"_leaveCb\");\r\nconst enterCbKey = Symbol(\"_enterCb\");\r\nfunction useTransitionState() {\r\n const state = {\r\n isMounted: false,\r\n isLeaving: false,\r\n isUnmounting: false,\r\n leavingVNodes: /* @__PURE__ */ new Map()\r\n };\r\n onMounted(() => {\r\n state.isMounted = true;\r\n });\r\n onBeforeUnmount(() => {\r\n state.isUnmounting = true;\r\n });\r\n return state;\r\n}\r\nconst TransitionHookValidator = [Function, Array];\r\nconst BaseTransitionPropsValidators = {\r\n mode: String,\r\n appear: Boolean,\r\n persisted: Boolean,\r\n // enter\r\n onBeforeEnter: TransitionHookValidator,\r\n onEnter: TransitionHookValidator,\r\n onAfterEnter: TransitionHookValidator,\r\n onEnterCancelled: TransitionHookValidator,\r\n // leave\r\n onBeforeLeave: TransitionHookValidator,\r\n onLeave: TransitionHookValidator,\r\n onAfterLeave: TransitionHookValidator,\r\n onLeaveCancelled: TransitionHookValidator,\r\n // appear\r\n onBeforeAppear: TransitionHookValidator,\r\n onAppear: TransitionHookValidator,\r\n onAfterAppear: TransitionHookValidator,\r\n onAppearCancelled: TransitionHookValidator\r\n};\r\nconst recursiveGetSubtree = (instance) => {\r\n const subTree = instance.subTree;\r\n return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;\r\n};\r\nconst BaseTransitionImpl = {\r\n name: `BaseTransition`,\r\n props: BaseTransitionPropsValidators,\r\n setup(props, { slots }) {\r\n const instance = getCurrentInstance();\r\n const state = useTransitionState();\r\n return () => {\r\n const children = slots.default && getTransitionRawChildren(slots.default(), true);\r\n if (!children || !children.length) {\r\n return;\r\n }\r\n let child = children[0];\r\n if (children.length > 1) {\r\n let hasFound = false;\r\n for (const c of children) {\r\n if (c.type !== Comment) {\r\n if (!!(process.env.NODE_ENV !== \"production\") && hasFound) {\r\n warn$1(\r\n \" can only be used on a single element or component. Use for lists.\"\r\n );\r\n break;\r\n }\r\n child = c;\r\n hasFound = true;\r\n if (!!!(process.env.NODE_ENV !== \"production\")) break;\r\n }\r\n }\r\n }\r\n const rawProps = toRaw(props);\r\n const { mode } = rawProps;\r\n if (!!(process.env.NODE_ENV !== \"production\") && mode && mode !== \"in-out\" && mode !== \"out-in\" && mode !== \"default\") {\r\n warn$1(`invalid mode: ${mode}`);\r\n }\r\n if (state.isLeaving) {\r\n return emptyPlaceholder(child);\r\n }\r\n const innerChild = getKeepAliveChild(child);\r\n if (!innerChild) {\r\n return emptyPlaceholder(child);\r\n }\r\n let enterHooks = resolveTransitionHooks(\r\n innerChild,\r\n rawProps,\r\n state,\r\n instance,\r\n // #11061, ensure enterHooks is fresh after clone\r\n (hooks) => enterHooks = hooks\r\n );\r\n setTransitionHooks(innerChild, enterHooks);\r\n const oldChild = instance.subTree;\r\n const oldInnerChild = oldChild && getKeepAliveChild(oldChild);\r\n if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {\r\n const leavingHooks = resolveTransitionHooks(\r\n oldInnerChild,\r\n rawProps,\r\n state,\r\n instance\r\n );\r\n setTransitionHooks(oldInnerChild, leavingHooks);\r\n if (mode === \"out-in\" && innerChild.type !== Comment) {\r\n state.isLeaving = true;\r\n leavingHooks.afterLeave = () => {\r\n state.isLeaving = false;\r\n if (instance.update.active !== false) {\r\n instance.effect.dirty = true;\r\n instance.update();\r\n }\r\n };\r\n return emptyPlaceholder(child);\r\n } else if (mode === \"in-out\" && innerChild.type !== Comment) {\r\n leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {\r\n const leavingVNodesCache = getLeavingNodesForType(\r\n state,\r\n oldInnerChild\r\n );\r\n leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;\r\n el[leaveCbKey] = () => {\r\n earlyRemove();\r\n el[leaveCbKey] = void 0;\r\n delete enterHooks.delayedLeave;\r\n };\r\n enterHooks.delayedLeave = delayedLeave;\r\n };\r\n }\r\n }\r\n return child;\r\n };\r\n }\r\n};\r\nconst BaseTransition = BaseTransitionImpl;\r\nfunction getLeavingNodesForType(state, vnode) {\r\n const { leavingVNodes } = state;\r\n let leavingVNodesCache = leavingVNodes.get(vnode.type);\r\n if (!leavingVNodesCache) {\r\n leavingVNodesCache = /* @__PURE__ */ Object.create(null);\r\n leavingVNodes.set(vnode.type, leavingVNodesCache);\r\n }\r\n return leavingVNodesCache;\r\n}\r\nfunction resolveTransitionHooks(vnode, props, state, instance, postClone) {\r\n const {\r\n appear,\r\n mode,\r\n persisted = false,\r\n onBeforeEnter,\r\n onEnter,\r\n onAfterEnter,\r\n onEnterCancelled,\r\n onBeforeLeave,\r\n onLeave,\r\n onAfterLeave,\r\n onLeaveCancelled,\r\n onBeforeAppear,\r\n onAppear,\r\n onAfterAppear,\r\n onAppearCancelled\r\n } = props;\r\n const key = String(vnode.key);\r\n const leavingVNodesCache = getLeavingNodesForType(state, vnode);\r\n const callHook = (hook, args) => {\r\n hook && callWithAsyncErrorHandling(\r\n hook,\r\n instance,\r\n 9,\r\n args\r\n );\r\n };\r\n const callAsyncHook = (hook, args) => {\r\n const done = args[1];\r\n callHook(hook, args);\r\n if (isArray(hook)) {\r\n if (hook.every((hook2) => hook2.length <= 1)) done();\r\n } else if (hook.length <= 1) {\r\n done();\r\n }\r\n };\r\n const hooks = {\r\n mode,\r\n persisted,\r\n beforeEnter(el) {\r\n let hook = onBeforeEnter;\r\n if (!state.isMounted) {\r\n if (appear) {\r\n hook = onBeforeAppear || onBeforeEnter;\r\n } else {\r\n return;\r\n }\r\n }\r\n if (el[leaveCbKey]) {\r\n el[leaveCbKey](\r\n true\r\n /* cancelled */\r\n );\r\n }\r\n const leavingVNode = leavingVNodesCache[key];\r\n if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {\r\n leavingVNode.el[leaveCbKey]();\r\n }\r\n callHook(hook, [el]);\r\n },\r\n enter(el) {\r\n let hook = onEnter;\r\n let afterHook = onAfterEnter;\r\n let cancelHook = onEnterCancelled;\r\n if (!state.isMounted) {\r\n if (appear) {\r\n hook = onAppear || onEnter;\r\n afterHook = onAfterAppear || onAfterEnter;\r\n cancelHook = onAppearCancelled || onEnterCancelled;\r\n } else {\r\n return;\r\n }\r\n }\r\n let called = false;\r\n const done = el[enterCbKey] = (cancelled) => {\r\n if (called) return;\r\n called = true;\r\n if (cancelled) {\r\n callHook(cancelHook, [el]);\r\n } else {\r\n callHook(afterHook, [el]);\r\n }\r\n if (hooks.delayedLeave) {\r\n hooks.delayedLeave();\r\n }\r\n el[enterCbKey] = void 0;\r\n };\r\n if (hook) {\r\n callAsyncHook(hook, [el, done]);\r\n } else {\r\n done();\r\n }\r\n },\r\n leave(el, remove) {\r\n const key2 = String(vnode.key);\r\n if (el[enterCbKey]) {\r\n el[enterCbKey](\r\n true\r\n /* cancelled */\r\n );\r\n }\r\n if (state.isUnmounting) {\r\n return remove();\r\n }\r\n callHook(onBeforeLeave, [el]);\r\n let called = false;\r\n const done = el[leaveCbKey] = (cancelled) => {\r\n if (called) return;\r\n called = true;\r\n remove();\r\n if (cancelled) {\r\n callHook(onLeaveCancelled, [el]);\r\n } else {\r\n callHook(onAfterLeave, [el]);\r\n }\r\n el[leaveCbKey] = void 0;\r\n if (leavingVNodesCache[key2] === vnode) {\r\n delete leavingVNodesCache[key2];\r\n }\r\n };\r\n leavingVNodesCache[key2] = vnode;\r\n if (onLeave) {\r\n callAsyncHook(onLeave, [el, done]);\r\n } else {\r\n done();\r\n }\r\n },\r\n clone(vnode2) {\r\n const hooks2 = resolveTransitionHooks(\r\n vnode2,\r\n props,\r\n state,\r\n instance,\r\n postClone\r\n );\r\n if (postClone) postClone(hooks2);\r\n return hooks2;\r\n }\r\n };\r\n return hooks;\r\n}\r\nfunction emptyPlaceholder(vnode) {\r\n if (isKeepAlive(vnode)) {\r\n vnode = cloneVNode(vnode);\r\n vnode.children = null;\r\n return vnode;\r\n }\r\n}\r\nfunction getKeepAliveChild(vnode) {\r\n if (!isKeepAlive(vnode)) {\r\n return vnode;\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\") && vnode.component) {\r\n return vnode.component.subTree;\r\n }\r\n const { shapeFlag, children } = vnode;\r\n if (children) {\r\n if (shapeFlag & 16) {\r\n return children[0];\r\n }\r\n if (shapeFlag & 32 && isFunction(children.default)) {\r\n return children.default();\r\n }\r\n }\r\n}\r\nfunction setTransitionHooks(vnode, hooks) {\r\n if (vnode.shapeFlag & 6 && vnode.component) {\r\n setTransitionHooks(vnode.component.subTree, hooks);\r\n } else if (vnode.shapeFlag & 128) {\r\n vnode.ssContent.transition = hooks.clone(vnode.ssContent);\r\n vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);\r\n } else {\r\n vnode.transition = hooks;\r\n }\r\n}\r\nfunction getTransitionRawChildren(children, keepComment = false, parentKey) {\r\n let ret = [];\r\n let keyedFragmentCount = 0;\r\n for (let i = 0; i < children.length; i++) {\r\n let child = children[i];\r\n const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);\r\n if (child.type === Fragment) {\r\n if (child.patchFlag & 128) keyedFragmentCount++;\r\n ret = ret.concat(\r\n getTransitionRawChildren(child.children, keepComment, key)\r\n );\r\n } else if (keepComment || child.type !== Comment) {\r\n ret.push(key != null ? cloneVNode(child, { key }) : child);\r\n }\r\n }\r\n if (keyedFragmentCount > 1) {\r\n for (let i = 0; i < ret.length; i++) {\r\n ret[i].patchFlag = -2;\r\n }\r\n }\r\n return ret;\r\n}\r\n\r\n/*! #__NO_SIDE_EFFECTS__ */\r\n// @__NO_SIDE_EFFECTS__\r\nfunction defineComponent(options, extraOptions) {\r\n return isFunction(options) ? (\r\n // #8326: extend call and options.name access are considered side-effects\r\n // by Rollup, so we have to wrap it in a pure-annotated IIFE.\r\n /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()\r\n ) : options;\r\n}\r\n\r\nconst isAsyncWrapper = (i) => !!i.type.__asyncLoader;\r\n/*! #__NO_SIDE_EFFECTS__ */\r\n// @__NO_SIDE_EFFECTS__\r\nfunction defineAsyncComponent(source) {\r\n if (isFunction(source)) {\r\n source = { loader: source };\r\n }\r\n const {\r\n loader,\r\n loadingComponent,\r\n errorComponent,\r\n delay = 200,\r\n timeout,\r\n // undefined = never times out\r\n suspensible = true,\r\n onError: userOnError\r\n } = source;\r\n let pendingRequest = null;\r\n let resolvedComp;\r\n let retries = 0;\r\n const retry = () => {\r\n retries++;\r\n pendingRequest = null;\r\n return load();\r\n };\r\n const load = () => {\r\n let thisRequest;\r\n return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {\r\n err = err instanceof Error ? err : new Error(String(err));\r\n if (userOnError) {\r\n return new Promise((resolve, reject) => {\r\n const userRetry = () => resolve(retry());\r\n const userFail = () => reject(err);\r\n userOnError(err, userRetry, userFail, retries + 1);\r\n });\r\n } else {\r\n throw err;\r\n }\r\n }).then((comp) => {\r\n if (thisRequest !== pendingRequest && pendingRequest) {\r\n return pendingRequest;\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\") && !comp) {\r\n warn$1(\r\n `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`\r\n );\r\n }\r\n if (comp && (comp.__esModule || comp[Symbol.toStringTag] === \"Module\")) {\r\n comp = comp.default;\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\") && comp && !isObject(comp) && !isFunction(comp)) {\r\n throw new Error(`Invalid async component load result: ${comp}`);\r\n }\r\n resolvedComp = comp;\r\n return comp;\r\n }));\r\n };\r\n return defineComponent({\r\n name: \"AsyncComponentWrapper\",\r\n __asyncLoader: load,\r\n get __asyncResolved() {\r\n return resolvedComp;\r\n },\r\n setup() {\r\n const instance = currentInstance;\r\n if (resolvedComp) {\r\n return () => createInnerComp(resolvedComp, instance);\r\n }\r\n const onError = (err) => {\r\n pendingRequest = null;\r\n handleError(\r\n err,\r\n instance,\r\n 13,\r\n !errorComponent\r\n );\r\n };\r\n if (suspensible && instance.suspense || isInSSRComponentSetup) {\r\n return load().then((comp) => {\r\n return () => createInnerComp(comp, instance);\r\n }).catch((err) => {\r\n onError(err);\r\n return () => errorComponent ? createVNode(errorComponent, {\r\n error: err\r\n }) : null;\r\n });\r\n }\r\n const loaded = ref(false);\r\n const error = ref();\r\n const delayed = ref(!!delay);\r\n if (delay) {\r\n setTimeout(() => {\r\n delayed.value = false;\r\n }, delay);\r\n }\r\n if (timeout != null) {\r\n setTimeout(() => {\r\n if (!loaded.value && !error.value) {\r\n const err = new Error(\r\n `Async component timed out after ${timeout}ms.`\r\n );\r\n onError(err);\r\n error.value = err;\r\n }\r\n }, timeout);\r\n }\r\n load().then(() => {\r\n loaded.value = true;\r\n if (instance.parent && isKeepAlive(instance.parent.vnode)) {\r\n instance.parent.effect.dirty = true;\r\n queueJob(instance.parent.update);\r\n }\r\n }).catch((err) => {\r\n onError(err);\r\n error.value = err;\r\n });\r\n return () => {\r\n if (loaded.value && resolvedComp) {\r\n return createInnerComp(resolvedComp, instance);\r\n } else if (error.value && errorComponent) {\r\n return createVNode(errorComponent, {\r\n error: error.value\r\n });\r\n } else if (loadingComponent && !delayed.value) {\r\n return createVNode(loadingComponent);\r\n }\r\n };\r\n }\r\n });\r\n}\r\nfunction createInnerComp(comp, parent) {\r\n const { ref: ref2, props, children, ce } = parent.vnode;\r\n const vnode = createVNode(comp, props, children);\r\n vnode.ref = ref2;\r\n vnode.ce = ce;\r\n delete parent.vnode.ce;\r\n return vnode;\r\n}\r\n\r\nconst isKeepAlive = (vnode) => vnode.type.__isKeepAlive;\r\nconst KeepAliveImpl = {\r\n name: `KeepAlive`,\r\n // Marker for special handling inside the renderer. We are not using a ===\r\n // check directly on KeepAlive in the renderer, because importing it directly\r\n // would prevent it from being tree-shaken.\r\n __isKeepAlive: true,\r\n props: {\r\n include: [String, RegExp, Array],\r\n exclude: [String, RegExp, Array],\r\n max: [String, Number]\r\n },\r\n setup(props, { slots }) {\r\n const instance = getCurrentInstance();\r\n const sharedContext = instance.ctx;\r\n if (!sharedContext.renderer) {\r\n return () => {\r\n const children = slots.default && slots.default();\r\n return children && children.length === 1 ? children[0] : children;\r\n };\r\n }\r\n const cache = /* @__PURE__ */ new Map();\r\n const keys = /* @__PURE__ */ new Set();\r\n let current = null;\r\n if (!!(process.env.NODE_ENV !== \"production\") || __VUE_PROD_DEVTOOLS__) {\r\n instance.__v_cache = cache;\r\n }\r\n const parentSuspense = instance.suspense;\r\n const {\r\n renderer: {\r\n p: patch,\r\n m: move,\r\n um: _unmount,\r\n o: { createElement }\r\n }\r\n } = sharedContext;\r\n const storageContainer = createElement(\"div\");\r\n sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {\r\n const instance2 = vnode.component;\r\n move(vnode, container, anchor, 0, parentSuspense);\r\n patch(\r\n instance2.vnode,\r\n vnode,\r\n container,\r\n anchor,\r\n instance2,\r\n parentSuspense,\r\n namespace,\r\n vnode.slotScopeIds,\r\n optimized\r\n );\r\n queuePostRenderEffect(() => {\r\n instance2.isDeactivated = false;\r\n if (instance2.a) {\r\n invokeArrayFns(instance2.a);\r\n }\r\n const vnodeHook = vnode.props && vnode.props.onVnodeMounted;\r\n if (vnodeHook) {\r\n invokeVNodeHook(vnodeHook, instance2.parent, vnode);\r\n }\r\n }, parentSuspense);\r\n if (!!(process.env.NODE_ENV !== \"production\") || __VUE_PROD_DEVTOOLS__) {\r\n devtoolsComponentAdded(instance2);\r\n }\r\n };\r\n sharedContext.deactivate = (vnode) => {\r\n const instance2 = vnode.component;\r\n invalidateMount(instance2.m);\r\n invalidateMount(instance2.a);\r\n move(vnode, storageContainer, null, 1, parentSuspense);\r\n queuePostRenderEffect(() => {\r\n if (instance2.da) {\r\n invokeArrayFns(instance2.da);\r\n }\r\n const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;\r\n if (vnodeHook) {\r\n invokeVNodeHook(vnodeHook, instance2.parent, vnode);\r\n }\r\n instance2.isDeactivated = true;\r\n }, parentSuspense);\r\n if (!!(process.env.NODE_ENV !== \"production\") || __VUE_PROD_DEVTOOLS__) {\r\n devtoolsComponentAdded(instance2);\r\n }\r\n };\r\n function unmount(vnode) {\r\n resetShapeFlag(vnode);\r\n _unmount(vnode, instance, parentSuspense, true);\r\n }\r\n function pruneCache(filter) {\r\n cache.forEach((vnode, key) => {\r\n const name = getComponentName(vnode.type);\r\n if (name && (!filter || !filter(name))) {\r\n pruneCacheEntry(key);\r\n }\r\n });\r\n }\r\n function pruneCacheEntry(key) {\r\n const cached = cache.get(key);\r\n if (!current || !isSameVNodeType(cached, current)) {\r\n unmount(cached);\r\n } else if (current) {\r\n resetShapeFlag(current);\r\n }\r\n cache.delete(key);\r\n keys.delete(key);\r\n }\r\n watch(\r\n () => [props.include, props.exclude],\r\n ([include, exclude]) => {\r\n include && pruneCache((name) => matches(include, name));\r\n exclude && pruneCache((name) => !matches(exclude, name));\r\n },\r\n // prune post-render after `current` has been updated\r\n { flush: \"post\", deep: true }\r\n );\r\n let pendingCacheKey = null;\r\n const cacheSubtree = () => {\r\n if (pendingCacheKey != null) {\r\n if (isSuspense(instance.subTree.type)) {\r\n queuePostRenderEffect(() => {\r\n cache.set(pendingCacheKey, getInnerChild(instance.subTree));\r\n }, instance.subTree.suspense);\r\n } else {\r\n cache.set(pendingCacheKey, getInnerChild(instance.subTree));\r\n }\r\n }\r\n };\r\n onMounted(cacheSubtree);\r\n onUpdated(cacheSubtree);\r\n onBeforeUnmount(() => {\r\n cache.forEach((cached) => {\r\n const { subTree, suspense } = instance;\r\n const vnode = getInnerChild(subTree);\r\n if (cached.type === vnode.type && cached.key === vnode.key) {\r\n resetShapeFlag(vnode);\r\n const da = vnode.component.da;\r\n da && queuePostRenderEffect(da, suspense);\r\n return;\r\n }\r\n unmount(cached);\r\n });\r\n });\r\n return () => {\r\n pendingCacheKey = null;\r\n if (!slots.default) {\r\n return null;\r\n }\r\n const children = slots.default();\r\n const rawVNode = children[0];\r\n if (children.length > 1) {\r\n if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn$1(`KeepAlive should contain exactly one component child.`);\r\n }\r\n current = null;\r\n return children;\r\n } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {\r\n current = null;\r\n return rawVNode;\r\n }\r\n let vnode = getInnerChild(rawVNode);\r\n const comp = vnode.type;\r\n const name = getComponentName(\r\n isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp\r\n );\r\n const { include, exclude, max } = props;\r\n if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {\r\n current = vnode;\r\n return rawVNode;\r\n }\r\n const key = vnode.key == null ? comp : vnode.key;\r\n const cachedVNode = cache.get(key);\r\n if (vnode.el) {\r\n vnode = cloneVNode(vnode);\r\n if (rawVNode.shapeFlag & 128) {\r\n rawVNode.ssContent = vnode;\r\n }\r\n }\r\n pendingCacheKey = key;\r\n if (cachedVNode) {\r\n vnode.el = cachedVNode.el;\r\n vnode.component = cachedVNode.component;\r\n if (vnode.transition) {\r\n setTransitionHooks(vnode, vnode.transition);\r\n }\r\n vnode.shapeFlag |= 512;\r\n keys.delete(key);\r\n keys.add(key);\r\n } else {\r\n keys.add(key);\r\n if (max && keys.size > parseInt(max, 10)) {\r\n pruneCacheEntry(keys.values().next().value);\r\n }\r\n }\r\n vnode.shapeFlag |= 256;\r\n current = vnode;\r\n return isSuspense(rawVNode.type) ? rawVNode : vnode;\r\n };\r\n }\r\n};\r\nconst KeepAlive = KeepAliveImpl;\r\nfunction matches(pattern, name) {\r\n if (isArray(pattern)) {\r\n return pattern.some((p) => matches(p, name));\r\n } else if (isString(pattern)) {\r\n return pattern.split(\",\").includes(name);\r\n } else if (isRegExp(pattern)) {\r\n return pattern.test(name);\r\n }\r\n return false;\r\n}\r\nfunction onActivated(hook, target) {\r\n registerKeepAliveHook(hook, \"a\", target);\r\n}\r\nfunction onDeactivated(hook, target) {\r\n registerKeepAliveHook(hook, \"da\", target);\r\n}\r\nfunction registerKeepAliveHook(hook, type, target = currentInstance) {\r\n const wrappedHook = hook.__wdc || (hook.__wdc = () => {\r\n let current = target;\r\n while (current) {\r\n if (current.isDeactivated) {\r\n return;\r\n }\r\n current = current.parent;\r\n }\r\n return hook();\r\n });\r\n injectHook(type, wrappedHook, target);\r\n if (target) {\r\n let current = target.parent;\r\n while (current && current.parent) {\r\n if (isKeepAlive(current.parent.vnode)) {\r\n injectToKeepAliveRoot(wrappedHook, type, target, current);\r\n }\r\n current = current.parent;\r\n }\r\n }\r\n}\r\nfunction injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {\r\n const injected = injectHook(\r\n type,\r\n hook,\r\n keepAliveRoot,\r\n true\r\n /* prepend */\r\n );\r\n onUnmounted(() => {\r\n remove(keepAliveRoot[type], injected);\r\n }, target);\r\n}\r\nfunction resetShapeFlag(vnode) {\r\n vnode.shapeFlag &= ~256;\r\n vnode.shapeFlag &= ~512;\r\n}\r\nfunction getInnerChild(vnode) {\r\n return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;\r\n}\r\n\r\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\r\n if (target) {\r\n const hooks = target[type] || (target[type] = []);\r\n const wrappedHook = hook.__weh || (hook.__weh = (...args) => {\r\n pauseTracking();\r\n const reset = setCurrentInstance(target);\r\n const res = callWithAsyncErrorHandling(hook, target, type, args);\r\n reset();\r\n resetTracking();\r\n return res;\r\n });\r\n if (prepend) {\r\n hooks.unshift(wrappedHook);\r\n } else {\r\n hooks.push(wrappedHook);\r\n }\r\n return wrappedHook;\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, \"\"));\r\n warn$1(\r\n `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` )\r\n );\r\n }\r\n}\r\nconst createHook = (lifecycle) => (hook, target = currentInstance) => {\r\n if (!isInSSRComponentSetup || lifecycle === \"sp\") {\r\n injectHook(lifecycle, (...args) => hook(...args), target);\r\n }\r\n};\r\nconst onBeforeMount = createHook(\"bm\");\r\nconst onMounted = createHook(\"m\");\r\nconst onBeforeUpdate = createHook(\"bu\");\r\nconst onUpdated = createHook(\"u\");\r\nconst onBeforeUnmount = createHook(\"bum\");\r\nconst onUnmounted = createHook(\"um\");\r\nconst onServerPrefetch = createHook(\"sp\");\r\nconst onRenderTriggered = createHook(\r\n \"rtg\"\r\n);\r\nconst onRenderTracked = createHook(\r\n \"rtc\"\r\n);\r\nfunction onErrorCaptured(hook, target = currentInstance) {\r\n injectHook(\"ec\", hook, target);\r\n}\r\n\r\nconst COMPONENTS = \"components\";\r\nconst DIRECTIVES = \"directives\";\r\nfunction resolveComponent(name, maybeSelfReference) {\r\n return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;\r\n}\r\nconst NULL_DYNAMIC_COMPONENT = Symbol.for(\"v-ndc\");\r\nfunction resolveDynamicComponent(component) {\r\n if (isString(component)) {\r\n return resolveAsset(COMPONENTS, component, false) || component;\r\n } else {\r\n return component || NULL_DYNAMIC_COMPONENT;\r\n }\r\n}\r\nfunction resolveDirective(name) {\r\n return resolveAsset(DIRECTIVES, name);\r\n}\r\nfunction resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {\r\n const instance = currentRenderingInstance || currentInstance;\r\n if (instance) {\r\n const Component = instance.type;\r\n if (type === COMPONENTS) {\r\n const selfName = getComponentName(\r\n Component,\r\n false\r\n );\r\n if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {\r\n return Component;\r\n }\r\n }\r\n const res = (\r\n // local registration\r\n // check instance[type] first which is resolved for options API\r\n resolve(instance[type] || Component[type], name) || // global registration\r\n resolve(instance.appContext[type], name)\r\n );\r\n if (!res && maybeSelfReference) {\r\n return Component;\r\n }\r\n if (!!(process.env.NODE_ENV !== \"production\") && warnMissing && !res) {\r\n const extra = type === COMPONENTS ? `\r\nIf this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;\r\n warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);\r\n }\r\n return res;\r\n } else if (!!(process.env.NODE_ENV !== \"production\")) {\r\n warn$1(\r\n `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`\r\n );\r\n }\r\n}\r\nfunction resolve(registry, name) {\r\n return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);\r\n}\r\n\r\nfunction renderList(source, renderItem, cache, index) {\r\n let ret;\r\n const cached = cache && cache[index];\r\n if (isArray(source) || isString(source)) {\r\n ret = new Array(source.length);\r\n for (let i = 0, l = source.length; i < l; i++) {\r\n ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);\r\n }\r\n } else if (typeof source === \"number\") {\r\n if (!!(process.env.NODE_ENV !== \"production\") && !Number.isInteger(source)) {\r\n warn$1(`The v-for range expect an integer value but got ${source}.`);\r\n }\r\n ret = new Array(source);\r\n for (let i = 0; i < source; i++) {\r\n ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);\r\n }\r\n } else if (isObject(source)) {\r\n if (source[Symbol.iterator]) {\r\n ret = Array.from(\r\n source,\r\n (item, i) => renderItem(item, i, void 0, cached && cached[i])\r\n );\r\n } else {\r\n const keys = Object.keys(source);\r\n ret = new Array(keys.length);\r\n for (let i = 0, l = keys.length; i < l; i++) {\r\n const key = keys[i];\r\n ret[i] = renderItem(source[key], key, i, cached && cached[i]);\r\n }\r\n }\r\n } else {\r\n ret = [];\r\n }\r\n if (cache) {\r\n cache[index] = ret;\r\n }\r\n return ret;\r\n}\r\n\r\nfunction createSlots(slots, dynamicSlots) {\r\n for (let i = 0; i < dynamicSlots.length; i++) {\r\n const slot = dynamicSlots[i];\r\n if (isArray(slot)) {\r\n for (let j = 0; j < slot.length; j++) {\r\n slots[slot[j].name] = slot[j].fn;\r\n }\r\n } else if (slot) {\r\n slots[slot.name] = slot.key ? (...args) => {\r\n const res = slot.fn(...args);\r\n if (res) res.key = slot.key;\r\n return res;\r\n } : slot.fn;\r\n }\r\n }\r\n return slots;\r\n}\r\n\r\nfunction renderSlot(slots, name, props = {}, fallback, noSlotted) {\r\n if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {\r\n if (name !== \"default\") props.name = name;\r\n return createVNode(\"slot\", props, fallback && fallback());\r\n }\r\n let slot = slots[name];\r\n if (!!(process.env.NODE_ENV !== \"production\") && slot && slot.length > 1) {\r\n warn$1(\r\n `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`\r\n );\r\n slot = () => [];\r\n }\r\n if (slot && slot._c) {\r\n slot._d = false;\r\n }\r\n openBlock();\r\n const validSlotContent = slot && ensureValidVNode(slot(props));\r\n const rendered = createBlock(\r\n Fragment,\r\n {\r\n key: (props.key || // slot content array of a dynamic conditional slot may have a branch\r\n // key attached in the `createSlots` helper, respect that\r\n validSlotContent && validSlotContent.key || `_${name}`) + // #7256 force differentiate fallback content from actual content\r\n (!validSlotContent && fallback ? \"_fb\" : \"\")\r\n },\r\n validSlotContent || (fallback ? fallback() : []),\r\n validSlotContent && slots._ === 1 ? 64 : -2\r\n );\r\n if (!noSlotted && rendered.scopeId) {\r\n rendered.slotScopeIds = [rendered.scopeId + \"-s\"];\r\n }\r\n if (slot && slot._c) {\r\n slot._d = true;\r\n }\r\n return rendered;\r\n}\r\nfunction ensureValidVNode(vnodes) {\r\n return vnodes.some((child) => {\r\n if (!isVNode(child)) return true;\r\n if (child.type === Comment) return false;\r\n if (child.type === Fragment && !ensureValidVNode(child.children))\r\n return false;\r\n return true;\r\n }) ? vnodes : null;\r\n}\r\n\r\nfunction toHandlers(obj, preserveCaseIfNecessary) {\r\n const ret = {};\r\n if (!!(process.env.NODE_ENV !== \"production\") && !isObject(obj)) {\r\n warn$1(`v-on with no argument expects an object value.`);\r\n return ret;\r\n }\r\n for (const key in obj) {\r\n ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];\r\n }\r\n return ret;\r\n}\r\n\r\nconst getPublicInstance = (i) => {\r\n if (!i) return null;\r\n if (isStatefulComponent(i)) return getComponentPublicInstance(i);\r\n return getPublicInstance(i.parent);\r\n};\r\nconst publicPropertiesMap = (\r\n // Move PURE marker to new line to workaround compiler discarding it\r\n // due to type annotation\r\n /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {\r\n $: (i) => i,\r\n $el: (i) => i.vnode.el,\r\n $data: (i) => i.data,\r\n $props: (i) => !!(process.env.NODE_ENV !== \"production\") ? shallowReadonly(i.props) : i.props,\r\n $attrs: (i) => !!(process.env.NODE_ENV !== \"production\") ? shallowReadonly(i.attrs) : i.attrs,\r\n $slots: (i) => !!(process.env.NODE_ENV !== \"production\") ? shallowReadonly(i.slots) : i.slots,\r\n $refs: (i) => !!(process.env.NODE_ENV !== \"production\") ? shallowReadonly(i.refs) : i.refs,\r\n $parent: (i) => getPublicInstance(i.parent),\r\n $root: (i) => getPublicInstance(i.root),\r\n $emit: (i) => i.emit,\r\n $options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,\r\n $forceUpdate: (i) => i.f || (i.f = () => {\r\n i.effect.dirty = true;\r\n queueJob(i.update);\r\n }),\r\n $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),\r\n $watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP\r\n })\r\n);\r\nconst isReservedPrefix = (key) => key === \"_\" || key === \"$\";\r\nconst hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);\r\nconst PublicInstanceProxyHandlers = {\r\n get({ _: instance }, key) {\r\n if (key === \"__v_skip\") {\r\n return true;\r\n }\r\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n if (!!(process.env.NODE_ENV !== \"production\") && key === \"__isVue\") {\r\n return true;\r\n }\r\n let normalizedProps;\r\n if (key[0] !== \"$\") {\r\n const n = accessCache[key];\r\n if (n !== void 0) {\r\n switch (n) {\r\n case 1 /* SETUP */:\r\n return setupState[key];\r\n case 2 /* DATA */:\r\n return data[key];\r\n case 4 /* CONTEXT */:\r\n return ctx[key];\r\n case 3 /* PROPS */:\r\n return props[key];\r\n }\r\n } else if (hasSetupBinding(setupState, key)) {\r\n accessCache[key] = 1 /* SETUP */;\r\n return setupState[key];\r\n } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 2 /* DATA */;\r\n return data[key];\r\n } else if (\r\n // only cache other properties when instance has declared (thus stable)\r\n // props\r\n (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)\r\n ) {\r\n accessCache[key] = 3 /* PROPS */;\r\n return props[key];\r\n } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 4 /* CONTEXT */;\r\n return ctx[key];\r\n } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {\r\n accessCache[key] = 0 /* OTHER */;\r\n }\r\n }\r\n const publicGetter = publicPropertiesMap[key];\r\n let cssModule, globalProperties;\r\n if (publicGetter) {\r\n if (key === \"$attrs\") {\r\n track(instance.attrs, \"get\", \"\");\r\n !!(process.env.NODE_ENV !== \"production\") && markAttrsAccessed();\r\n } else if (!!(process.env.NODE_ENV !== \"production\") && key === \"$slots\") {\r\n track(instance, \"get\", key);\r\n }\r\n return publicGetter(instance);\r\n } else if (\r\n // css module (injected by vue-loader)\r\n (cssModule = type.__cssModules) && (cssModule = cssModule[key])\r\n ) {\r\n return cssModule;\r\n } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n accessCache[key] = 4 /* CONTEXT */;\r\n return ctx[key];\r\n } else if (\r\n // global properties\r\n globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)\r\n ) {\r\n {\r\n return globalProperties[key];\r\n }\r\n } else if (!!(process.env.NODE_ENV !== \"production\") && currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n // to infinite warning loop\r\n key.indexOf(\"__v\") !== 0)) {\r\n if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {\r\n warn$1(\r\n `Property ${JSON.stringify(\r\n key\r\n )} must be accessed via $data because it starts with a reserved character (\"$\" or \"_\") and is not proxied on the render context.`\r\n );\r\n } else if (instance === currentRenderingInstance) {\r\n warn$1(\r\n `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`\r\n );\r\n }\r\n }\r\n },\r\n set({ _: instance }, key, value) {\r\n const { data, setupState, ctx } = instance;\r\n if (hasSetupBinding(setupState, key)) {\r\n setupState[key] = value;\r\n return true;\r\n } else if (!!(process.env.NODE_ENV !== \"production\") && setupState.__isScriptSetup && hasOwn(setupState, key)) {\r\n warn$1(`Cannot mutate