diff --git a/.gitignore b/.gitignore
index 307bb5e..016ca54 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,7 @@
.nuxt
.nitro
.cache
-dist
+/dist
# Node dependencies
/node_modules
diff --git a/.output/server/node_modules/@unhead/dom/dist/index.mjs b/.output/server/node_modules/@unhead/dom/dist/index.mjs
new file mode 100644
index 0000000..5fd97f6
--- /dev/null
+++ b/.output/server/node_modules/@unhead/dom/dist/index.mjs
@@ -0,0 +1,133 @@
+import { HasElementTags, hashTag, normaliseProps, tagDedupeKey, defineHeadPlugin } from '@unhead/shared';
+
+async function elementToTag($el) {
+ const tag = {
+ tag: $el.tagName.toLowerCase(),
+ props: await normaliseProps(
+ $el.getAttributeNames().reduce((props, name) => ({ ...props, [name]: $el.getAttribute(name) }), {})
+ ),
+ innerHTML: $el.innerHTML
+ };
+ tag._d = tagDedupeKey(tag);
+ return tag;
+}
+async function renderDOMHead(head, options = {}) {
+ const dom = options.document || head.resolvedOptions.document;
+ if (!dom)
+ return;
+ const beforeRenderCtx = { shouldRender: head.dirty, tags: [] };
+ await head.hooks.callHook("dom:beforeRender", beforeRenderCtx);
+ if (!beforeRenderCtx.shouldRender)
+ return;
+ const tags = (await head.resolveTags()).map((tag) => ({
+ tag,
+ id: HasElementTags.includes(tag.tag) ? hashTag(tag) : tag.tag,
+ shouldRender: true
+ }));
+ let state = head._dom;
+ if (!state) {
+ state = {
+ elMap: { htmlAttrs: dom.documentElement, bodyAttrs: dom.body }
+ };
+ for (const key of ["body", "head"]) {
+ const children = dom?.[key]?.children;
+ for (const c of [...children].filter((c2) => HasElementTags.includes(c2.tagName.toLowerCase())))
+ state.elMap[c.getAttribute("data-hid") || hashTag(await elementToTag(c))] = c;
+ }
+ }
+ state.pendingSideEffects = { ...state.sideEffects || {} };
+ state.sideEffects = {};
+ function track(id, scope, fn) {
+ const k = `${id}:${scope}`;
+ state.sideEffects[k] = fn;
+ delete state.pendingSideEffects[k];
+ }
+ function trackCtx({ id, $el, tag }) {
+ const isAttrTag = tag.tag.endsWith("Attrs");
+ state.elMap[id] = $el;
+ if (!isAttrTag) {
+ ["textContent", "innerHTML"].forEach((k) => {
+ tag[k] && tag[k] !== $el[k] && ($el[k] = tag[k]);
+ });
+ track(id, "el", () => {
+ state.elMap[id].remove();
+ delete state.elMap[id];
+ });
+ }
+ Object.entries(tag.props).forEach(([k, value]) => {
+ const ck = `attr:${k}`;
+ if (k === "class") {
+ for (const c of (value || "").split(" ").filter(Boolean)) {
+ isAttrTag && track(id, `${ck}:${c}`, () => $el.classList.remove(c));
+ !$el.classList.contains(c) && $el.classList.add(c);
+ }
+ } else {
+ $el.getAttribute(k) !== value && $el.setAttribute(k, value === true ? "" : String(value));
+ isAttrTag && track(id, ck, () => $el.removeAttribute(k));
+ }
+ });
+ }
+ const pending = [];
+ const frag = {
+ bodyClose: void 0,
+ bodyOpen: void 0,
+ head: void 0
+ };
+ for (const ctx of tags) {
+ const { tag, shouldRender, id } = ctx;
+ if (!shouldRender)
+ continue;
+ if (tag.tag === "title") {
+ dom.title = tag.textContent;
+ continue;
+ }
+ ctx.$el = ctx.$el || state.elMap[id];
+ if (ctx.$el)
+ trackCtx(ctx);
+ else
+ HasElementTags.includes(tag.tag) && pending.push(ctx);
+ }
+ for (const ctx of pending) {
+ const pos = ctx.tag.tagPosition || "head";
+ ctx.$el = dom.createElement(ctx.tag.tag);
+ trackCtx(ctx);
+ frag[pos] = frag[pos] || dom.createDocumentFragment();
+ frag[pos].appendChild(ctx.$el);
+ }
+ for (const ctx of tags)
+ await head.hooks.callHook("dom:renderTag", ctx, dom, track);
+ frag.head && dom.head.appendChild(frag.head);
+ frag.bodyOpen && dom.body.insertBefore(frag.bodyOpen, dom.body.firstChild);
+ frag.bodyClose && dom.body.appendChild(frag.bodyClose);
+ Object.values(state.pendingSideEffects).forEach((fn) => fn());
+ head._dom = state;
+ head.dirty = false;
+ await head.hooks.callHook("dom:rendered", { renders: tags });
+}
+
+async function debouncedRenderDOMHead(head, options = {}) {
+ const fn = options.delayFn || ((fn2) => setTimeout(fn2, 10));
+ return head._domUpdatePromise = head._domUpdatePromise || new Promise((resolve) => fn(async () => {
+ await renderDOMHead(head, options);
+ delete head._domUpdatePromise;
+ resolve();
+ }));
+}
+
+// @__NO_SIDE_EFFECTS__
+function DomPlugin(options) {
+ return defineHeadPlugin((head) => {
+ const initialPayload = head.resolvedOptions.document?.head.querySelector('script[id="unhead:payload"]')?.innerHTML || false;
+ initialPayload && head.push(JSON.parse(initialPayload));
+ return {
+ mode: "client",
+ hooks: {
+ "entries:updated": function(head2) {
+ debouncedRenderDOMHead(head2, options);
+ }
+ }
+ };
+ });
+}
+
+export { DomPlugin, debouncedRenderDOMHead, renderDOMHead };
diff --git a/.output/server/node_modules/@unhead/shared/dist/index.mjs b/.output/server/node_modules/@unhead/shared/dist/index.mjs
new file mode 100644
index 0000000..1485155
--- /dev/null
+++ b/.output/server/node_modules/@unhead/shared/dist/index.mjs
@@ -0,0 +1,640 @@
+function asArray$1(value) {
+ return Array.isArray(value) ? value : [value];
+}
+
+const SelfClosingTags = ["meta", "link", "base"];
+const TagsWithInnerContent = ["title", "titleTemplate", "script", "style", "noscript"];
+const HasElementTags = [
+ "base",
+ "meta",
+ "link",
+ "style",
+ "script",
+ "noscript"
+];
+const ValidHeadTags = [
+ "title",
+ "titleTemplate",
+ "templateParams",
+ "base",
+ "htmlAttrs",
+ "bodyAttrs",
+ "meta",
+ "link",
+ "style",
+ "script",
+ "noscript"
+];
+const UniqueTags = ["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"];
+const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy", "children", "innerHTML", "textContent", "processTemplateParams"];
+const IsBrowser = typeof window !== "undefined";
+const composableNames = [
+ "getActiveHead",
+ "useHead",
+ "useSeoMeta",
+ "useHeadSafe",
+ "useServerHead",
+ "useServerSeoMeta",
+ "useServerHeadSafe"
+];
+
+function defineHeadPlugin(plugin) {
+ return plugin;
+}
+
+function hashCode(s) {
+ let h = 9;
+ for (let i = 0; i < s.length; )
+ h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
+ return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+}
+function hashTag(tag) {
+ return tag._h || hashCode(tag._d ? tag._d : `${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
+}
+
+function tagDedupeKey(tag, fn) {
+ const { props, tag: tagName } = tag;
+ if (UniqueTags.includes(tagName))
+ return tagName;
+ if (tagName === "link" && props.rel === "canonical")
+ return "canonical";
+ if (props.charset)
+ return "charset";
+ const name = ["id"];
+ if (tagName === "meta")
+ name.push(...["name", "property", "http-equiv"]);
+ for (const n of name) {
+ if (typeof props[n] !== "undefined") {
+ const val = String(props[n]);
+ if (fn && !fn(val))
+ return false;
+ return `${tagName}:${n}:${val}`;
+ }
+ }
+ return false;
+}
+
+function resolveTitleTemplate(template, title) {
+ if (template == null)
+ return title || null;
+ if (typeof template === "function")
+ return template(title);
+ return template;
+}
+
+function asArray(input) {
+ return Array.isArray(input) ? input : [input];
+}
+const InternalKeySymbol = "_$key";
+function packObject(input, options) {
+ const keys = Object.keys(input);
+ let [k, v] = keys;
+ options = options || {};
+ options.key = options.key || k;
+ options.value = options.value || v;
+ options.resolveKey = options.resolveKey || ((k2) => k2);
+ const resolveKey = (index) => {
+ const arr = asArray(options?.[index]);
+ return arr.find((k2) => {
+ if (typeof k2 === "string" && k2.includes(".")) {
+ return k2;
+ }
+ return k2 && keys.includes(k2);
+ });
+ };
+ const resolveValue = (k2, input2) => {
+ if (k2.includes(".")) {
+ const paths = k2.split(".");
+ let val = input2;
+ for (const path of paths)
+ val = val[path];
+ return val;
+ }
+ return input2[k2];
+ };
+ k = resolveKey("key") || k;
+ v = resolveKey("value") || v;
+ const dedupeKeyPrefix = input.key ? `${InternalKeySymbol}${input.key}-` : "";
+ let keyValue = resolveValue(k, input);
+ keyValue = options.resolveKey(keyValue);
+ return {
+ [`${dedupeKeyPrefix}${keyValue}`]: resolveValue(v, input)
+ };
+}
+
+function packArray(input, options) {
+ const packed = {};
+ for (const i of input) {
+ const packedObj = packObject(i, options);
+ const pKey = Object.keys(packedObj)[0];
+ const isDedupeKey = pKey.startsWith(InternalKeySymbol);
+ if (!isDedupeKey && packed[pKey]) {
+ packed[pKey] = Array.isArray(packed[pKey]) ? packed[pKey] : [packed[pKey]];
+ packed[pKey].push(Object.values(packedObj)[0]);
+ } else {
+ packed[isDedupeKey ? pKey.split("-").slice(1).join("-") || pKey : pKey] = packedObj[pKey];
+ }
+ }
+ return packed;
+}
+
+function unpackToArray(input, options) {
+ const unpacked = [];
+ const kFn = options.resolveKeyData || ((ctx) => ctx.key);
+ const vFn = options.resolveValueData || ((ctx) => ctx.value);
+ for (const [k, v] of Object.entries(input)) {
+ unpacked.push(...(Array.isArray(v) ? v : [v]).map((i) => {
+ const ctx = { key: k, value: i };
+ const val = vFn(ctx);
+ if (typeof val === "object")
+ return unpackToArray(val, options);
+ if (Array.isArray(val))
+ return val;
+ return {
+ [typeof options.key === "function" ? options.key(ctx) : options.key]: kFn(ctx),
+ [typeof options.value === "function" ? options.value(ctx) : options.value]: val
+ };
+ }).flat());
+ }
+ return unpacked;
+}
+
+function unpackToString(value, options) {
+ return Object.entries(value).map(([key, value2]) => {
+ if (typeof value2 === "object")
+ value2 = unpackToString(value2, options);
+ if (options.resolve) {
+ const resolved = options.resolve({ key, value: value2 });
+ if (resolved)
+ return resolved;
+ }
+ if (typeof value2 === "number")
+ value2 = value2.toString();
+ if (typeof value2 === "string" && options.wrapValue) {
+ value2 = value2.replace(new RegExp(options.wrapValue, "g"), `\\${options.wrapValue}`);
+ value2 = `${options.wrapValue}${value2}${options.wrapValue}`;
+ }
+ return `${key}${options.keyValueSeparator || ""}${value2}`;
+ }).join(options.entrySeparator || "");
+}
+
+const p = (p2) => ({ keyValue: p2, metaKey: "property" });
+const k = (p2) => ({ keyValue: p2 });
+const MetaPackingSchema = {
+ appleItunesApp: {
+ unpack: {
+ entrySeparator: ", ",
+ resolve({ key, value }) {
+ return `${fixKeyCase(key)}=${value}`;
+ }
+ }
+ },
+ articleExpirationTime: p("article:expiration_time"),
+ articleModifiedTime: p("article:modified_time"),
+ articlePublishedTime: p("article:published_time"),
+ bookReleaseDate: p("book:release_date"),
+ charset: {
+ metaKey: "charset"
+ },
+ contentSecurityPolicy: {
+ unpack: {
+ entrySeparator: "; ",
+ resolve({ key, value }) {
+ return `${fixKeyCase(key)} ${value}`;
+ }
+ },
+ metaKey: "http-equiv"
+ },
+ contentType: {
+ metaKey: "http-equiv"
+ },
+ defaultStyle: {
+ metaKey: "http-equiv"
+ },
+ fbAppId: p("fb:app_id"),
+ msapplicationConfig: k("msapplication-Config"),
+ msapplicationTileColor: k("msapplication-TileColor"),
+ msapplicationTileImage: k("msapplication-TileImage"),
+ ogAudioSecureUrl: p("og:audio:secure_url"),
+ ogAudioUrl: p("og:audio"),
+ ogImageSecureUrl: p("og:image:secure_url"),
+ ogImageUrl: p("og:image"),
+ ogSiteName: p("og:site_name"),
+ ogVideoSecureUrl: p("og:video:secure_url"),
+ ogVideoUrl: p("og:video"),
+ profileFirstName: p("profile:first_name"),
+ profileLastName: p("profile:last_name"),
+ profileUsername: p("profile:username"),
+ refresh: {
+ metaKey: "http-equiv",
+ unpack: {
+ entrySeparator: ";",
+ resolve({ key, value }) {
+ if (key === "seconds")
+ return `${value}`;
+ }
+ }
+ },
+ robots: {
+ unpack: {
+ entrySeparator: ", ",
+ resolve({ key, value }) {
+ if (typeof value === "boolean")
+ return `${fixKeyCase(key)}`;
+ else
+ return `${fixKeyCase(key)}:${value}`;
+ }
+ }
+ },
+ xUaCompatible: {
+ metaKey: "http-equiv"
+ }
+};
+const openGraphNamespaces = [
+ "og",
+ "book",
+ "article",
+ "profile"
+];
+function resolveMetaKeyType(key) {
+ const fKey = fixKeyCase(key).split(":")[0];
+ if (openGraphNamespaces.includes(fKey))
+ return "property";
+ return MetaPackingSchema[key]?.metaKey || "name";
+}
+function resolveMetaKeyValue(key) {
+ return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
+}
+function fixKeyCase(key) {
+ const updated = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+ const fKey = updated.split("-")[0];
+ if (openGraphNamespaces.includes(fKey) || fKey === "twitter")
+ return key.replace(/([A-Z])/g, ":$1").toLowerCase();
+ return updated;
+}
+function changeKeyCasingDeep(input) {
+ if (Array.isArray(input)) {
+ return input.map((entry) => changeKeyCasingDeep(entry));
+ }
+ if (typeof input !== "object" || Array.isArray(input))
+ return input;
+ const output = {};
+ for (const [key, value] of Object.entries(input))
+ output[fixKeyCase(key)] = changeKeyCasingDeep(value);
+ return output;
+}
+function resolvePackedMetaObjectValue(value, key) {
+ const definition = MetaPackingSchema[key];
+ if (key === "refresh")
+ return `${value.seconds};url=${value.url}`;
+ return unpackToString(
+ changeKeyCasingDeep(value),
+ {
+ keyValueSeparator: "=",
+ entrySeparator: ", ",
+ resolve({ value: value2, key: key2 }) {
+ if (value2 === null)
+ return "";
+ if (typeof value2 === "boolean")
+ return `${key2}`;
+ },
+ ...definition?.unpack
+ }
+ );
+}
+const ObjectArrayEntries = ["og:image", "og:video", "og:audio", "twitter:image"];
+function sanitize(input) {
+ const out = {};
+ Object.entries(input).forEach(([k2, v]) => {
+ if (String(v) !== "false" && k2)
+ out[k2] = v;
+ });
+ return out;
+}
+function handleObjectEntry(key, v) {
+ const value = sanitize(v);
+ const fKey = fixKeyCase(key);
+ const attr = resolveMetaKeyType(fKey);
+ if (ObjectArrayEntries.includes(fKey)) {
+ const input = {};
+ Object.entries(value).forEach(([k2, v2]) => {
+ input[`${key}${k2 === "url" ? "" : `${k2.charAt(0).toUpperCase()}${k2.slice(1)}`}`] = v2;
+ });
+ return unpackMeta(input).sort((a, b) => (a[attr]?.length || 0) - (b[attr]?.length || 0));
+ }
+ return [{ [attr]: fKey, ...value }];
+}
+function unpackMeta(input) {
+ const extras = [];
+ const primitives = {};
+ Object.entries(input).forEach(([key, value]) => {
+ if (!Array.isArray(value)) {
+ if (typeof value === "object" && value) {
+ if (ObjectArrayEntries.includes(fixKeyCase(key))) {
+ extras.push(...handleObjectEntry(key, value));
+ return;
+ }
+ primitives[key] = sanitize(value);
+ } else {
+ primitives[key] = value;
+ }
+ return;
+ }
+ value.forEach((v) => {
+ extras.push(...typeof v === "string" ? unpackMeta({ [key]: v }) : handleObjectEntry(key, v));
+ });
+ });
+ const meta = unpackToArray(primitives, {
+ key({ key }) {
+ return resolveMetaKeyType(key);
+ },
+ value({ key }) {
+ return key === "charset" ? "charset" : "content";
+ },
+ resolveKeyData({ key }) {
+ return resolveMetaKeyValue(key);
+ },
+ resolveValueData({ value, key }) {
+ if (value === null)
+ return "_null";
+ if (typeof value === "object")
+ return resolvePackedMetaObjectValue(value, key);
+ return typeof value === "number" ? value.toString() : value;
+ }
+ });
+ return [...extras, ...meta].map((m) => {
+ if (m.content === "_null")
+ m.content = null;
+ return m;
+ });
+}
+function packMeta(inputs) {
+ const mappedPackingSchema = Object.entries(MetaPackingSchema).map(([key, value]) => [key, value.keyValue]);
+ return packArray(inputs, {
+ key: ["name", "property", "httpEquiv", "http-equiv", "charset"],
+ value: ["content", "charset"],
+ resolveKey(k2) {
+ let key = mappedPackingSchema.filter((sk) => sk[1] === k2)?.[0]?.[0] || k2;
+ const replacer = (_, letter) => letter?.toUpperCase();
+ key = key.replace(/:([a-z])/g, replacer).replace(/-([a-z])/g, replacer);
+ return key;
+ }
+ });
+}
+
+const WhitelistAttributes = {
+ htmlAttrs: ["id", "class", "lang", "dir"],
+ bodyAttrs: ["id", "class"],
+ meta: ["id", "name", "property", "charset", "content"],
+ noscript: ["id", "textContent"],
+ script: ["id", "type", "textContent"],
+ link: ["id", "color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"]
+};
+function acceptDataAttrs(value) {
+ const filtered = {};
+ Object.keys(value || {}).filter((a) => a.startsWith("data-")).forEach((a) => {
+ filtered[a] = value[a];
+ });
+ return filtered;
+}
+function whitelistSafeInput(input) {
+ const filtered = {};
+ Object.keys(input).forEach((key) => {
+ const tagValue = input[key];
+ if (!tagValue)
+ return;
+ switch (key) {
+ case "title":
+ case "titleTemplate":
+ case "templateParams":
+ filtered[key] = tagValue;
+ break;
+ case "htmlAttrs":
+ case "bodyAttrs":
+ filtered[key] = acceptDataAttrs(tagValue);
+ WhitelistAttributes[key].forEach((a) => {
+ if (tagValue[a])
+ filtered[key][a] = tagValue[a];
+ });
+ break;
+ case "meta":
+ if (Array.isArray(tagValue)) {
+ filtered[key] = tagValue.map((meta) => {
+ const safeMeta = acceptDataAttrs(meta);
+ WhitelistAttributes.meta.forEach((key2) => {
+ if (meta[key2])
+ safeMeta[key2] = meta[key2];
+ });
+ return safeMeta;
+ }).filter((meta) => Object.keys(meta).length > 0);
+ }
+ break;
+ case "link":
+ if (Array.isArray(tagValue)) {
+ filtered[key] = tagValue.map((meta) => {
+ const link = acceptDataAttrs(meta);
+ WhitelistAttributes.link.forEach((key2) => {
+ const val = meta[key2];
+ if (key2 === "rel" && ["stylesheet", "canonical", "modulepreload", "prerender", "preload", "prefetch"].includes(val))
+ return;
+ if (key2 === "href") {
+ if (val.includes("javascript:") || val.includes("data:"))
+ return;
+ link[key2] = val;
+ } else if (val) {
+ link[key2] = val;
+ }
+ });
+ return link;
+ }).filter((link) => Object.keys(link).length > 1 && !!link.rel);
+ }
+ break;
+ case "noscript":
+ if (Array.isArray(tagValue)) {
+ filtered[key] = tagValue.map((meta) => {
+ const noscript = acceptDataAttrs(meta);
+ WhitelistAttributes.noscript.forEach((key2) => {
+ if (meta[key2])
+ noscript[key2] = meta[key2];
+ });
+ return noscript;
+ }).filter((meta) => Object.keys(meta).length > 0);
+ }
+ break;
+ case "script":
+ if (Array.isArray(tagValue)) {
+ filtered[key] = tagValue.map((script) => {
+ const safeScript = acceptDataAttrs(script);
+ WhitelistAttributes.script.forEach((s) => {
+ if (script[s]) {
+ if (s === "textContent") {
+ try {
+ const jsonVal = typeof script[s] === "string" ? JSON.parse(script[s]) : script[s];
+ safeScript[s] = JSON.stringify(jsonVal, null, 0);
+ } catch (e) {
+ }
+ } else {
+ safeScript[s] = script[s];
+ }
+ }
+ });
+ return safeScript;
+ }).filter((meta) => Object.keys(meta).length > 0);
+ }
+ break;
+ }
+ });
+ return filtered;
+}
+
+async function normaliseTag(tagName, input, e) {
+ const tag = {
+ tag: tagName,
+ props: await normaliseProps(
+ // explicitly check for an object
+ // @ts-expect-error untyped
+ typeof input === "object" && typeof input !== "function" && !(input instanceof Promise) ? { ...input } : { [["script", "noscript", "style"].includes(tagName) ? "innerHTML" : "textContent"]: input },
+ ["templateParams", "titleTemplate"].includes(tagName)
+ )
+ };
+ TagConfigKeys.forEach((k) => {
+ const val = typeof tag.props[k] !== "undefined" ? tag.props[k] : e[k];
+ if (typeof val !== "undefined") {
+ if (!["innerHTML", "textContent", "children"].includes(k) || TagsWithInnerContent.includes(tag.tag)) {
+ tag[k === "children" ? "innerHTML" : k] = val;
+ }
+ delete tag.props[k];
+ }
+ });
+ if (tag.props.body) {
+ tag.tagPosition = "bodyClose";
+ delete tag.props.body;
+ }
+ if (tag.tag === "script") {
+ if (typeof tag.innerHTML === "object") {
+ tag.innerHTML = JSON.stringify(tag.innerHTML);
+ tag.props.type = tag.props.type || "application/json";
+ }
+ }
+ return Array.isArray(tag.props.content) ? tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } })) : tag;
+}
+function normaliseClassProp(v) {
+ if (typeof v === "object" && !Array.isArray(v)) {
+ v = Object.keys(v).filter((k) => v[k]);
+ }
+ return (Array.isArray(v) ? v.join(" ") : v).split(" ").filter((c) => c.trim()).filter(Boolean).join(" ");
+}
+async function normaliseProps(props, virtual) {
+ for (const k of Object.keys(props)) {
+ if (k === "class") {
+ props[k] = normaliseClassProp(props[k]);
+ continue;
+ }
+ if (props[k] instanceof Promise)
+ props[k] = await props[k];
+ if (!virtual && !TagConfigKeys.includes(k)) {
+ const v = String(props[k]);
+ const isDataKey = k.startsWith("data-");
+ if (v === "true" || v === "") {
+ props[k] = isDataKey ? "true" : true;
+ } else if (!props[k]) {
+ if (isDataKey && v === "false")
+ props[k] = "false";
+ else
+ delete props[k];
+ }
+ }
+ }
+ return props;
+}
+const TagEntityBits = 10;
+async function normaliseEntryTags(e) {
+ const tagPromises = [];
+ Object.entries(e.resolvedInput).filter(([k, v]) => typeof v !== "undefined" && ValidHeadTags.includes(k)).forEach(([k, value]) => {
+ const v = asArray$1(value);
+ tagPromises.push(...v.map((props) => normaliseTag(k, props, e)).flat());
+ });
+ return (await Promise.all(tagPromises)).flat().filter(Boolean).map((t, i) => {
+ t._e = e._i;
+ e.mode && (t._m = e.mode);
+ t._p = (e._i << TagEntityBits) + i;
+ return t;
+ });
+}
+
+const TAG_WEIGHTS = {
+ // tags
+ base: -10,
+ title: 10
+};
+const TAG_ALIASES = {
+ // relative scores to their default values
+ critical: -80,
+ high: -10,
+ low: 20
+};
+function tagWeight(tag) {
+ let weight = 100;
+ const priority = tag.tagPriority;
+ if (typeof priority === "number")
+ return priority;
+ if (tag.tag === "meta") {
+ if (tag.props["http-equiv"] === "content-security-policy")
+ weight = -30;
+ if (tag.props.charset)
+ weight = -20;
+ if (tag.props.name === "viewport")
+ weight = -15;
+ } else if (tag.tag === "link" && tag.props.rel === "preconnect") {
+ weight = 20;
+ } else if (tag.tag in TAG_WEIGHTS) {
+ weight = TAG_WEIGHTS[tag.tag];
+ }
+ if (typeof priority === "string" && priority in TAG_ALIASES) {
+ return weight + TAG_ALIASES[priority];
+ }
+ return weight;
+}
+const SortModifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+
+const NetworkEvents = ["onload", "onerror", "onabort", "onprogress", "onloadstart"];
+
+const sepSub = "%separator";
+function processTemplateParams(s, p, sep) {
+ if (typeof s !== "string" || !s.includes("%"))
+ return s;
+ function sub(token) {
+ let val;
+ if (["s", "pageTitle"].includes(token)) {
+ val = p.pageTitle;
+ } else if (token.includes(".")) {
+ val = token.split(".").reduce((acc, key) => acc ? acc[key] || void 0 : void 0, p);
+ } else {
+ val = p[token];
+ }
+ return typeof val !== "undefined" ? (val || "").replace(/"/g, '\\"') : false;
+ }
+ let decoded = s;
+ try {
+ decoded = decodeURI(s);
+ } catch {
+ }
+ const tokens = (decoded.match(/%(\w+\.+\w+)|%(\w+)/g) || []).sort().reverse();
+ tokens.forEach((token) => {
+ const re = sub(token.slice(1));
+ if (typeof re === "string") {
+ s = s.replace(new RegExp(`\\${token}(\\W|$)`, "g"), (_, args) => `${re}${args}`).trim();
+ }
+ });
+ if (s.includes(sepSub)) {
+ if (s.endsWith(sepSub))
+ s = s.slice(0, -sepSub.length).trim();
+ if (s.startsWith(sepSub))
+ s = s.slice(sepSub.length).trim();
+ s = s.replace(new RegExp(`\\${sepSub}\\s*\\${sepSub}`, "g"), sepSub);
+ s = processTemplateParams(s, { separator: sep }, sep);
+ }
+ return s;
+}
+
+export { HasElementTags, IsBrowser, NetworkEvents, SelfClosingTags, SortModifiers, TAG_ALIASES, TAG_WEIGHTS, TagConfigKeys, TagEntityBits, TagsWithInnerContent, UniqueTags, ValidHeadTags, asArray$1 as asArray, composableNames, defineHeadPlugin, hashCode, hashTag, normaliseClassProp, normaliseEntryTags, normaliseProps, normaliseTag, packMeta, processTemplateParams, resolveMetaKeyType, resolveMetaKeyValue, resolvePackedMetaObjectValue, resolveTitleTemplate, tagDedupeKey, tagWeight, unpackMeta, whitelistSafeInput };
diff --git a/.output/server/node_modules/@unhead/ssr/dist/index.mjs b/.output/server/node_modules/@unhead/ssr/dist/index.mjs
new file mode 100644
index 0000000..732a57c
--- /dev/null
+++ b/.output/server/node_modules/@unhead/ssr/dist/index.mjs
@@ -0,0 +1,84 @@
+import { TagsWithInnerContent, SelfClosingTags } from '@unhead/shared';
+
+function encodeAttribute(value) {
+ return String(value).replace(/"/g, """);
+}
+function propsToString(props) {
+ const attrs = [];
+ for (const [key, value] of Object.entries(props)) {
+ if (value !== false && value !== null)
+ attrs.push(value === true ? key : `${key}="${encodeAttribute(value)}"`);
+ }
+ return `${attrs.length > 0 ? " " : ""}${attrs.join(" ")}`;
+}
+
+function escapeHtml(str) {
+ return str.replace(/[&<>"'/]/g, (char) => {
+ switch (char) {
+ case "&":
+ return "&";
+ case "<":
+ return "<";
+ case ">":
+ return ">";
+ case '"':
+ return """;
+ case "'":
+ return "'";
+ case "/":
+ return "/";
+ default:
+ return char;
+ }
+ });
+}
+function tagToString(tag) {
+ const attrs = propsToString(tag.props);
+ const openTag = `<${tag.tag}${attrs}>`;
+ if (!TagsWithInnerContent.includes(tag.tag))
+ return SelfClosingTags.includes(tag.tag) ? openTag : `${openTag}</${tag.tag}>`;
+ let content = String(tag.innerHTML || "");
+ if (tag.textContent)
+ content = escapeHtml(String(tag.textContent));
+ return SelfClosingTags.includes(tag.tag) ? openTag : `${openTag}${content}</${tag.tag}>`;
+}
+
+function ssrRenderTags(tags) {
+ const schema = { htmlAttrs: {}, bodyAttrs: {}, tags: { head: [], bodyClose: [], bodyOpen: [] } };
+ for (const tag of tags) {
+ if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
+ schema[tag.tag] = { ...schema[tag.tag], ...tag.props };
+ continue;
+ }
+ schema.tags[tag.tagPosition || "head"].push(tagToString(tag));
+ }
+ return {
+ headTags: schema.tags.head.join("\n"),
+ bodyTags: schema.tags.bodyClose.join("\n"),
+ bodyTagsOpen: schema.tags.bodyOpen.join("\n"),
+ htmlAttrs: propsToString(schema.htmlAttrs),
+ bodyAttrs: propsToString(schema.bodyAttrs)
+ };
+}
+
+async function renderSSRHead(head) {
+ const beforeRenderCtx = { shouldRender: true };
+ await head.hooks.callHook("ssr:beforeRender", beforeRenderCtx);
+ if (!beforeRenderCtx.shouldRender) {
+ return {
+ headTags: "",
+ bodyTags: "",
+ bodyTagsOpen: "",
+ htmlAttrs: "",
+ bodyAttrs: ""
+ };
+ }
+ const ctx = { tags: await head.resolveTags() };
+ await head.hooks.callHook("ssr:render", ctx);
+ const html = ssrRenderTags(ctx.tags);
+ const renderCtx = { tags: ctx.tags, html };
+ await head.hooks.callHook("ssr:rendered", renderCtx);
+ return renderCtx.html;
+}
+
+export { escapeHtml, propsToString, renderSSRHead, ssrRenderTags, tagToString };
diff --git a/.output/server/node_modules/@vue/compiler-core/dist/compiler-core.cjs.js b/.output/server/node_modules/@vue/compiler-core/dist/compiler-core.cjs.js
new file mode 100644
index 0000000..e3dd2ab
--- /dev/null
+++ b/.output/server/node_modules/@vue/compiler-core/dist/compiler-core.cjs.js
@@ -0,0 +1,5505 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('@vue/shared');
+var parser = require('@babel/parser');
+var sourceMapJs = require('source-map-js');
+var estreeWalker = require('estree-walker');
+
+function defaultOnError(error) {
+ throw error;
+}
+function defaultOnWarn(msg) {
+ console.warn(`[Vue warn] ${msg.message}`);
+}
+function createCompilerError(code, loc, messages, additionalMessage) {
+ const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
+ const error = new SyntaxError(String(msg));
+ error.code = code;
+ error.loc = loc;
+ return error;
+}
+const errorMessages = {
+ // parse errors
+ [0]: "Illegal comment.",
+ [1]: "CDATA section is allowed only in XML context.",
+ [2]: "Duplicate attribute.",
+ [3]: "End tag cannot have attributes.",
+ [4]: "Illegal '/' in tags.",
+ [5]: "Unexpected EOF in tag.",
+ [6]: "Unexpected EOF in CDATA section.",
+ [7]: "Unexpected EOF in comment.",
+ [8]: "Unexpected EOF in script.",
+ [9]: "Unexpected EOF in tag.",
+ [10]: "Incorrectly closed comment.",
+ [11]: "Incorrectly opened comment.",
+ [12]: "Illegal tag name. Use '<' to print '<'.",
+ [13]: "Attribute value was expected.",
+ [14]: "End tag name was expected.",
+ [15]: "Whitespace was expected.",
+ [16]: "Unexpected '<!--' in comment.",
+ [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
+ [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
+ [19]: "Attribute name cannot start with '='.",
+ [21]: "'<?' is allowed only in XML context.",
+ [20]: `Unexpected null character.`,
+ [22]: "Illegal '/' in tags.",
+ // Vue-specific parse errors
+ [23]: "Invalid end tag.",
+ [24]: "Element is missing end tag.",
+ [25]: "Interpolation end sign was not found.",
+ [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
+ [26]: "Legal directive name was expected.",
+ // transform errors
+ [28]: `v-if/v-else-if is missing expression.`,
+ [29]: `v-if/else branches must use unique keys.`,
+ [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
+ [31]: `v-for is missing expression.`,
+ [32]: `v-for has invalid expression.`,
+ [33]: `<template v-for> key should be placed on the <template> tag.`,
+ [34]: `v-bind is missing expression.`,
+ [35]: `v-on is missing expression.`,
+ [36]: `Unexpected custom directive on <slot> outlet.`,
+ [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
+ [38]: `Duplicate slot names found. `,
+ [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
+ [40]: `v-slot can only be used on components or <template> tags.`,
+ [41]: `v-model is missing expression.`,
+ [42]: `v-model value must be a valid JavaScript member expression.`,
+ [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
+ [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
+Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+ [45]: `Error parsing JavaScript expression: `,
+ [46]: `<KeepAlive> expects exactly one child component.`,
+ // generic errors
+ [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+ [48]: `ES module mode is not supported in this build of compiler.`,
+ [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+ [50]: `"scopeId" option is only supported in module mode.`,
+ // deprecations
+ [51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
+ [52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
+ // just to fulfill types
+ [53]: ``
+};
+
+const FRAGMENT = Symbol(`Fragment` );
+const TELEPORT = Symbol(`Teleport` );
+const SUSPENSE = Symbol(`Suspense` );
+const KEEP_ALIVE = Symbol(`KeepAlive` );
+const BASE_TRANSITION = Symbol(`BaseTransition` );
+const OPEN_BLOCK = Symbol(`openBlock` );
+const CREATE_BLOCK = Symbol(`createBlock` );
+const CREATE_ELEMENT_BLOCK = Symbol(`createElementBlock` );
+const CREATE_VNODE = Symbol(`createVNode` );
+const CREATE_ELEMENT_VNODE = Symbol(`createElementVNode` );
+const CREATE_COMMENT = Symbol(`createCommentVNode` );
+const CREATE_TEXT = Symbol(`createTextVNode` );
+const CREATE_STATIC = Symbol(`createStaticVNode` );
+const RESOLVE_COMPONENT = Symbol(`resolveComponent` );
+const RESOLVE_DYNAMIC_COMPONENT = Symbol(
+ `resolveDynamicComponent`
+);
+const RESOLVE_DIRECTIVE = Symbol(`resolveDirective` );
+const RESOLVE_FILTER = Symbol(`resolveFilter` );
+const WITH_DIRECTIVES = Symbol(`withDirectives` );
+const RENDER_LIST = Symbol(`renderList` );
+const RENDER_SLOT = Symbol(`renderSlot` );
+const CREATE_SLOTS = Symbol(`createSlots` );
+const TO_DISPLAY_STRING = Symbol(`toDisplayString` );
+const MERGE_PROPS = Symbol(`mergeProps` );
+const NORMALIZE_CLASS = Symbol(`normalizeClass` );
+const NORMALIZE_STYLE = Symbol(`normalizeStyle` );
+const NORMALIZE_PROPS = Symbol(`normalizeProps` );
+const GUARD_REACTIVE_PROPS = Symbol(`guardReactiveProps` );
+const TO_HANDLERS = Symbol(`toHandlers` );
+const CAMELIZE = Symbol(`camelize` );
+const CAPITALIZE = Symbol(`capitalize` );
+const TO_HANDLER_KEY = Symbol(`toHandlerKey` );
+const SET_BLOCK_TRACKING = Symbol(`setBlockTracking` );
+const PUSH_SCOPE_ID = Symbol(`pushScopeId` );
+const POP_SCOPE_ID = Symbol(`popScopeId` );
+const WITH_CTX = Symbol(`withCtx` );
+const UNREF = Symbol(`unref` );
+const IS_REF = Symbol(`isRef` );
+const WITH_MEMO = Symbol(`withMemo` );
+const IS_MEMO_SAME = Symbol(`isMemoSame` );
+const helperNameMap = {
+ [FRAGMENT]: `Fragment`,
+ [TELEPORT]: `Teleport`,
+ [SUSPENSE]: `Suspense`,
+ [KEEP_ALIVE]: `KeepAlive`,
+ [BASE_TRANSITION]: `BaseTransition`,
+ [OPEN_BLOCK]: `openBlock`,
+ [CREATE_BLOCK]: `createBlock`,
+ [CREATE_ELEMENT_BLOCK]: `createElementBlock`,
+ [CREATE_VNODE]: `createVNode`,
+ [CREATE_ELEMENT_VNODE]: `createElementVNode`,
+ [CREATE_COMMENT]: `createCommentVNode`,
+ [CREATE_TEXT]: `createTextVNode`,
+ [CREATE_STATIC]: `createStaticVNode`,
+ [RESOLVE_COMPONENT]: `resolveComponent`,
+ [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
+ [RESOLVE_DIRECTIVE]: `resolveDirective`,
+ [RESOLVE_FILTER]: `resolveFilter`,
+ [WITH_DIRECTIVES]: `withDirectives`,
+ [RENDER_LIST]: `renderList`,
+ [RENDER_SLOT]: `renderSlot`,
+ [CREATE_SLOTS]: `createSlots`,
+ [TO_DISPLAY_STRING]: `toDisplayString`,
+ [MERGE_PROPS]: `mergeProps`,
+ [NORMALIZE_CLASS]: `normalizeClass`,
+ [NORMALIZE_STYLE]: `normalizeStyle`,
+ [NORMALIZE_PROPS]: `normalizeProps`,
+ [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
+ [TO_HANDLERS]: `toHandlers`,
+ [CAMELIZE]: `camelize`,
+ [CAPITALIZE]: `capitalize`,
+ [TO_HANDLER_KEY]: `toHandlerKey`,
+ [SET_BLOCK_TRACKING]: `setBlockTracking`,
+ [PUSH_SCOPE_ID]: `pushScopeId`,
+ [POP_SCOPE_ID]: `popScopeId`,
+ [WITH_CTX]: `withCtx`,
+ [UNREF]: `unref`,
+ [IS_REF]: `isRef`,
+ [WITH_MEMO]: `withMemo`,
+ [IS_MEMO_SAME]: `isMemoSame`
+};
+function registerRuntimeHelpers(helpers) {
+ Object.getOwnPropertySymbols(helpers).forEach((s) => {
+ helperNameMap[s] = helpers[s];
+ });
+}
+
+const locStub = {
+ source: "",
+ start: { line: 1, column: 1, offset: 0 },
+ end: { line: 1, column: 1, offset: 0 }
+};
+function createRoot(children, loc = locStub) {
+ return {
+ type: 0,
+ children,
+ helpers: /* @__PURE__ */ new Set(),
+ components: [],
+ directives: [],
+ hoists: [],
+ imports: [],
+ cached: 0,
+ temps: 0,
+ codegenNode: void 0,
+ loc
+ };
+}
+function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
+ if (context) {
+ if (isBlock) {
+ context.helper(OPEN_BLOCK);
+ context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
+ } else {
+ context.helper(getVNodeHelper(context.inSSR, isComponent));
+ }
+ if (directives) {
+ context.helper(WITH_DIRECTIVES);
+ }
+ }
+ return {
+ type: 13,
+ tag,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ directives,
+ isBlock,
+ disableTracking,
+ isComponent,
+ loc
+ };
+}
+function createArrayExpression(elements, loc = locStub) {
+ return {
+ type: 17,
+ loc,
+ elements
+ };
+}
+function createObjectExpression(properties, loc = locStub) {
+ return {
+ type: 15,
+ loc,
+ properties
+ };
+}
+function createObjectProperty(key, value) {
+ return {
+ type: 16,
+ loc: locStub,
+ key: shared.isString(key) ? createSimpleExpression(key, true) : key,
+ value
+ };
+}
+function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
+ return {
+ type: 4,
+ loc,
+ content,
+ isStatic,
+ constType: isStatic ? 3 : constType
+ };
+}
+function createInterpolation(content, loc) {
+ return {
+ type: 5,
+ loc,
+ content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content
+ };
+}
+function createCompoundExpression(children, loc = locStub) {
+ return {
+ type: 8,
+ loc,
+ children
+ };
+}
+function createCallExpression(callee, args = [], loc = locStub) {
+ return {
+ type: 14,
+ loc,
+ callee,
+ arguments: args
+ };
+}
+function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
+ return {
+ type: 18,
+ params,
+ returns,
+ newline,
+ isSlot,
+ loc
+ };
+}
+function createConditionalExpression(test, consequent, alternate, newline = true) {
+ return {
+ type: 19,
+ test,
+ consequent,
+ alternate,
+ newline,
+ loc: locStub
+ };
+}
+function createCacheExpression(index, value, isVNode = false) {
+ return {
+ type: 20,
+ index,
+ value,
+ isVNode,
+ loc: locStub
+ };
+}
+function createBlockStatement(body) {
+ return {
+ type: 21,
+ body,
+ loc: locStub
+ };
+}
+function createTemplateLiteral(elements) {
+ return {
+ type: 22,
+ elements,
+ loc: locStub
+ };
+}
+function createIfStatement(test, consequent, alternate) {
+ return {
+ type: 23,
+ test,
+ consequent,
+ alternate,
+ loc: locStub
+ };
+}
+function createAssignmentExpression(left, right) {
+ return {
+ type: 24,
+ left,
+ right,
+ loc: locStub
+ };
+}
+function createSequenceExpression(expressions) {
+ return {
+ type: 25,
+ expressions,
+ loc: locStub
+ };
+}
+function createReturnStatement(returns) {
+ return {
+ type: 26,
+ returns,
+ loc: locStub
+ };
+}
+function getVNodeHelper(ssr, isComponent) {
+ return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
+}
+function getVNodeBlockHelper(ssr, isComponent) {
+ return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
+}
+function convertToBlock(node, { helper, removeHelper, inSSR }) {
+ if (!node.isBlock) {
+ node.isBlock = true;
+ removeHelper(getVNodeHelper(inSSR, node.isComponent));
+ helper(OPEN_BLOCK);
+ helper(getVNodeBlockHelper(inSSR, node.isComponent));
+ }
+}
+
+const isStaticExp = (p) => p.type === 4 && p.isStatic;
+const isBuiltInType = (tag, expected) => tag === expected || tag === shared.hyphenate(expected);
+function isCoreComponent(tag) {
+ if (isBuiltInType(tag, "Teleport")) {
+ return TELEPORT;
+ } else if (isBuiltInType(tag, "Suspense")) {
+ return SUSPENSE;
+ } else if (isBuiltInType(tag, "KeepAlive")) {
+ return KEEP_ALIVE;
+ } else if (isBuiltInType(tag, "BaseTransition")) {
+ return BASE_TRANSITION;
+ }
+}
+const nonIdentifierRE = /^\d|[^\$\w]/;
+const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
+const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
+const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
+const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
+const isMemberExpressionBrowser = (path) => {
+ path = path.trim().replace(whitespaceRE, (s) => s.trim());
+ let state = 0 /* inMemberExp */;
+ let stateStack = [];
+ let currentOpenBracketCount = 0;
+ let currentOpenParensCount = 0;
+ let currentStringType = null;
+ for (let i = 0; i < path.length; i++) {
+ const char = path.charAt(i);
+ switch (state) {
+ case 0 /* inMemberExp */:
+ if (char === "[") {
+ stateStack.push(state);
+ state = 1 /* inBrackets */;
+ currentOpenBracketCount++;
+ } else if (char === "(") {
+ stateStack.push(state);
+ state = 2 /* inParens */;
+ currentOpenParensCount++;
+ } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
+ return false;
+ }
+ break;
+ case 1 /* inBrackets */:
+ if (char === `'` || char === `"` || char === "`") {
+ stateStack.push(state);
+ state = 3 /* inString */;
+ currentStringType = char;
+ } else if (char === `[`) {
+ currentOpenBracketCount++;
+ } else if (char === `]`) {
+ if (!--currentOpenBracketCount) {
+ state = stateStack.pop();
+ }
+ }
+ break;
+ case 2 /* inParens */:
+ if (char === `'` || char === `"` || char === "`") {
+ stateStack.push(state);
+ state = 3 /* inString */;
+ currentStringType = char;
+ } else if (char === `(`) {
+ currentOpenParensCount++;
+ } else if (char === `)`) {
+ if (i === path.length - 1) {
+ return false;
+ }
+ if (!--currentOpenParensCount) {
+ state = stateStack.pop();
+ }
+ }
+ break;
+ case 3 /* inString */:
+ if (char === currentStringType) {
+ state = stateStack.pop();
+ currentStringType = null;
+ }
+ break;
+ }
+ }
+ return !currentOpenBracketCount && !currentOpenParensCount;
+};
+const isMemberExpressionNode = (path, context) => {
+ try {
+ let ret = parser.parseExpression(path, {
+ plugins: context.expressionPlugins
+ });
+ if (ret.type === "TSAsExpression" || ret.type === "TSTypeAssertion") {
+ ret = ret.expression;
+ }
+ return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier";
+ } catch (e) {
+ return false;
+ }
+};
+const isMemberExpression = isMemberExpressionNode;
+function getInnerRange(loc, offset, length) {
+ const source = loc.source.slice(offset, offset + length);
+ const newLoc = {
+ source,
+ start: advancePositionWithClone(loc.start, loc.source, offset),
+ end: loc.end
+ };
+ if (length != null) {
+ newLoc.end = advancePositionWithClone(
+ loc.start,
+ loc.source,
+ offset + length
+ );
+ }
+ return newLoc;
+}
+function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
+ return advancePositionWithMutation(
+ shared.extend({}, pos),
+ source,
+ numberOfCharacters
+ );
+}
+function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
+ let linesCount = 0;
+ let lastNewLinePos = -1;
+ for (let i = 0; i < numberOfCharacters; i++) {
+ if (source.charCodeAt(i) === 10) {
+ linesCount++;
+ lastNewLinePos = i;
+ }
+ }
+ pos.offset += numberOfCharacters;
+ pos.line += linesCount;
+ pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
+ return pos;
+}
+function assert(condition, msg) {
+ if (!condition) {
+ throw new Error(msg || `unexpected compiler condition`);
+ }
+}
+function findDir(node, name, allowEmpty = false) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) {
+ return p;
+ }
+ }
+}
+function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 6) {
+ if (dynamicOnly)
+ continue;
+ if (p.name === name && (p.value || allowEmpty)) {
+ return p;
+ }
+ } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
+ return p;
+ }
+ }
+}
+function isStaticArgOf(arg, name) {
+ return !!(arg && isStaticExp(arg) && arg.content === name);
+}
+function hasDynamicKeyVBind(node) {
+ return node.props.some(
+ (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
+ p.arg.type !== 4 || // v-bind:[_ctx.foo]
+ !p.arg.isStatic)
+ // v-bind:[foo]
+ );
+}
+function isText$1(node) {
+ return node.type === 5 || node.type === 2;
+}
+function isVSlot(p) {
+ return p.type === 7 && p.name === "slot";
+}
+function isTemplateNode(node) {
+ return node.type === 1 && node.tagType === 3;
+}
+function isSlotOutlet(node) {
+ return node.type === 1 && node.tagType === 2;
+}
+const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
+function getUnnormalizedProps(props, callPath = []) {
+ if (props && !shared.isString(props) && props.type === 14) {
+ const callee = props.callee;
+ if (!shared.isString(callee) && propsHelperSet.has(callee)) {
+ return getUnnormalizedProps(
+ props.arguments[0],
+ callPath.concat(props)
+ );
+ }
+ }
+ return [props, callPath];
+}
+function injectProp(node, prop, context) {
+ let propsWithInjection;
+ let props = node.type === 13 ? node.props : node.arguments[2];
+ let callPath = [];
+ let parentCall;
+ if (props && !shared.isString(props) && props.type === 14) {
+ const ret = getUnnormalizedProps(props);
+ props = ret[0];
+ callPath = ret[1];
+ parentCall = callPath[callPath.length - 1];
+ }
+ if (props == null || shared.isString(props)) {
+ propsWithInjection = createObjectExpression([prop]);
+ } else if (props.type === 14) {
+ const first = props.arguments[0];
+ if (!shared.isString(first) && first.type === 15) {
+ if (!hasProp(prop, first)) {
+ first.properties.unshift(prop);
+ }
+ } else {
+ if (props.callee === TO_HANDLERS) {
+ propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+ createObjectExpression([prop]),
+ props
+ ]);
+ } else {
+ props.arguments.unshift(createObjectExpression([prop]));
+ }
+ }
+ !propsWithInjection && (propsWithInjection = props);
+ } else if (props.type === 15) {
+ if (!hasProp(prop, props)) {
+ props.properties.unshift(prop);
+ }
+ propsWithInjection = props;
+ } else {
+ propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+ createObjectExpression([prop]),
+ props
+ ]);
+ if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
+ parentCall = callPath[callPath.length - 2];
+ }
+ }
+ if (node.type === 13) {
+ if (parentCall) {
+ parentCall.arguments[0] = propsWithInjection;
+ } else {
+ node.props = propsWithInjection;
+ }
+ } else {
+ if (parentCall) {
+ parentCall.arguments[0] = propsWithInjection;
+ } else {
+ node.arguments[2] = propsWithInjection;
+ }
+ }
+}
+function hasProp(prop, props) {
+ let result = false;
+ if (prop.key.type === 4) {
+ const propKeyName = prop.key.content;
+ result = props.properties.some(
+ (p) => p.key.type === 4 && p.key.content === propKeyName
+ );
+ }
+ return result;
+}
+function toValidAssetId(name, type) {
+ return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+ return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+ })}`;
+}
+function hasScopeRef(node, ids) {
+ if (!node || Object.keys(ids).length === 0) {
+ return false;
+ }
+ switch (node.type) {
+ case 1:
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
+ return true;
+ }
+ }
+ return node.children.some((c) => hasScopeRef(c, ids));
+ case 11:
+ if (hasScopeRef(node.source, ids)) {
+ return true;
+ }
+ return node.children.some((c) => hasScopeRef(c, ids));
+ case 9:
+ return node.branches.some((b) => hasScopeRef(b, ids));
+ case 10:
+ if (hasScopeRef(node.condition, ids)) {
+ return true;
+ }
+ return node.children.some((c) => hasScopeRef(c, ids));
+ case 4:
+ return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
+ case 8:
+ return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids));
+ case 5:
+ case 12:
+ return hasScopeRef(node.content, ids);
+ case 2:
+ case 3:
+ return false;
+ default:
+ return false;
+ }
+}
+function getMemoedVNodeCall(node) {
+ if (node.type === 14 && node.callee === WITH_MEMO) {
+ return node.arguments[1].returns;
+ } else {
+ return node;
+ }
+}
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+
+const deprecationData = {
+ ["COMPILER_IS_ON_ELEMENT"]: {
+ message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
+ },
+ ["COMPILER_V_BIND_SYNC"]: {
+ message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
+ },
+ ["COMPILER_V_BIND_PROP"]: {
+ message: `.prop modifier for v-bind has been removed and no longer necessary. Vue 3 will automatically set a binding as DOM property when appropriate.`
+ },
+ ["COMPILER_V_BIND_OBJECT_ORDER"]: {
+ message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
+ },
+ ["COMPILER_V_ON_NATIVE"]: {
+ message: `.native modifier for v-on has been removed as is no longer necessary.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
+ },
+ ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
+ message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
+ },
+ ["COMPILER_NATIVE_TEMPLATE"]: {
+ message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
+ },
+ ["COMPILER_INLINE_TEMPLATE"]: {
+ message: `"inline-template" has been removed in Vue 3.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
+ },
+ ["COMPILER_FILTER"]: {
+ message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
+ }
+};
+function getCompatValue(key, context) {
+ const config = context.options ? context.options.compatConfig : context.compatConfig;
+ const value = config && config[key];
+ if (key === "MODE") {
+ return value || 3;
+ } else {
+ return value;
+ }
+}
+function isCompatEnabled(key, context) {
+ const mode = getCompatValue("MODE", context);
+ const value = getCompatValue(key, context);
+ return mode === 3 ? value === true : value !== false;
+}
+function checkCompatEnabled(key, context, loc, ...args) {
+ const enabled = isCompatEnabled(key, context);
+ if (enabled) {
+ warnDeprecation(key, context, loc, ...args);
+ }
+ return enabled;
+}
+function warnDeprecation(key, context, loc, ...args) {
+ const val = getCompatValue(key, context);
+ if (val === "suppress-warning") {
+ return;
+ }
+ const { message, link } = deprecationData[key];
+ const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
+ Details: ${link}` : ``}`;
+ const err = new SyntaxError(msg);
+ err.code = key;
+ if (loc)
+ err.loc = loc;
+ context.onWarn(err);
+}
+
+const decodeRE = /&(gt|lt|amp|apos|quot);/g;
+const decodeMap = {
+ gt: ">",
+ lt: "<",
+ amp: "&",
+ apos: "'",
+ quot: '"'
+};
+const defaultParserOptions = {
+ delimiters: [`{{`, `}}`],
+ getNamespace: () => 0,
+ getTextMode: () => 0,
+ isVoidTag: shared.NO,
+ isPreTag: shared.NO,
+ isCustomElement: shared.NO,
+ decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),
+ onError: defaultOnError,
+ onWarn: defaultOnWarn,
+ comments: true
+};
+function baseParse(content, options = {}) {
+ const context = createParserContext(content, options);
+ const start = getCursor(context);
+ return createRoot(
+ parseChildren(context, 0, []),
+ getSelection(context, start)
+ );
+}
+function createParserContext(content, rawOptions) {
+ const options = shared.extend({}, defaultParserOptions);
+ let key;
+ for (key in rawOptions) {
+ options[key] = rawOptions[key] === void 0 ? defaultParserOptions[key] : rawOptions[key];
+ }
+ return {
+ options,
+ column: 1,
+ line: 1,
+ offset: 0,
+ originalSource: content,
+ source: content,
+ inPre: false,
+ inVPre: false,
+ onWarn: options.onWarn
+ };
+}
+function parseChildren(context, mode, ancestors) {
+ const parent = last(ancestors);
+ const ns = parent ? parent.ns : 0;
+ const nodes = [];
+ while (!isEnd(context, mode, ancestors)) {
+ const s = context.source;
+ let node = void 0;
+ if (mode === 0 || mode === 1) {
+ if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {
+ node = parseInterpolation(context, mode);
+ } else if (mode === 0 && s[0] === "<") {
+ if (s.length === 1) {
+ emitError(context, 5, 1);
+ } else if (s[1] === "!") {
+ if (startsWith(s, "<!--")) {
+ node = parseComment(context);
+ } else if (startsWith(s, "<!DOCTYPE")) {
+ node = parseBogusComment(context);
+ } else if (startsWith(s, "<![CDATA[")) {
+ if (ns !== 0) {
+ node = parseCDATA(context, ancestors);
+ } else {
+ emitError(context, 1);
+ node = parseBogusComment(context);
+ }
+ } else {
+ emitError(context, 11);
+ node = parseBogusComment(context);
+ }
+ } else if (s[1] === "/") {
+ if (s.length === 2) {
+ emitError(context, 5, 2);
+ } else if (s[2] === ">") {
+ emitError(context, 14, 2);
+ advanceBy(context, 3);
+ continue;
+ } else if (/[a-z]/i.test(s[2])) {
+ emitError(context, 23);
+ parseTag(context, 1 /* End */, parent);
+ continue;
+ } else {
+ emitError(
+ context,
+ 12,
+ 2
+ );
+ node = parseBogusComment(context);
+ }
+ } else if (/[a-z]/i.test(s[1])) {
+ node = parseElement(context, ancestors);
+ if (isCompatEnabled(
+ "COMPILER_NATIVE_TEMPLATE",
+ context
+ ) && node && node.tag === "template" && !node.props.some(
+ (p) => p.type === 7 && isSpecialTemplateDirective(p.name)
+ )) {
+ warnDeprecation(
+ "COMPILER_NATIVE_TEMPLATE",
+ context,
+ node.loc
+ );
+ node = node.children;
+ }
+ } else if (s[1] === "?") {
+ emitError(
+ context,
+ 21,
+ 1
+ );
+ node = parseBogusComment(context);
+ } else {
+ emitError(context, 12, 1);
+ }
+ }
+ }
+ if (!node) {
+ node = parseText(context, mode);
+ }
+ if (shared.isArray(node)) {
+ for (let i = 0; i < node.length; i++) {
+ pushNode(nodes, node[i]);
+ }
+ } else {
+ pushNode(nodes, node);
+ }
+ }
+ let removedWhitespace = false;
+ if (mode !== 2 && mode !== 1) {
+ const shouldCondense = context.options.whitespace !== "preserve";
+ for (let i = 0; i < nodes.length; i++) {
+ const node = nodes[i];
+ if (node.type === 2) {
+ if (!context.inPre) {
+ if (!/[^\t\r\n\f ]/.test(node.content)) {
+ const prev = nodes[i - 1];
+ const next = nodes[i + 1];
+ if (!prev || !next || shouldCondense && (prev.type === 3 && next.type === 3 || prev.type === 3 && next.type === 1 || prev.type === 1 && next.type === 3 || prev.type === 1 && next.type === 1 && /[\r\n]/.test(node.content))) {
+ removedWhitespace = true;
+ nodes[i] = null;
+ } else {
+ node.content = " ";
+ }
+ } else if (shouldCondense) {
+ node.content = node.content.replace(/[\t\r\n\f ]+/g, " ");
+ }
+ } else {
+ node.content = node.content.replace(/\r\n/g, "\n");
+ }
+ } else if (node.type === 3 && !context.options.comments) {
+ removedWhitespace = true;
+ nodes[i] = null;
+ }
+ }
+ if (context.inPre && parent && context.options.isPreTag(parent.tag)) {
+ const first = nodes[0];
+ if (first && first.type === 2) {
+ first.content = first.content.replace(/^\r?\n/, "");
+ }
+ }
+ }
+ return removedWhitespace ? nodes.filter(Boolean) : nodes;
+}
+function pushNode(nodes, node) {
+ if (node.type === 2) {
+ const prev = last(nodes);
+ if (prev && prev.type === 2 && prev.loc.end.offset === node.loc.start.offset) {
+ prev.content += node.content;
+ prev.loc.end = node.loc.end;
+ prev.loc.source += node.loc.source;
+ return;
+ }
+ }
+ nodes.push(node);
+}
+function parseCDATA(context, ancestors) {
+ advanceBy(context, 9);
+ const nodes = parseChildren(context, 3, ancestors);
+ if (context.source.length === 0) {
+ emitError(context, 6);
+ } else {
+ advanceBy(context, 3);
+ }
+ return nodes;
+}
+function parseComment(context) {
+ const start = getCursor(context);
+ let content;
+ const match = /--(\!)?>/.exec(context.source);
+ if (!match) {
+ content = context.source.slice(4);
+ advanceBy(context, context.source.length);
+ emitError(context, 7);
+ } else {
+ if (match.index <= 3) {
+ emitError(context, 0);
+ }
+ if (match[1]) {
+ emitError(context, 10);
+ }
+ content = context.source.slice(4, match.index);
+ const s = context.source.slice(0, match.index);
+ let prevIndex = 1, nestedIndex = 0;
+ while ((nestedIndex = s.indexOf("<!--", prevIndex)) !== -1) {
+ advanceBy(context, nestedIndex - prevIndex + 1);
+ if (nestedIndex + 4 < s.length) {
+ emitError(context, 16);
+ }
+ prevIndex = nestedIndex + 1;
+ }
+ advanceBy(context, match.index + match[0].length - prevIndex + 1);
+ }
+ return {
+ type: 3,
+ content,
+ loc: getSelection(context, start)
+ };
+}
+function parseBogusComment(context) {
+ const start = getCursor(context);
+ const contentStart = context.source[1] === "?" ? 1 : 2;
+ let content;
+ const closeIndex = context.source.indexOf(">");
+ if (closeIndex === -1) {
+ content = context.source.slice(contentStart);
+ advanceBy(context, context.source.length);
+ } else {
+ content = context.source.slice(contentStart, closeIndex);
+ advanceBy(context, closeIndex + 1);
+ }
+ return {
+ type: 3,
+ content,
+ loc: getSelection(context, start)
+ };
+}
+function parseElement(context, ancestors) {
+ const wasInPre = context.inPre;
+ const wasInVPre = context.inVPre;
+ const parent = last(ancestors);
+ const element = parseTag(context, 0 /* Start */, parent);
+ const isPreBoundary = context.inPre && !wasInPre;
+ const isVPreBoundary = context.inVPre && !wasInVPre;
+ if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
+ if (isPreBoundary) {
+ context.inPre = false;
+ }
+ if (isVPreBoundary) {
+ context.inVPre = false;
+ }
+ return element;
+ }
+ ancestors.push(element);
+ const mode = context.options.getTextMode(element, parent);
+ const children = parseChildren(context, mode, ancestors);
+ ancestors.pop();
+ {
+ const inlineTemplateProp = element.props.find(
+ (p) => p.type === 6 && p.name === "inline-template"
+ );
+ if (inlineTemplateProp && checkCompatEnabled(
+ "COMPILER_INLINE_TEMPLATE",
+ context,
+ inlineTemplateProp.loc
+ )) {
+ const loc = getSelection(context, element.loc.end);
+ inlineTemplateProp.value = {
+ type: 2,
+ content: loc.source,
+ loc
+ };
+ }
+ }
+ element.children = children;
+ if (startsWithEndTagOpen(context.source, element.tag)) {
+ parseTag(context, 1 /* End */, parent);
+ } else {
+ emitError(context, 24, 0, element.loc.start);
+ if (context.source.length === 0 && element.tag.toLowerCase() === "script") {
+ const first = children[0];
+ if (first && startsWith(first.loc.source, "<!--")) {
+ emitError(context, 8);
+ }
+ }
+ }
+ element.loc = getSelection(context, element.loc.start);
+ if (isPreBoundary) {
+ context.inPre = false;
+ }
+ if (isVPreBoundary) {
+ context.inVPre = false;
+ }
+ return element;
+}
+const isSpecialTemplateDirective = /* @__PURE__ */ shared.makeMap(
+ `if,else,else-if,for,slot`
+);
+function parseTag(context, type, parent) {
+ const start = getCursor(context);
+ const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source);
+ const tag = match[1];
+ const ns = context.options.getNamespace(tag, parent);
+ advanceBy(context, match[0].length);
+ advanceSpaces(context);
+ const cursor = getCursor(context);
+ const currentSource = context.source;
+ if (context.options.isPreTag(tag)) {
+ context.inPre = true;
+ }
+ let props = parseAttributes(context, type);
+ if (type === 0 /* Start */ && !context.inVPre && props.some((p) => p.type === 7 && p.name === "pre")) {
+ context.inVPre = true;
+ shared.extend(context, cursor);
+ context.source = currentSource;
+ props = parseAttributes(context, type).filter((p) => p.name !== "v-pre");
+ }
+ let isSelfClosing = false;
+ if (context.source.length === 0) {
+ emitError(context, 9);
+ } else {
+ isSelfClosing = startsWith(context.source, "/>");
+ if (type === 1 /* End */ && isSelfClosing) {
+ emitError(context, 4);
+ }
+ advanceBy(context, isSelfClosing ? 2 : 1);
+ }
+ if (type === 1 /* End */) {
+ return;
+ }
+ if (isCompatEnabled(
+ "COMPILER_V_IF_V_FOR_PRECEDENCE",
+ context
+ )) {
+ let hasIf = false;
+ let hasFor = false;
+ for (let i = 0; i < props.length; i++) {
+ const p = props[i];
+ if (p.type === 7) {
+ if (p.name === "if") {
+ hasIf = true;
+ } else if (p.name === "for") {
+ hasFor = true;
+ }
+ }
+ if (hasIf && hasFor) {
+ warnDeprecation(
+ "COMPILER_V_IF_V_FOR_PRECEDENCE",
+ context,
+ getSelection(context, start)
+ );
+ break;
+ }
+ }
+ }
+ let tagType = 0;
+ if (!context.inVPre) {
+ if (tag === "slot") {
+ tagType = 2;
+ } else if (tag === "template") {
+ if (props.some(
+ (p) => p.type === 7 && isSpecialTemplateDirective(p.name)
+ )) {
+ tagType = 3;
+ }
+ } else if (isComponent(tag, props, context)) {
+ tagType = 1;
+ }
+ }
+ return {
+ type: 1,
+ ns,
+ tag,
+ tagType,
+ props,
+ isSelfClosing,
+ children: [],
+ loc: getSelection(context, start),
+ codegenNode: void 0
+ // to be created during transform phase
+ };
+}
+function isComponent(tag, props, context) {
+ const options = context.options;
+ if (options.isCustomElement(tag)) {
+ return false;
+ }
+ if (tag === "component" || /^[A-Z]/.test(tag) || isCoreComponent(tag) || options.isBuiltInComponent && options.isBuiltInComponent(tag) || options.isNativeTag && !options.isNativeTag(tag)) {
+ return true;
+ }
+ for (let i = 0; i < props.length; i++) {
+ const p = props[i];
+ if (p.type === 6) {
+ if (p.name === "is" && p.value) {
+ if (p.value.content.startsWith("vue:")) {
+ return true;
+ } else if (checkCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context,
+ p.loc
+ )) {
+ return true;
+ }
+ }
+ } else {
+ if (p.name === "is") {
+ return true;
+ } else if (
+ // :is on plain element - only treat as component in compat mode
+ p.name === "bind" && isStaticArgOf(p.arg, "is") && true && checkCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context,
+ p.loc
+ )
+ ) {
+ return true;
+ }
+ }
+ }
+}
+function parseAttributes(context, type) {
+ const props = [];
+ const attributeNames = /* @__PURE__ */ new Set();
+ while (context.source.length > 0 && !startsWith(context.source, ">") && !startsWith(context.source, "/>")) {
+ if (startsWith(context.source, "/")) {
+ emitError(context, 22);
+ advanceBy(context, 1);
+ advanceSpaces(context);
+ continue;
+ }
+ if (type === 1 /* End */) {
+ emitError(context, 3);
+ }
+ const attr = parseAttribute(context, attributeNames);
+ if (attr.type === 6 && attr.value && attr.name === "class") {
+ attr.value.content = attr.value.content.replace(/\s+/g, " ").trim();
+ }
+ if (type === 0 /* Start */) {
+ props.push(attr);
+ }
+ if (/^[^\t\r\n\f />]/.test(context.source)) {
+ emitError(context, 15);
+ }
+ advanceSpaces(context);
+ }
+ return props;
+}
+function parseAttribute(context, nameSet) {
+ var _a;
+ const start = getCursor(context);
+ const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source);
+ const name = match[0];
+ if (nameSet.has(name)) {
+ emitError(context, 2);
+ }
+ nameSet.add(name);
+ if (name[0] === "=") {
+ emitError(context, 19);
+ }
+ {
+ const pattern = /["'<]/g;
+ let m;
+ while (m = pattern.exec(name)) {
+ emitError(
+ context,
+ 17,
+ m.index
+ );
+ }
+ }
+ advanceBy(context, name.length);
+ let value = void 0;
+ if (/^[\t\r\n\f ]*=/.test(context.source)) {
+ advanceSpaces(context);
+ advanceBy(context, 1);
+ advanceSpaces(context);
+ value = parseAttributeValue(context);
+ if (!value) {
+ emitError(context, 13);
+ }
+ }
+ const loc = getSelection(context, start);
+ if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(name)) {
+ const match2 = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(
+ name
+ );
+ let isPropShorthand = startsWith(name, ".");
+ let dirName = match2[1] || (isPropShorthand || startsWith(name, ":") ? "bind" : startsWith(name, "@") ? "on" : "slot");
+ let arg;
+ if (match2[2]) {
+ const isSlot = dirName === "slot";
+ const startOffset = name.lastIndexOf(
+ match2[2],
+ name.length - (((_a = match2[3]) == null ? void 0 : _a.length) || 0)
+ );
+ const loc2 = getSelection(
+ context,
+ getNewPosition(context, start, startOffset),
+ getNewPosition(
+ context,
+ start,
+ startOffset + match2[2].length + (isSlot && match2[3] || "").length
+ )
+ );
+ let content = match2[2];
+ let isStatic = true;
+ if (content.startsWith("[")) {
+ isStatic = false;
+ if (!content.endsWith("]")) {
+ emitError(
+ context,
+ 27
+ );
+ content = content.slice(1);
+ } else {
+ content = content.slice(1, content.length - 1);
+ }
+ } else if (isSlot) {
+ content += match2[3] || "";
+ }
+ arg = {
+ type: 4,
+ content,
+ isStatic,
+ constType: isStatic ? 3 : 0,
+ loc: loc2
+ };
+ }
+ if (value && value.isQuoted) {
+ const valueLoc = value.loc;
+ valueLoc.start.offset++;
+ valueLoc.start.column++;
+ valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);
+ valueLoc.source = valueLoc.source.slice(1, -1);
+ }
+ const modifiers = match2[3] ? match2[3].slice(1).split(".") : [];
+ if (isPropShorthand)
+ modifiers.push("prop");
+ if (dirName === "bind" && arg) {
+ if (modifiers.includes("sync") && checkCompatEnabled(
+ "COMPILER_V_BIND_SYNC",
+ context,
+ loc,
+ arg.loc.source
+ )) {
+ dirName = "model";
+ modifiers.splice(modifiers.indexOf("sync"), 1);
+ }
+ if (modifiers.includes("prop")) {
+ checkCompatEnabled(
+ "COMPILER_V_BIND_PROP",
+ context,
+ loc
+ );
+ }
+ }
+ return {
+ type: 7,
+ name: dirName,
+ exp: value && {
+ type: 4,
+ content: value.content,
+ isStatic: false,
+ // Treat as non-constant by default. This can be potentially set to
+ // other values by `transformExpression` to make it eligible for hoisting.
+ constType: 0,
+ loc: value.loc
+ },
+ arg,
+ modifiers,
+ loc
+ };
+ }
+ if (!context.inVPre && startsWith(name, "v-")) {
+ emitError(context, 26);
+ }
+ return {
+ type: 6,
+ name,
+ value: value && {
+ type: 2,
+ content: value.content,
+ loc: value.loc
+ },
+ loc
+ };
+}
+function parseAttributeValue(context) {
+ const start = getCursor(context);
+ let content;
+ const quote = context.source[0];
+ const isQuoted = quote === `"` || quote === `'`;
+ if (isQuoted) {
+ advanceBy(context, 1);
+ const endIndex = context.source.indexOf(quote);
+ if (endIndex === -1) {
+ content = parseTextData(
+ context,
+ context.source.length,
+ 4
+ );
+ } else {
+ content = parseTextData(context, endIndex, 4);
+ advanceBy(context, 1);
+ }
+ } else {
+ const match = /^[^\t\r\n\f >]+/.exec(context.source);
+ if (!match) {
+ return void 0;
+ }
+ const unexpectedChars = /["'<=`]/g;
+ let m;
+ while (m = unexpectedChars.exec(match[0])) {
+ emitError(
+ context,
+ 18,
+ m.index
+ );
+ }
+ content = parseTextData(context, match[0].length, 4);
+ }
+ return { content, isQuoted, loc: getSelection(context, start) };
+}
+function parseInterpolation(context, mode) {
+ const [open, close] = context.options.delimiters;
+ const closeIndex = context.source.indexOf(close, open.length);
+ if (closeIndex === -1) {
+ emitError(context, 25);
+ return void 0;
+ }
+ const start = getCursor(context);
+ advanceBy(context, open.length);
+ const innerStart = getCursor(context);
+ const innerEnd = getCursor(context);
+ const rawContentLength = closeIndex - open.length;
+ const rawContent = context.source.slice(0, rawContentLength);
+ const preTrimContent = parseTextData(context, rawContentLength, mode);
+ const content = preTrimContent.trim();
+ const startOffset = preTrimContent.indexOf(content);
+ if (startOffset > 0) {
+ advancePositionWithMutation(innerStart, rawContent, startOffset);
+ }
+ const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);
+ advancePositionWithMutation(innerEnd, rawContent, endOffset);
+ advanceBy(context, close.length);
+ return {
+ type: 5,
+ content: {
+ type: 4,
+ isStatic: false,
+ // Set `isConstant` to false by default and will decide in transformExpression
+ constType: 0,
+ content,
+ loc: getSelection(context, innerStart, innerEnd)
+ },
+ loc: getSelection(context, start)
+ };
+}
+function parseText(context, mode) {
+ const endTokens = mode === 3 ? ["]]>"] : ["<", context.options.delimiters[0]];
+ let endIndex = context.source.length;
+ for (let i = 0; i < endTokens.length; i++) {
+ const index = context.source.indexOf(endTokens[i], 1);
+ if (index !== -1 && endIndex > index) {
+ endIndex = index;
+ }
+ }
+ const start = getCursor(context);
+ const content = parseTextData(context, endIndex, mode);
+ return {
+ type: 2,
+ content,
+ loc: getSelection(context, start)
+ };
+}
+function parseTextData(context, length, mode) {
+ const rawText = context.source.slice(0, length);
+ advanceBy(context, length);
+ if (mode === 2 || mode === 3 || !rawText.includes("&")) {
+ return rawText;
+ } else {
+ return context.options.decodeEntities(
+ rawText,
+ mode === 4
+ );
+ }
+}
+function getCursor(context) {
+ const { column, line, offset } = context;
+ return { column, line, offset };
+}
+function getSelection(context, start, end) {
+ end = end || getCursor(context);
+ return {
+ start,
+ end,
+ source: context.originalSource.slice(start.offset, end.offset)
+ };
+}
+function last(xs) {
+ return xs[xs.length - 1];
+}
+function startsWith(source, searchString) {
+ return source.startsWith(searchString);
+}
+function advanceBy(context, numberOfCharacters) {
+ const { source } = context;
+ advancePositionWithMutation(context, source, numberOfCharacters);
+ context.source = source.slice(numberOfCharacters);
+}
+function advanceSpaces(context) {
+ const match = /^[\t\r\n\f ]+/.exec(context.source);
+ if (match) {
+ advanceBy(context, match[0].length);
+ }
+}
+function getNewPosition(context, start, numberOfCharacters) {
+ return advancePositionWithClone(
+ start,
+ context.originalSource.slice(start.offset, numberOfCharacters),
+ numberOfCharacters
+ );
+}
+function emitError(context, code, offset, loc = getCursor(context)) {
+ if (offset) {
+ loc.offset += offset;
+ loc.column += offset;
+ }
+ context.options.onError(
+ createCompilerError(code, {
+ start: loc,
+ end: loc,
+ source: ""
+ })
+ );
+}
+function isEnd(context, mode, ancestors) {
+ const s = context.source;
+ switch (mode) {
+ case 0:
+ if (startsWith(s, "</")) {
+ for (let i = ancestors.length - 1; i >= 0; --i) {
+ if (startsWithEndTagOpen(s, ancestors[i].tag)) {
+ return true;
+ }
+ }
+ }
+ break;
+ case 1:
+ case 2: {
+ const parent = last(ancestors);
+ if (parent && startsWithEndTagOpen(s, parent.tag)) {
+ return true;
+ }
+ break;
+ }
+ case 3:
+ if (startsWith(s, "]]>")) {
+ return true;
+ }
+ break;
+ }
+ return !s;
+}
+function startsWithEndTagOpen(source, tag) {
+ return startsWith(source, "</") && source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() && /[\t\r\n\f />]/.test(source[2 + tag.length] || ">");
+}
+
+function hoistStatic(root, context) {
+ walk(
+ root,
+ context,
+ // Root node is unfortunately non-hoistable due to potential parent
+ // fallthrough attributes.
+ isSingleElementRoot(root, root.children[0])
+ );
+}
+function isSingleElementRoot(root, child) {
+ const { children } = root;
+ return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
+}
+function walk(node, context, doNotHoistNode = false) {
+ const { children } = node;
+ const originalCount = children.length;
+ let hoistedCount = 0;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (child.type === 1 && child.tagType === 0) {
+ const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
+ if (constantType > 0) {
+ if (constantType >= 2) {
+ child.codegenNode.patchFlag = -1 + (` /* HOISTED */` );
+ child.codegenNode = context.hoist(child.codegenNode);
+ hoistedCount++;
+ continue;
+ }
+ } else {
+ const codegenNode = child.codegenNode;
+ if (codegenNode.type === 13) {
+ const flag = getPatchFlag(codegenNode);
+ if ((!flag || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
+ const props = getNodeProps(child);
+ if (props) {
+ codegenNode.props = context.hoist(props);
+ }
+ }
+ if (codegenNode.dynamicProps) {
+ codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
+ }
+ }
+ }
+ }
+ if (child.type === 1) {
+ const isComponent = child.tagType === 1;
+ if (isComponent) {
+ context.scopes.vSlot++;
+ }
+ walk(child, context);
+ if (isComponent) {
+ context.scopes.vSlot--;
+ }
+ } else if (child.type === 11) {
+ walk(child, context, child.children.length === 1);
+ } else if (child.type === 9) {
+ for (let i2 = 0; i2 < child.branches.length; i2++) {
+ walk(
+ child.branches[i2],
+ context,
+ child.branches[i2].children.length === 1
+ );
+ }
+ }
+ }
+ if (hoistedCount && context.transformHoist) {
+ context.transformHoist(children, context, node);
+ }
+ if (hoistedCount && hoistedCount === originalCount && node.type === 1 && node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) {
+ const hoisted = context.hoist(
+ createArrayExpression(node.codegenNode.children)
+ );
+ if (context.hmr) {
+ hoisted.content = `[...${hoisted.content}]`;
+ }
+ node.codegenNode.children = hoisted;
+ }
+}
+function getConstantType(node, context) {
+ const { constantCache } = context;
+ switch (node.type) {
+ case 1:
+ if (node.tagType !== 0) {
+ return 0;
+ }
+ const cached = constantCache.get(node);
+ if (cached !== void 0) {
+ return cached;
+ }
+ const codegenNode = node.codegenNode;
+ if (codegenNode.type !== 13) {
+ return 0;
+ }
+ if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject") {
+ return 0;
+ }
+ const flag = getPatchFlag(codegenNode);
+ if (!flag) {
+ let returnType2 = 3;
+ const generatedPropsType = getGeneratedPropsConstantType(node, context);
+ if (generatedPropsType === 0) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ if (generatedPropsType < returnType2) {
+ returnType2 = generatedPropsType;
+ }
+ for (let i = 0; i < node.children.length; i++) {
+ const childType = getConstantType(node.children[i], context);
+ if (childType === 0) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ if (childType < returnType2) {
+ returnType2 = childType;
+ }
+ }
+ if (returnType2 > 1) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7 && p.name === "bind" && p.exp) {
+ const expType = getConstantType(p.exp, context);
+ if (expType === 0) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ if (expType < returnType2) {
+ returnType2 = expType;
+ }
+ }
+ }
+ }
+ if (codegenNode.isBlock) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ }
+ context.removeHelper(OPEN_BLOCK);
+ context.removeHelper(
+ getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
+ );
+ codegenNode.isBlock = false;
+ context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
+ }
+ constantCache.set(node, returnType2);
+ return returnType2;
+ } else {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ case 2:
+ case 3:
+ return 3;
+ case 9:
+ case 11:
+ case 10:
+ return 0;
+ case 5:
+ case 12:
+ return getConstantType(node.content, context);
+ case 4:
+ return node.constType;
+ case 8:
+ let returnType = 3;
+ for (let i = 0; i < node.children.length; i++) {
+ const child = node.children[i];
+ if (shared.isString(child) || shared.isSymbol(child)) {
+ continue;
+ }
+ const childType = getConstantType(child, context);
+ if (childType === 0) {
+ return 0;
+ } else if (childType < returnType) {
+ returnType = childType;
+ }
+ }
+ return returnType;
+ default:
+ return 0;
+ }
+}
+const allowHoistedHelperSet = /* @__PURE__ */ new Set([
+ NORMALIZE_CLASS,
+ NORMALIZE_STYLE,
+ NORMALIZE_PROPS,
+ GUARD_REACTIVE_PROPS
+]);
+function getConstantTypeOfHelperCall(value, context) {
+ if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
+ const arg = value.arguments[0];
+ if (arg.type === 4) {
+ return getConstantType(arg, context);
+ } else if (arg.type === 14) {
+ return getConstantTypeOfHelperCall(arg, context);
+ }
+ }
+ return 0;
+}
+function getGeneratedPropsConstantType(node, context) {
+ let returnType = 3;
+ const props = getNodeProps(node);
+ if (props && props.type === 15) {
+ const { properties } = props;
+ for (let i = 0; i < properties.length; i++) {
+ const { key, value } = properties[i];
+ const keyType = getConstantType(key, context);
+ if (keyType === 0) {
+ return keyType;
+ }
+ if (keyType < returnType) {
+ returnType = keyType;
+ }
+ let valueType;
+ if (value.type === 4) {
+ valueType = getConstantType(value, context);
+ } else if (value.type === 14) {
+ valueType = getConstantTypeOfHelperCall(value, context);
+ } else {
+ valueType = 0;
+ }
+ if (valueType === 0) {
+ return valueType;
+ }
+ if (valueType < returnType) {
+ returnType = valueType;
+ }
+ }
+ }
+ return returnType;
+}
+function getNodeProps(node) {
+ const codegenNode = node.codegenNode;
+ if (codegenNode.type === 13) {
+ return codegenNode.props;
+ }
+}
+function getPatchFlag(node) {
+ const flag = node.patchFlag;
+ return flag ? parseInt(flag, 10) : void 0;
+}
+
+function createTransformContext(root, {
+ filename = "",
+ prefixIdentifiers = false,
+ hoistStatic: hoistStatic2 = false,
+ hmr = false,
+ cacheHandlers = false,
+ nodeTransforms = [],
+ directiveTransforms = {},
+ transformHoist = null,
+ isBuiltInComponent = shared.NOOP,
+ isCustomElement = shared.NOOP,
+ expressionPlugins = [],
+ scopeId = null,
+ slotted = true,
+ ssr = false,
+ inSSR = false,
+ ssrCssVars = ``,
+ bindingMetadata = shared.EMPTY_OBJ,
+ inline = false,
+ isTS = false,
+ onError = defaultOnError,
+ onWarn = defaultOnWarn,
+ compatConfig
+}) {
+ const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
+ const context = {
+ // options
+ selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])),
+ prefixIdentifiers,
+ hoistStatic: hoistStatic2,
+ hmr,
+ cacheHandlers,
+ nodeTransforms,
+ directiveTransforms,
+ transformHoist,
+ isBuiltInComponent,
+ isCustomElement,
+ expressionPlugins,
+ scopeId,
+ slotted,
+ ssr,
+ inSSR,
+ ssrCssVars,
+ bindingMetadata,
+ inline,
+ isTS,
+ onError,
+ onWarn,
+ compatConfig,
+ // state
+ root,
+ helpers: /* @__PURE__ */ new Map(),
+ components: /* @__PURE__ */ new Set(),
+ directives: /* @__PURE__ */ new Set(),
+ hoists: [],
+ imports: [],
+ constantCache: /* @__PURE__ */ new WeakMap(),
+ temps: 0,
+ cached: 0,
+ identifiers: /* @__PURE__ */ Object.create(null),
+ scopes: {
+ vFor: 0,
+ vSlot: 0,
+ vPre: 0,
+ vOnce: 0
+ },
+ parent: null,
+ currentNode: root,
+ childIndex: 0,
+ inVOnce: false,
+ // methods
+ helper(name) {
+ const count = context.helpers.get(name) || 0;
+ context.helpers.set(name, count + 1);
+ return name;
+ },
+ removeHelper(name) {
+ const count = context.helpers.get(name);
+ if (count) {
+ const currentCount = count - 1;
+ if (!currentCount) {
+ context.helpers.delete(name);
+ } else {
+ context.helpers.set(name, currentCount);
+ }
+ }
+ },
+ helperString(name) {
+ return `_${helperNameMap[context.helper(name)]}`;
+ },
+ replaceNode(node) {
+ {
+ if (!context.currentNode) {
+ throw new Error(`Node being replaced is already removed.`);
+ }
+ if (!context.parent) {
+ throw new Error(`Cannot replace root node.`);
+ }
+ }
+ context.parent.children[context.childIndex] = context.currentNode = node;
+ },
+ removeNode(node) {
+ if (!context.parent) {
+ throw new Error(`Cannot remove root node.`);
+ }
+ const list = context.parent.children;
+ const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
+ if (removalIndex < 0) {
+ throw new Error(`node being removed is not a child of current parent`);
+ }
+ if (!node || node === context.currentNode) {
+ context.currentNode = null;
+ context.onNodeRemoved();
+ } else {
+ if (context.childIndex > removalIndex) {
+ context.childIndex--;
+ context.onNodeRemoved();
+ }
+ }
+ context.parent.children.splice(removalIndex, 1);
+ },
+ onNodeRemoved: () => {
+ },
+ addIdentifiers(exp) {
+ {
+ if (shared.isString(exp)) {
+ addId(exp);
+ } else if (exp.identifiers) {
+ exp.identifiers.forEach(addId);
+ } else if (exp.type === 4) {
+ addId(exp.content);
+ }
+ }
+ },
+ removeIdentifiers(exp) {
+ {
+ if (shared.isString(exp)) {
+ removeId(exp);
+ } else if (exp.identifiers) {
+ exp.identifiers.forEach(removeId);
+ } else if (exp.type === 4) {
+ removeId(exp.content);
+ }
+ }
+ },
+ hoist(exp) {
+ if (shared.isString(exp))
+ exp = createSimpleExpression(exp);
+ context.hoists.push(exp);
+ const identifier = createSimpleExpression(
+ `_hoisted_${context.hoists.length}`,
+ false,
+ exp.loc,
+ 2
+ );
+ identifier.hoisted = exp;
+ return identifier;
+ },
+ cache(exp, isVNode = false) {
+ return createCacheExpression(context.cached++, exp, isVNode);
+ }
+ };
+ {
+ context.filters = /* @__PURE__ */ new Set();
+ }
+ function addId(id) {
+ const { identifiers } = context;
+ if (identifiers[id] === void 0) {
+ identifiers[id] = 0;
+ }
+ identifiers[id]++;
+ }
+ function removeId(id) {
+ context.identifiers[id]--;
+ }
+ return context;
+}
+function transform(root, options) {
+ const context = createTransformContext(root, options);
+ traverseNode(root, context);
+ if (options.hoistStatic) {
+ hoistStatic(root, context);
+ }
+ if (!options.ssr) {
+ createRootCodegen(root, context);
+ }
+ root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
+ root.components = [...context.components];
+ root.directives = [...context.directives];
+ root.imports = context.imports;
+ root.hoists = context.hoists;
+ root.temps = context.temps;
+ root.cached = context.cached;
+ {
+ root.filters = [...context.filters];
+ }
+}
+function createRootCodegen(root, context) {
+ const { helper } = context;
+ const { children } = root;
+ if (children.length === 1) {
+ const child = children[0];
+ if (isSingleElementRoot(root, child) && child.codegenNode) {
+ const codegenNode = child.codegenNode;
+ if (codegenNode.type === 13) {
+ convertToBlock(codegenNode, context);
+ }
+ root.codegenNode = codegenNode;
+ } else {
+ root.codegenNode = child;
+ }
+ } else if (children.length > 1) {
+ let patchFlag = 64;
+ let patchFlagText = shared.PatchFlagNames[64];
+ if (children.filter((c) => c.type !== 3).length === 1) {
+ patchFlag |= 2048;
+ patchFlagText += `, ${shared.PatchFlagNames[2048]}`;
+ }
+ root.codegenNode = createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ void 0,
+ root.children,
+ patchFlag + (` /* ${patchFlagText} */` ),
+ void 0,
+ void 0,
+ true,
+ void 0,
+ false
+ /* isComponent */
+ );
+ } else ;
+}
+function traverseChildren(parent, context) {
+ let i = 0;
+ const nodeRemoved = () => {
+ i--;
+ };
+ for (; i < parent.children.length; i++) {
+ const child = parent.children[i];
+ if (shared.isString(child))
+ continue;
+ context.parent = parent;
+ context.childIndex = i;
+ context.onNodeRemoved = nodeRemoved;
+ traverseNode(child, context);
+ }
+}
+function traverseNode(node, context) {
+ context.currentNode = node;
+ const { nodeTransforms } = context;
+ const exitFns = [];
+ for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
+ const onExit = nodeTransforms[i2](node, context);
+ if (onExit) {
+ if (shared.isArray(onExit)) {
+ exitFns.push(...onExit);
+ } else {
+ exitFns.push(onExit);
+ }
+ }
+ if (!context.currentNode) {
+ return;
+ } else {
+ node = context.currentNode;
+ }
+ }
+ switch (node.type) {
+ case 3:
+ if (!context.ssr) {
+ context.helper(CREATE_COMMENT);
+ }
+ break;
+ case 5:
+ if (!context.ssr) {
+ context.helper(TO_DISPLAY_STRING);
+ }
+ break;
+ case 9:
+ for (let i2 = 0; i2 < node.branches.length; i2++) {
+ traverseNode(node.branches[i2], context);
+ }
+ break;
+ case 10:
+ case 11:
+ case 1:
+ case 0:
+ traverseChildren(node, context);
+ break;
+ }
+ context.currentNode = node;
+ let i = exitFns.length;
+ while (i--) {
+ exitFns[i]();
+ }
+}
+function createStructuralDirectiveTransform(name, fn) {
+ const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n);
+ return (node, context) => {
+ if (node.type === 1) {
+ const { props } = node;
+ if (node.tagType === 3 && props.some(isVSlot)) {
+ return;
+ }
+ const exitFns = [];
+ for (let i = 0; i < props.length; i++) {
+ const prop = props[i];
+ if (prop.type === 7 && matches(prop.name)) {
+ props.splice(i, 1);
+ i--;
+ const onExit = fn(node, prop, context);
+ if (onExit)
+ exitFns.push(onExit);
+ }
+ }
+ return exitFns;
+ }
+ };
+}
+
+const PURE_ANNOTATION = `/*#__PURE__*/`;
+const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
+function createCodegenContext(ast, {
+ mode = "function",
+ prefixIdentifiers = mode === "module",
+ sourceMap = false,
+ filename = `template.vue.html`,
+ scopeId = null,
+ optimizeImports = false,
+ runtimeGlobalName = `Vue`,
+ runtimeModuleName = `vue`,
+ ssrRuntimeModuleName = "vue/server-renderer",
+ ssr = false,
+ isTS = false,
+ inSSR = false
+}) {
+ const context = {
+ mode,
+ prefixIdentifiers,
+ sourceMap,
+ filename,
+ scopeId,
+ optimizeImports,
+ runtimeGlobalName,
+ runtimeModuleName,
+ ssrRuntimeModuleName,
+ ssr,
+ isTS,
+ inSSR,
+ source: ast.loc.source,
+ code: ``,
+ column: 1,
+ line: 1,
+ offset: 0,
+ indentLevel: 0,
+ pure: false,
+ map: void 0,
+ helper(key) {
+ return `_${helperNameMap[key]}`;
+ },
+ push(code, node) {
+ context.code += code;
+ if (context.map) {
+ if (node) {
+ let name;
+ if (node.type === 4 && !node.isStatic) {
+ const content = node.content.replace(/^_ctx\./, "");
+ if (content !== node.content && isSimpleIdentifier(content)) {
+ name = content;
+ }
+ }
+ addMapping(node.loc.start, name);
+ }
+ advancePositionWithMutation(context, code);
+ if (node && node.loc !== locStub) {
+ addMapping(node.loc.end);
+ }
+ }
+ },
+ indent() {
+ newline(++context.indentLevel);
+ },
+ deindent(withoutNewLine = false) {
+ if (withoutNewLine) {
+ --context.indentLevel;
+ } else {
+ newline(--context.indentLevel);
+ }
+ },
+ newline() {
+ newline(context.indentLevel);
+ }
+ };
+ function newline(n) {
+ context.push("\n" + ` `.repeat(n));
+ }
+ function addMapping(loc, name) {
+ context.map.addMapping({
+ name,
+ source: context.filename,
+ original: {
+ line: loc.line,
+ column: loc.column - 1
+ // source-map column is 0 based
+ },
+ generated: {
+ line: context.line,
+ column: context.column - 1
+ }
+ });
+ }
+ if (sourceMap) {
+ context.map = new sourceMapJs.SourceMapGenerator();
+ context.map.setSourceContent(filename, context.source);
+ }
+ return context;
+}
+function generate(ast, options = {}) {
+ const context = createCodegenContext(ast, options);
+ if (options.onContextCreated)
+ options.onContextCreated(context);
+ const {
+ mode,
+ push,
+ prefixIdentifiers,
+ indent,
+ deindent,
+ newline,
+ scopeId,
+ ssr
+ } = context;
+ const helpers = Array.from(ast.helpers);
+ const hasHelpers = helpers.length > 0;
+ const useWithBlock = !prefixIdentifiers && mode !== "module";
+ const genScopeId = scopeId != null && mode === "module";
+ const isSetupInlined = !!options.inline;
+ const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;
+ if (mode === "module") {
+ genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);
+ } else {
+ genFunctionPreamble(ast, preambleContext);
+ }
+ const functionName = ssr ? `ssrRender` : `render`;
+ const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
+ if (options.bindingMetadata && !options.inline) {
+ args.push("$props", "$setup", "$data", "$options");
+ }
+ const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", ");
+ if (isSetupInlined) {
+ push(`(${signature}) => {`);
+ } else {
+ push(`function ${functionName}(${signature}) {`);
+ }
+ indent();
+ if (useWithBlock) {
+ push(`with (_ctx) {`);
+ indent();
+ if (hasHelpers) {
+ push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue`);
+ push(`
+`);
+ newline();
+ }
+ }
+ if (ast.components.length) {
+ genAssets(ast.components, "component", context);
+ if (ast.directives.length || ast.temps > 0) {
+ newline();
+ }
+ }
+ if (ast.directives.length) {
+ genAssets(ast.directives, "directive", context);
+ if (ast.temps > 0) {
+ newline();
+ }
+ }
+ if (ast.filters && ast.filters.length) {
+ newline();
+ genAssets(ast.filters, "filter", context);
+ newline();
+ }
+ if (ast.temps > 0) {
+ push(`let `);
+ for (let i = 0; i < ast.temps; i++) {
+ push(`${i > 0 ? `, ` : ``}_temp${i}`);
+ }
+ }
+ if (ast.components.length || ast.directives.length || ast.temps) {
+ push(`
+`);
+ newline();
+ }
+ if (!ssr) {
+ push(`return `);
+ }
+ if (ast.codegenNode) {
+ genNode(ast.codegenNode, context);
+ } else {
+ push(`null`);
+ }
+ if (useWithBlock) {
+ deindent();
+ push(`}`);
+ }
+ deindent();
+ push(`}`);
+ return {
+ ast,
+ code: context.code,
+ preamble: isSetupInlined ? preambleContext.code : ``,
+ // SourceMapGenerator does have toJSON() method but it's not in the types
+ map: context.map ? context.map.toJSON() : void 0
+ };
+}
+function genFunctionPreamble(ast, context) {
+ const {
+ ssr,
+ prefixIdentifiers,
+ push,
+ newline,
+ runtimeModuleName,
+ runtimeGlobalName,
+ ssrRuntimeModuleName
+ } = context;
+ const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;
+ const helpers = Array.from(ast.helpers);
+ if (helpers.length > 0) {
+ if (prefixIdentifiers) {
+ push(`const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding}
+`);
+ } else {
+ push(`const _Vue = ${VueBinding}
+`);
+ if (ast.hoists.length) {
+ const staticHelpers = [
+ CREATE_VNODE,
+ CREATE_ELEMENT_VNODE,
+ CREATE_COMMENT,
+ CREATE_TEXT,
+ CREATE_STATIC
+ ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
+ push(`const { ${staticHelpers} } = _Vue
+`);
+ }
+ }
+ }
+ if (ast.ssrHelpers && ast.ssrHelpers.length) {
+ push(
+ `const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}")
+`
+ );
+ }
+ genHoists(ast.hoists, context);
+ newline();
+ push(`return `);
+}
+function genModulePreamble(ast, context, genScopeId, inline) {
+ const {
+ push,
+ newline,
+ optimizeImports,
+ runtimeModuleName,
+ ssrRuntimeModuleName
+ } = context;
+ if (genScopeId && ast.hoists.length) {
+ ast.helpers.add(PUSH_SCOPE_ID);
+ ast.helpers.add(POP_SCOPE_ID);
+ }
+ if (ast.helpers.size) {
+ const helpers = Array.from(ast.helpers);
+ if (optimizeImports) {
+ push(
+ `import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
+`
+ );
+ push(
+ `
+// Binding optimization for webpack code-split
+const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")}
+`
+ );
+ } else {
+ push(
+ `import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
+`
+ );
+ }
+ }
+ if (ast.ssrHelpers && ast.ssrHelpers.length) {
+ push(
+ `import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}"
+`
+ );
+ }
+ if (ast.imports.length) {
+ genImports(ast.imports, context);
+ newline();
+ }
+ genHoists(ast.hoists, context);
+ newline();
+ if (!inline) {
+ push(`export `);
+ }
+}
+function genAssets(assets, type, { helper, push, newline, isTS }) {
+ const resolver = helper(
+ type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
+ );
+ for (let i = 0; i < assets.length; i++) {
+ let id = assets[i];
+ const maybeSelfReference = id.endsWith("__self");
+ if (maybeSelfReference) {
+ id = id.slice(0, -6);
+ }
+ push(
+ `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
+ );
+ if (i < assets.length - 1) {
+ newline();
+ }
+ }
+}
+function genHoists(hoists, context) {
+ if (!hoists.length) {
+ return;
+ }
+ context.pure = true;
+ const { push, newline, helper, scopeId, mode } = context;
+ const genScopeId = scopeId != null && mode !== "function";
+ newline();
+ if (genScopeId) {
+ push(
+ `const _withScopeId = n => (${helper(
+ PUSH_SCOPE_ID
+ )}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`
+ );
+ newline();
+ }
+ for (let i = 0; i < hoists.length; i++) {
+ const exp = hoists[i];
+ if (exp) {
+ const needScopeIdWrapper = genScopeId && exp.type === 13;
+ push(
+ `const _hoisted_${i + 1} = ${needScopeIdWrapper ? `${PURE_ANNOTATION} _withScopeId(() => ` : ``}`
+ );
+ genNode(exp, context);
+ if (needScopeIdWrapper) {
+ push(`)`);
+ }
+ newline();
+ }
+ }
+ context.pure = false;
+}
+function genImports(importsOptions, context) {
+ if (!importsOptions.length) {
+ return;
+ }
+ importsOptions.forEach((imports) => {
+ context.push(`import `);
+ genNode(imports.exp, context);
+ context.push(` from '${imports.path}'`);
+ context.newline();
+ });
+}
+function isText(n) {
+ return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
+}
+function genNodeListAsArray(nodes, context) {
+ const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n));
+ context.push(`[`);
+ multilines && context.indent();
+ genNodeList(nodes, context, multilines);
+ multilines && context.deindent();
+ context.push(`]`);
+}
+function genNodeList(nodes, context, multilines = false, comma = true) {
+ const { push, newline } = context;
+ for (let i = 0; i < nodes.length; i++) {
+ const node = nodes[i];
+ if (shared.isString(node)) {
+ push(node);
+ } else if (shared.isArray(node)) {
+ genNodeListAsArray(node, context);
+ } else {
+ genNode(node, context);
+ }
+ if (i < nodes.length - 1) {
+ if (multilines) {
+ comma && push(",");
+ newline();
+ } else {
+ comma && push(", ");
+ }
+ }
+ }
+}
+function genNode(node, context) {
+ if (shared.isString(node)) {
+ context.push(node);
+ return;
+ }
+ if (shared.isSymbol(node)) {
+ context.push(context.helper(node));
+ return;
+ }
+ switch (node.type) {
+ case 1:
+ case 9:
+ case 11:
+ assert(
+ node.codegenNode != null,
+ `Codegen node is missing for element/if/for node. Apply appropriate transforms first.`
+ );
+ genNode(node.codegenNode, context);
+ break;
+ case 2:
+ genText(node, context);
+ break;
+ case 4:
+ genExpression(node, context);
+ break;
+ case 5:
+ genInterpolation(node, context);
+ break;
+ case 12:
+ genNode(node.codegenNode, context);
+ break;
+ case 8:
+ genCompoundExpression(node, context);
+ break;
+ case 3:
+ genComment(node, context);
+ break;
+ case 13:
+ genVNodeCall(node, context);
+ break;
+ case 14:
+ genCallExpression(node, context);
+ break;
+ case 15:
+ genObjectExpression(node, context);
+ break;
+ case 17:
+ genArrayExpression(node, context);
+ break;
+ case 18:
+ genFunctionExpression(node, context);
+ break;
+ case 19:
+ genConditionalExpression(node, context);
+ break;
+ case 20:
+ genCacheExpression(node, context);
+ break;
+ case 21:
+ genNodeList(node.body, context, true, false);
+ break;
+ case 22:
+ genTemplateLiteral(node, context);
+ break;
+ case 23:
+ genIfStatement(node, context);
+ break;
+ case 24:
+ genAssignmentExpression(node, context);
+ break;
+ case 25:
+ genSequenceExpression(node, context);
+ break;
+ case 26:
+ genReturnStatement(node, context);
+ break;
+ case 10:
+ break;
+ default:
+ {
+ assert(false, `unhandled codegen node type: ${node.type}`);
+ const exhaustiveCheck = node;
+ return exhaustiveCheck;
+ }
+ }
+}
+function genText(node, context) {
+ context.push(JSON.stringify(node.content), node);
+}
+function genExpression(node, context) {
+ const { content, isStatic } = node;
+ context.push(isStatic ? JSON.stringify(content) : content, node);
+}
+function genInterpolation(node, context) {
+ const { push, helper, pure } = context;
+ if (pure)
+ push(PURE_ANNOTATION);
+ push(`${helper(TO_DISPLAY_STRING)}(`);
+ genNode(node.content, context);
+ push(`)`);
+}
+function genCompoundExpression(node, context) {
+ for (let i = 0; i < node.children.length; i++) {
+ const child = node.children[i];
+ if (shared.isString(child)) {
+ context.push(child);
+ } else {
+ genNode(child, context);
+ }
+ }
+}
+function genExpressionAsPropertyKey(node, context) {
+ const { push } = context;
+ if (node.type === 8) {
+ push(`[`);
+ genCompoundExpression(node, context);
+ push(`]`);
+ } else if (node.isStatic) {
+ const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
+ push(text, node);
+ } else {
+ push(`[${node.content}]`, node);
+ }
+}
+function genComment(node, context) {
+ const { push, helper, pure } = context;
+ if (pure) {
+ push(PURE_ANNOTATION);
+ }
+ push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
+}
+function genVNodeCall(node, context) {
+ const { push, helper, pure } = context;
+ const {
+ tag,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ directives,
+ isBlock,
+ disableTracking,
+ isComponent
+ } = node;
+ if (directives) {
+ push(helper(WITH_DIRECTIVES) + `(`);
+ }
+ if (isBlock) {
+ push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
+ }
+ if (pure) {
+ push(PURE_ANNOTATION);
+ }
+ const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
+ push(helper(callHelper) + `(`, node);
+ genNodeList(
+ genNullableArgs([tag, props, children, patchFlag, dynamicProps]),
+ context
+ );
+ push(`)`);
+ if (isBlock) {
+ push(`)`);
+ }
+ if (directives) {
+ push(`, `);
+ genNode(directives, context);
+ push(`)`);
+ }
+}
+function genNullableArgs(args) {
+ let i = args.length;
+ while (i--) {
+ if (args[i] != null)
+ break;
+ }
+ return args.slice(0, i + 1).map((arg) => arg || `null`);
+}
+function genCallExpression(node, context) {
+ const { push, helper, pure } = context;
+ const callee = shared.isString(node.callee) ? node.callee : helper(node.callee);
+ if (pure) {
+ push(PURE_ANNOTATION);
+ }
+ push(callee + `(`, node);
+ genNodeList(node.arguments, context);
+ push(`)`);
+}
+function genObjectExpression(node, context) {
+ const { push, indent, deindent, newline } = context;
+ const { properties } = node;
+ if (!properties.length) {
+ push(`{}`, node);
+ return;
+ }
+ const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
+ push(multilines ? `{` : `{ `);
+ multilines && indent();
+ for (let i = 0; i < properties.length; i++) {
+ const { key, value } = properties[i];
+ genExpressionAsPropertyKey(key, context);
+ push(`: `);
+ genNode(value, context);
+ if (i < properties.length - 1) {
+ push(`,`);
+ newline();
+ }
+ }
+ multilines && deindent();
+ push(multilines ? `}` : ` }`);
+}
+function genArrayExpression(node, context) {
+ genNodeListAsArray(node.elements, context);
+}
+function genFunctionExpression(node, context) {
+ const { push, indent, deindent } = context;
+ const { params, returns, body, newline, isSlot } = node;
+ if (isSlot) {
+ push(`_${helperNameMap[WITH_CTX]}(`);
+ }
+ push(`(`, node);
+ if (shared.isArray(params)) {
+ genNodeList(params, context);
+ } else if (params) {
+ genNode(params, context);
+ }
+ push(`) => `);
+ if (newline || body) {
+ push(`{`);
+ indent();
+ }
+ if (returns) {
+ if (newline) {
+ push(`return `);
+ }
+ if (shared.isArray(returns)) {
+ genNodeListAsArray(returns, context);
+ } else {
+ genNode(returns, context);
+ }
+ } else if (body) {
+ genNode(body, context);
+ }
+ if (newline || body) {
+ deindent();
+ push(`}`);
+ }
+ if (isSlot) {
+ if (node.isNonScopedSlot) {
+ push(`, undefined, true`);
+ }
+ push(`)`);
+ }
+}
+function genConditionalExpression(node, context) {
+ const { test, consequent, alternate, newline: needNewline } = node;
+ const { push, indent, deindent, newline } = context;
+ if (test.type === 4) {
+ const needsParens = !isSimpleIdentifier(test.content);
+ needsParens && push(`(`);
+ genExpression(test, context);
+ needsParens && push(`)`);
+ } else {
+ push(`(`);
+ genNode(test, context);
+ push(`)`);
+ }
+ needNewline && indent();
+ context.indentLevel++;
+ needNewline || push(` `);
+ push(`? `);
+ genNode(consequent, context);
+ context.indentLevel--;
+ needNewline && newline();
+ needNewline || push(` `);
+ push(`: `);
+ const isNested = alternate.type === 19;
+ if (!isNested) {
+ context.indentLevel++;
+ }
+ genNode(alternate, context);
+ if (!isNested) {
+ context.indentLevel--;
+ }
+ needNewline && deindent(
+ true
+ /* without newline */
+ );
+}
+function genCacheExpression(node, context) {
+ const { push, helper, indent, deindent, newline } = context;
+ push(`_cache[${node.index}] || (`);
+ if (node.isVNode) {
+ indent();
+ push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
+ newline();
+ }
+ push(`_cache[${node.index}] = `);
+ genNode(node.value, context);
+ if (node.isVNode) {
+ push(`,`);
+ newline();
+ push(`${helper(SET_BLOCK_TRACKING)}(1),`);
+ newline();
+ push(`_cache[${node.index}]`);
+ deindent();
+ }
+ push(`)`);
+}
+function genTemplateLiteral(node, context) {
+ const { push, indent, deindent } = context;
+ push("`");
+ const l = node.elements.length;
+ const multilines = l > 3;
+ for (let i = 0; i < l; i++) {
+ const e = node.elements[i];
+ if (shared.isString(e)) {
+ push(e.replace(/(`|\$|\\)/g, "\\$1"));
+ } else {
+ push("${");
+ if (multilines)
+ indent();
+ genNode(e, context);
+ if (multilines)
+ deindent();
+ push("}");
+ }
+ }
+ push("`");
+}
+function genIfStatement(node, context) {
+ const { push, indent, deindent } = context;
+ const { test, consequent, alternate } = node;
+ push(`if (`);
+ genNode(test, context);
+ push(`) {`);
+ indent();
+ genNode(consequent, context);
+ deindent();
+ push(`}`);
+ if (alternate) {
+ push(` else `);
+ if (alternate.type === 23) {
+ genIfStatement(alternate, context);
+ } else {
+ push(`{`);
+ indent();
+ genNode(alternate, context);
+ deindent();
+ push(`}`);
+ }
+ }
+}
+function genAssignmentExpression(node, context) {
+ genNode(node.left, context);
+ context.push(` = `);
+ genNode(node.right, context);
+}
+function genSequenceExpression(node, context) {
+ context.push(`(`);
+ genNodeList(node.expressions, context);
+ context.push(`)`);
+}
+function genReturnStatement({ returns }, context) {
+ context.push(`return `);
+ if (shared.isArray(returns)) {
+ genNodeListAsArray(returns, context);
+ } else {
+ genNode(returns, context);
+ }
+}
+
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
+ const rootExp = root.type === "Program" && root.body[0].type === "ExpressionStatement" && root.body[0].expression;
+ estreeWalker.walk(root, {
+ enter(node, parent) {
+ parent && parentStack.push(parent);
+ if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) {
+ return this.skip();
+ }
+ if (node.type === "Identifier") {
+ const isLocal = !!knownIds[node.name];
+ const isRefed = isReferencedIdentifier(node, parent, parentStack);
+ if (includeAll || isRefed && !isLocal) {
+ onIdentifier(node, parent, parentStack, isRefed, isLocal);
+ }
+ } else if (node.type === "ObjectProperty" && parent.type === "ObjectPattern") {
+ node.inPattern = true;
+ } else if (isFunctionType(node)) {
+ walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
+ } else if (node.type === "BlockStatement") {
+ walkBlockDeclarations(
+ node,
+ (id) => markScopeIdentifier(node, id, knownIds)
+ );
+ }
+ },
+ leave(node, parent) {
+ parent && parentStack.pop();
+ if (node !== rootExp && node.scopeIds) {
+ for (const id of node.scopeIds) {
+ knownIds[id]--;
+ if (knownIds[id] === 0) {
+ delete knownIds[id];
+ }
+ }
+ }
+ }
+ });
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+ if (!parent) {
+ return true;
+ }
+ if (id.name === "arguments") {
+ return false;
+ }
+ if (isReferenced(id, parent)) {
+ return true;
+ }
+ switch (parent.type) {
+ case "AssignmentExpression":
+ case "AssignmentPattern":
+ return true;
+ case "ObjectPattern":
+ case "ArrayPattern":
+ return isInDestructureAssignment(parent, parentStack);
+ }
+ return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+ if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
+ let i = parentStack.length;
+ while (i--) {
+ const p = parentStack[i];
+ if (p.type === "AssignmentExpression") {
+ return true;
+ } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
+ break;
+ }
+ }
+ }
+ return false;
+}
+function walkFunctionParams(node, onIdent) {
+ for (const p of node.params) {
+ for (const id of extractIdentifiers(p)) {
+ onIdent(id);
+ }
+ }
+}
+function walkBlockDeclarations(block, onIdent) {
+ for (const stmt of block.body) {
+ if (stmt.type === "VariableDeclaration") {
+ if (stmt.declare)
+ continue;
+ for (const decl of stmt.declarations) {
+ for (const id of extractIdentifiers(decl.id)) {
+ onIdent(id);
+ }
+ }
+ } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+ if (stmt.declare || !stmt.id)
+ continue;
+ onIdent(stmt.id);
+ } else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
+ const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+ if (variable && variable.type === "VariableDeclaration") {
+ for (const decl of variable.declarations) {
+ for (const id of extractIdentifiers(decl.id)) {
+ onIdent(id);
+ }
+ }
+ }
+ }
+ }
+}
+function extractIdentifiers(param, nodes = []) {
+ switch (param.type) {
+ case "Identifier":
+ nodes.push(param);
+ break;
+ case "MemberExpression":
+ let object = param;
+ while (object.type === "MemberExpression") {
+ object = object.object;
+ }
+ nodes.push(object);
+ break;
+ case "ObjectPattern":
+ for (const prop of param.properties) {
+ if (prop.type === "RestElement") {
+ extractIdentifiers(prop.argument, nodes);
+ } else {
+ extractIdentifiers(prop.value, nodes);
+ }
+ }
+ break;
+ case "ArrayPattern":
+ param.elements.forEach((element) => {
+ if (element)
+ extractIdentifiers(element, nodes);
+ });
+ break;
+ case "RestElement":
+ extractIdentifiers(param.argument, nodes);
+ break;
+ case "AssignmentPattern":
+ extractIdentifiers(param.left, nodes);
+ break;
+ }
+ return nodes;
+}
+function markScopeIdentifier(node, child, knownIds) {
+ const { name } = child;
+ if (node.scopeIds && node.scopeIds.has(name)) {
+ return;
+ }
+ if (name in knownIds) {
+ knownIds[name]++;
+ } else {
+ knownIds[name] = 1;
+ }
+ (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
+}
+const isFunctionType = (node) => {
+ return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+function isReferenced(node, parent, grandparent) {
+ switch (parent.type) {
+ case "MemberExpression":
+ case "OptionalMemberExpression":
+ if (parent.property === node) {
+ return !!parent.computed;
+ }
+ return parent.object === node;
+ case "JSXMemberExpression":
+ return parent.object === node;
+ case "VariableDeclarator":
+ return parent.init === node;
+ case "ArrowFunctionExpression":
+ return parent.body === node;
+ case "PrivateName":
+ return false;
+ case "ClassMethod":
+ case "ClassPrivateMethod":
+ case "ObjectMethod":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return false;
+ case "ObjectProperty":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return !grandparent || grandparent.type !== "ObjectPattern";
+ case "ClassProperty":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return true;
+ case "ClassPrivateProperty":
+ return parent.key !== node;
+ case "ClassDeclaration":
+ case "ClassExpression":
+ return parent.superClass === node;
+ case "AssignmentExpression":
+ return parent.right === node;
+ case "AssignmentPattern":
+ return parent.right === node;
+ case "LabeledStatement":
+ return false;
+ case "CatchClause":
+ return false;
+ case "RestElement":
+ return false;
+ case "BreakStatement":
+ case "ContinueStatement":
+ return false;
+ case "FunctionDeclaration":
+ case "FunctionExpression":
+ return false;
+ case "ExportNamespaceSpecifier":
+ case "ExportDefaultSpecifier":
+ return false;
+ case "ExportSpecifier":
+ if (grandparent == null ? void 0 : grandparent.source) {
+ return false;
+ }
+ return parent.local === node;
+ case "ImportDefaultSpecifier":
+ case "ImportNamespaceSpecifier":
+ case "ImportSpecifier":
+ return false;
+ case "ImportAttribute":
+ return false;
+ case "JSXAttribute":
+ return false;
+ case "ObjectPattern":
+ case "ArrayPattern":
+ return false;
+ case "MetaProperty":
+ return false;
+ case "ObjectTypeProperty":
+ return parent.key !== node;
+ case "TSEnumMember":
+ return parent.id !== node;
+ case "TSPropertySignature":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return true;
+ }
+ return true;
+}
+const TS_NODE_TYPES = [
+ "TSAsExpression",
+ // foo as number
+ "TSTypeAssertion",
+ // (<number>foo)
+ "TSNonNullExpression",
+ // foo!
+ "TSInstantiationExpression",
+ // foo<string>
+ "TSSatisfiesExpression"
+ // foo satisfies T
+];
+
+const isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap("true,false,null,this");
+const constantBailRE = /\w\s*\(|\.[^\d]/;
+const transformExpression = (node, context) => {
+ if (node.type === 5) {
+ node.content = processExpression(
+ node.content,
+ context
+ );
+ } else if (node.type === 1) {
+ for (let i = 0; i < node.props.length; i++) {
+ const dir = node.props[i];
+ if (dir.type === 7 && dir.name !== "for") {
+ const exp = dir.exp;
+ const arg = dir.arg;
+ if (exp && exp.type === 4 && !(dir.name === "on" && arg)) {
+ dir.exp = processExpression(
+ exp,
+ context,
+ // slot args must be processed as function params
+ dir.name === "slot"
+ );
+ }
+ if (arg && arg.type === 4 && !arg.isStatic) {
+ dir.arg = processExpression(arg, context);
+ }
+ }
+ }
+ }
+};
+function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
+ if (!context.prefixIdentifiers || !node.content.trim()) {
+ return node;
+ }
+ const { inline, bindingMetadata } = context;
+ const rewriteIdentifier = (raw, parent, id) => {
+ const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw];
+ if (inline) {
+ const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
+ const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
+ const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
+ if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) {
+ return raw;
+ } else if (type === "setup-ref") {
+ return `${raw}.value`;
+ } else if (type === "setup-maybe-ref") {
+ return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : `${context.helperString(UNREF)}(${raw})`;
+ } else if (type === "setup-let") {
+ if (isAssignmentLVal) {
+ const { right: rVal, operator } = parent;
+ const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);
+ const rExpString = stringifyExpression(
+ processExpression(
+ createSimpleExpression(rExp, false),
+ context,
+ false,
+ false,
+ knownIds
+ )
+ );
+ return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
+` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
+ } else if (isUpdateArg) {
+ id.start = parent.start;
+ id.end = parent.end;
+ const { prefix: isPrefix, operator } = parent;
+ const prefix = isPrefix ? operator : ``;
+ const postfix = isPrefix ? `` : operator;
+ return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
+` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
+ } else if (isDestructureAssignment) {
+ return raw;
+ } else {
+ return `${context.helperString(UNREF)}(${raw})`;
+ }
+ } else if (type === "props") {
+ return shared.genPropsAccessExp(raw);
+ } else if (type === "props-aliased") {
+ return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
+ }
+ } else {
+ if (type && type.startsWith("setup") || type === "literal-const") {
+ return `$setup.${raw}`;
+ } else if (type === "props-aliased") {
+ return `$props['${bindingMetadata.__propsAliases[raw]}']`;
+ } else if (type) {
+ return `$${type}.${raw}`;
+ }
+ }
+ return `_ctx.${raw}`;
+ };
+ const rawExp = node.content;
+ const bailConstant = constantBailRE.test(rawExp);
+ if (isSimpleIdentifier(rawExp)) {
+ const isScopeVarReference = context.identifiers[rawExp];
+ const isAllowedGlobal = shared.isGloballyAllowed(rawExp);
+ const isLiteral = isLiteralWhitelisted(rawExp);
+ if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {
+ if (isConst(bindingMetadata[rawExp])) {
+ node.constType = 1;
+ }
+ node.content = rewriteIdentifier(rawExp);
+ } else if (!isScopeVarReference) {
+ if (isLiteral) {
+ node.constType = 3;
+ } else {
+ node.constType = 2;
+ }
+ }
+ return node;
+ }
+ let ast;
+ const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
+ try {
+ ast = parser.parse(source, {
+ plugins: context.expressionPlugins
+ }).program;
+ } catch (e) {
+ context.onError(
+ createCompilerError(
+ 45,
+ node.loc,
+ void 0,
+ e.message
+ )
+ );
+ return node;
+ }
+ const ids = [];
+ const parentStack = [];
+ const knownIds = Object.create(context.identifiers);
+ walkIdentifiers(
+ ast,
+ (node2, parent, _, isReferenced, isLocal) => {
+ if (isStaticPropertyKey(node2, parent)) {
+ return;
+ }
+ if (node2.name.startsWith("_filter_")) {
+ return;
+ }
+ const needPrefix = isReferenced && canPrefix(node2);
+ if (needPrefix && !isLocal) {
+ if (isStaticProperty(parent) && parent.shorthand) {
+ node2.prefix = `${node2.name}: `;
+ }
+ node2.name = rewriteIdentifier(node2.name, parent, node2);
+ ids.push(node2);
+ } else {
+ if (!(needPrefix && isLocal) && !bailConstant) {
+ node2.isConstant = true;
+ }
+ ids.push(node2);
+ }
+ },
+ true,
+ // invoke on ALL identifiers
+ parentStack,
+ knownIds
+ );
+ const children = [];
+ ids.sort((a, b) => a.start - b.start);
+ ids.forEach((id, i) => {
+ const start = id.start - 1;
+ const end = id.end - 1;
+ const last = ids[i - 1];
+ const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
+ if (leadingText.length || id.prefix) {
+ children.push(leadingText + (id.prefix || ``));
+ }
+ const source2 = rawExp.slice(start, end);
+ children.push(
+ createSimpleExpression(
+ id.name,
+ false,
+ {
+ source: source2,
+ start: advancePositionWithClone(node.loc.start, source2, start),
+ end: advancePositionWithClone(node.loc.start, source2, end)
+ },
+ id.isConstant ? 3 : 0
+ )
+ );
+ if (i === ids.length - 1 && end < rawExp.length) {
+ children.push(rawExp.slice(end));
+ }
+ });
+ let ret;
+ if (children.length) {
+ ret = createCompoundExpression(children, node.loc);
+ } else {
+ ret = node;
+ ret.constType = bailConstant ? 0 : 3;
+ }
+ ret.identifiers = Object.keys(knownIds);
+ return ret;
+}
+function canPrefix(id) {
+ if (shared.isGloballyAllowed(id.name)) {
+ return false;
+ }
+ if (id.name === "require") {
+ return false;
+ }
+ return true;
+}
+function stringifyExpression(exp) {
+ if (shared.isString(exp)) {
+ return exp;
+ } else if (exp.type === 4) {
+ return exp.content;
+ } else {
+ return exp.children.map(stringifyExpression).join("");
+ }
+}
+function isConst(type) {
+ return type === "setup-const" || type === "literal-const";
+}
+
+const transformIf = createStructuralDirectiveTransform(
+ /^(if|else|else-if)$/,
+ (node, dir, context) => {
+ return processIf(node, dir, context, (ifNode, branch, isRoot) => {
+ const siblings = context.parent.children;
+ let i = siblings.indexOf(ifNode);
+ let key = 0;
+ while (i-- >= 0) {
+ const sibling = siblings[i];
+ if (sibling && sibling.type === 9) {
+ key += sibling.branches.length;
+ }
+ }
+ return () => {
+ if (isRoot) {
+ ifNode.codegenNode = createCodegenNodeForBranch(
+ branch,
+ key,
+ context
+ );
+ } else {
+ const parentCondition = getParentCondition(ifNode.codegenNode);
+ parentCondition.alternate = createCodegenNodeForBranch(
+ branch,
+ key + ifNode.branches.length - 1,
+ context
+ );
+ }
+ };
+ });
+ }
+);
+function processIf(node, dir, context, processCodegen) {
+ if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
+ const loc = dir.exp ? dir.exp.loc : node.loc;
+ context.onError(
+ createCompilerError(28, dir.loc)
+ );
+ dir.exp = createSimpleExpression(`true`, false, loc);
+ }
+ if (context.prefixIdentifiers && dir.exp) {
+ dir.exp = processExpression(dir.exp, context);
+ }
+ if (dir.name === "if") {
+ const branch = createIfBranch(node, dir);
+ const ifNode = {
+ type: 9,
+ loc: node.loc,
+ branches: [branch]
+ };
+ context.replaceNode(ifNode);
+ if (processCodegen) {
+ return processCodegen(ifNode, branch, true);
+ }
+ } else {
+ const siblings = context.parent.children;
+ const comments = [];
+ let i = siblings.indexOf(node);
+ while (i-- >= -1) {
+ const sibling = siblings[i];
+ if (sibling && sibling.type === 3) {
+ context.removeNode(sibling);
+ comments.unshift(sibling);
+ continue;
+ }
+ if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
+ context.removeNode(sibling);
+ continue;
+ }
+ if (sibling && sibling.type === 9) {
+ if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
+ context.onError(
+ createCompilerError(30, node.loc)
+ );
+ }
+ context.removeNode();
+ const branch = createIfBranch(node, dir);
+ if (comments.length && // #3619 ignore comments if the v-if is direct child of <transition>
+ !(context.parent && context.parent.type === 1 && isBuiltInType(context.parent.tag, "transition"))) {
+ branch.children = [...comments, ...branch.children];
+ }
+ {
+ const key = branch.userKey;
+ if (key) {
+ sibling.branches.forEach(({ userKey }) => {
+ if (isSameKey(userKey, key)) {
+ context.onError(
+ createCompilerError(
+ 29,
+ branch.userKey.loc
+ )
+ );
+ }
+ });
+ }
+ }
+ sibling.branches.push(branch);
+ const onExit = processCodegen && processCodegen(sibling, branch, false);
+ traverseNode(branch, context);
+ if (onExit)
+ onExit();
+ context.currentNode = null;
+ } else {
+ context.onError(
+ createCompilerError(30, node.loc)
+ );
+ }
+ break;
+ }
+ }
+}
+function createIfBranch(node, dir) {
+ const isTemplateIf = node.tagType === 3;
+ return {
+ type: 10,
+ loc: node.loc,
+ condition: dir.name === "else" ? void 0 : dir.exp,
+ children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
+ userKey: findProp(node, `key`),
+ isTemplateIf
+ };
+}
+function createCodegenNodeForBranch(branch, keyIndex, context) {
+ if (branch.condition) {
+ return createConditionalExpression(
+ branch.condition,
+ createChildrenCodegenNode(branch, keyIndex, context),
+ // make sure to pass in asBlock: true so that the comment node call
+ // closes the current block.
+ createCallExpression(context.helper(CREATE_COMMENT), [
+ '"v-if"' ,
+ "true"
+ ])
+ );
+ } else {
+ return createChildrenCodegenNode(branch, keyIndex, context);
+ }
+}
+function createChildrenCodegenNode(branch, keyIndex, context) {
+ const { helper } = context;
+ const keyProperty = createObjectProperty(
+ `key`,
+ createSimpleExpression(
+ `${keyIndex}`,
+ false,
+ locStub,
+ 2
+ )
+ );
+ const { children } = branch;
+ const firstChild = children[0];
+ const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
+ if (needFragmentWrapper) {
+ if (children.length === 1 && firstChild.type === 11) {
+ const vnodeCall = firstChild.codegenNode;
+ injectProp(vnodeCall, keyProperty, context);
+ return vnodeCall;
+ } else {
+ let patchFlag = 64;
+ let patchFlagText = shared.PatchFlagNames[64];
+ if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) {
+ patchFlag |= 2048;
+ patchFlagText += `, ${shared.PatchFlagNames[2048]}`;
+ }
+ return createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ createObjectExpression([keyProperty]),
+ children,
+ patchFlag + (` /* ${patchFlagText} */` ),
+ void 0,
+ void 0,
+ true,
+ false,
+ false,
+ branch.loc
+ );
+ }
+ } else {
+ const ret = firstChild.codegenNode;
+ const vnodeCall = getMemoedVNodeCall(ret);
+ if (vnodeCall.type === 13) {
+ convertToBlock(vnodeCall, context);
+ }
+ injectProp(vnodeCall, keyProperty, context);
+ return ret;
+ }
+}
+function isSameKey(a, b) {
+ if (!a || a.type !== b.type) {
+ return false;
+ }
+ if (a.type === 6) {
+ if (a.value.content !== b.value.content) {
+ return false;
+ }
+ } else {
+ const exp = a.exp;
+ const branchExp = b.exp;
+ if (exp.type !== branchExp.type) {
+ return false;
+ }
+ if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
+ return false;
+ }
+ }
+ return true;
+}
+function getParentCondition(node) {
+ while (true) {
+ if (node.type === 19) {
+ if (node.alternate.type === 19) {
+ node = node.alternate;
+ } else {
+ return node;
+ }
+ } else if (node.type === 20) {
+ node = node.value;
+ }
+ }
+}
+
+const transformFor = createStructuralDirectiveTransform(
+ "for",
+ (node, dir, context) => {
+ const { helper, removeHelper } = context;
+ return processFor(node, dir, context, (forNode) => {
+ const renderExp = createCallExpression(helper(RENDER_LIST), [
+ forNode.source
+ ]);
+ const isTemplate = isTemplateNode(node);
+ const memo = findDir(node, "memo");
+ const keyProp = findProp(node, `key`);
+ const keyExp = keyProp && (keyProp.type === 6 ? createSimpleExpression(keyProp.value.content, true) : keyProp.exp);
+ const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;
+ if (isTemplate) {
+ if (memo) {
+ memo.exp = processExpression(
+ memo.exp,
+ context
+ );
+ }
+ if (keyProperty && keyProp.type !== 6) {
+ keyProperty.value = processExpression(
+ keyProperty.value,
+ context
+ );
+ }
+ }
+ const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
+ const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
+ forNode.codegenNode = createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ void 0,
+ renderExp,
+ fragmentFlag + (` /* ${shared.PatchFlagNames[fragmentFlag]} */` ),
+ void 0,
+ void 0,
+ true,
+ !isStableFragment,
+ false,
+ node.loc
+ );
+ return () => {
+ let childBlock;
+ const { children } = forNode;
+ if (isTemplate) {
+ node.children.some((c) => {
+ if (c.type === 1) {
+ const key = findProp(c, "key");
+ if (key) {
+ context.onError(
+ createCompilerError(
+ 33,
+ key.loc
+ )
+ );
+ return true;
+ }
+ }
+ });
+ }
+ const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
+ const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
+ if (slotOutlet) {
+ childBlock = slotOutlet.codegenNode;
+ if (isTemplate && keyProperty) {
+ injectProp(childBlock, keyProperty, context);
+ }
+ } else if (needFragmentWrapper) {
+ childBlock = createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ keyProperty ? createObjectExpression([keyProperty]) : void 0,
+ node.children,
+ 64 + (` /* ${shared.PatchFlagNames[64]} */` ),
+ void 0,
+ void 0,
+ true,
+ void 0,
+ false
+ /* isComponent */
+ );
+ } else {
+ childBlock = children[0].codegenNode;
+ if (isTemplate && keyProperty) {
+ injectProp(childBlock, keyProperty, context);
+ }
+ if (childBlock.isBlock !== !isStableFragment) {
+ if (childBlock.isBlock) {
+ removeHelper(OPEN_BLOCK);
+ removeHelper(
+ getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
+ );
+ } else {
+ removeHelper(
+ getVNodeHelper(context.inSSR, childBlock.isComponent)
+ );
+ }
+ }
+ childBlock.isBlock = !isStableFragment;
+ if (childBlock.isBlock) {
+ helper(OPEN_BLOCK);
+ helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
+ } else {
+ helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
+ }
+ }
+ if (memo) {
+ const loop = createFunctionExpression(
+ createForLoopParams(forNode.parseResult, [
+ createSimpleExpression(`_cached`)
+ ])
+ );
+ loop.body = createBlockStatement([
+ createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
+ createCompoundExpression([
+ `if (_cached`,
+ ...keyExp ? [` && _cached.key === `, keyExp] : [],
+ ` && ${context.helperString(
+ IS_MEMO_SAME
+ )}(_cached, _memo)) return _cached`
+ ]),
+ createCompoundExpression([`const _item = `, childBlock]),
+ createSimpleExpression(`_item.memo = _memo`),
+ createSimpleExpression(`return _item`)
+ ]);
+ renderExp.arguments.push(
+ loop,
+ createSimpleExpression(`_cache`),
+ createSimpleExpression(String(context.cached++))
+ );
+ } else {
+ renderExp.arguments.push(
+ createFunctionExpression(
+ createForLoopParams(forNode.parseResult),
+ childBlock,
+ true
+ /* force newline */
+ )
+ );
+ }
+ };
+ });
+ }
+);
+function processFor(node, dir, context, processCodegen) {
+ if (!dir.exp) {
+ context.onError(
+ createCompilerError(31, dir.loc)
+ );
+ return;
+ }
+ const parseResult = parseForExpression(
+ // can only be simple expression because vFor transform is applied
+ // before expression transform.
+ dir.exp,
+ context
+ );
+ if (!parseResult) {
+ context.onError(
+ createCompilerError(32, dir.loc)
+ );
+ return;
+ }
+ const { addIdentifiers, removeIdentifiers, scopes } = context;
+ const { source, value, key, index } = parseResult;
+ const forNode = {
+ type: 11,
+ loc: dir.loc,
+ source,
+ valueAlias: value,
+ keyAlias: key,
+ objectIndexAlias: index,
+ parseResult,
+ children: isTemplateNode(node) ? node.children : [node]
+ };
+ context.replaceNode(forNode);
+ scopes.vFor++;
+ if (context.prefixIdentifiers) {
+ value && addIdentifiers(value);
+ key && addIdentifiers(key);
+ index && addIdentifiers(index);
+ }
+ const onExit = processCodegen && processCodegen(forNode);
+ return () => {
+ scopes.vFor--;
+ if (context.prefixIdentifiers) {
+ value && removeIdentifiers(value);
+ key && removeIdentifiers(key);
+ index && removeIdentifiers(index);
+ }
+ if (onExit)
+ onExit();
+ };
+}
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+function parseForExpression(input, context) {
+ const loc = input.loc;
+ const exp = input.content;
+ const inMatch = exp.match(forAliasRE);
+ if (!inMatch)
+ return;
+ const [, LHS, RHS] = inMatch;
+ const result = {
+ source: createAliasExpression(
+ loc,
+ RHS.trim(),
+ exp.indexOf(RHS, LHS.length)
+ ),
+ value: void 0,
+ key: void 0,
+ index: void 0
+ };
+ if (context.prefixIdentifiers) {
+ result.source = processExpression(
+ result.source,
+ context
+ );
+ }
+ let valueContent = LHS.trim().replace(stripParensRE, "").trim();
+ const trimmedOffset = LHS.indexOf(valueContent);
+ const iteratorMatch = valueContent.match(forIteratorRE);
+ if (iteratorMatch) {
+ valueContent = valueContent.replace(forIteratorRE, "").trim();
+ const keyContent = iteratorMatch[1].trim();
+ let keyOffset;
+ if (keyContent) {
+ keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
+ result.key = createAliasExpression(loc, keyContent, keyOffset);
+ if (context.prefixIdentifiers) {
+ result.key = processExpression(result.key, context, true);
+ }
+ }
+ if (iteratorMatch[2]) {
+ const indexContent = iteratorMatch[2].trim();
+ if (indexContent) {
+ result.index = createAliasExpression(
+ loc,
+ indexContent,
+ exp.indexOf(
+ indexContent,
+ result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
+ )
+ );
+ if (context.prefixIdentifiers) {
+ result.index = processExpression(result.index, context, true);
+ }
+ }
+ }
+ }
+ if (valueContent) {
+ result.value = createAliasExpression(loc, valueContent, trimmedOffset);
+ if (context.prefixIdentifiers) {
+ result.value = processExpression(result.value, context, true);
+ }
+ }
+ return result;
+}
+function createAliasExpression(range, content, offset) {
+ return createSimpleExpression(
+ content,
+ false,
+ getInnerRange(range, offset, content.length)
+ );
+}
+function createForLoopParams({ value, key, index }, memoArgs = []) {
+ return createParamsList([value, key, index, ...memoArgs]);
+}
+function createParamsList(args) {
+ let i = args.length;
+ while (i--) {
+ if (args[i])
+ break;
+ }
+ return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
+}
+
+const defaultFallback = createSimpleExpression(`undefined`, false);
+const trackSlotScopes = (node, context) => {
+ if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
+ const vSlot = findDir(node, "slot");
+ if (vSlot) {
+ const slotProps = vSlot.exp;
+ if (context.prefixIdentifiers) {
+ slotProps && context.addIdentifiers(slotProps);
+ }
+ context.scopes.vSlot++;
+ return () => {
+ if (context.prefixIdentifiers) {
+ slotProps && context.removeIdentifiers(slotProps);
+ }
+ context.scopes.vSlot--;
+ };
+ }
+ }
+};
+const trackVForSlotScopes = (node, context) => {
+ let vFor;
+ if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
+ const result = vFor.parseResult = parseForExpression(
+ vFor.exp,
+ context
+ );
+ if (result) {
+ const { value, key, index } = result;
+ const { addIdentifiers, removeIdentifiers } = context;
+ value && addIdentifiers(value);
+ key && addIdentifiers(key);
+ index && addIdentifiers(index);
+ return () => {
+ value && removeIdentifiers(value);
+ key && removeIdentifiers(key);
+ index && removeIdentifiers(index);
+ };
+ }
+ }
+};
+const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(
+ props,
+ children,
+ false,
+ true,
+ children.length ? children[0].loc : loc
+);
+function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
+ context.helper(WITH_CTX);
+ const { children, loc } = node;
+ const slotsProperties = [];
+ const dynamicSlots = [];
+ let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
+ if (!context.ssr && context.prefixIdentifiers) {
+ hasDynamicSlots = hasScopeRef(node, context.identifiers);
+ }
+ const onComponentSlot = findDir(node, "slot", true);
+ if (onComponentSlot) {
+ const { arg, exp } = onComponentSlot;
+ if (arg && !isStaticExp(arg)) {
+ hasDynamicSlots = true;
+ }
+ slotsProperties.push(
+ createObjectProperty(
+ arg || createSimpleExpression("default", true),
+ buildSlotFn(exp, void 0, children, loc)
+ )
+ );
+ }
+ let hasTemplateSlots = false;
+ let hasNamedDefaultSlot = false;
+ const implicitDefaultChildren = [];
+ const seenSlotNames = /* @__PURE__ */ new Set();
+ let conditionalBranchIndex = 0;
+ for (let i = 0; i < children.length; i++) {
+ const slotElement = children[i];
+ let slotDir;
+ if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
+ if (slotElement.type !== 3) {
+ implicitDefaultChildren.push(slotElement);
+ }
+ continue;
+ }
+ if (onComponentSlot) {
+ context.onError(
+ createCompilerError(37, slotDir.loc)
+ );
+ break;
+ }
+ hasTemplateSlots = true;
+ const { children: slotChildren, loc: slotLoc } = slotElement;
+ const {
+ arg: slotName = createSimpleExpression(`default`, true),
+ exp: slotProps,
+ loc: dirLoc
+ } = slotDir;
+ let staticSlotName;
+ if (isStaticExp(slotName)) {
+ staticSlotName = slotName ? slotName.content : `default`;
+ } else {
+ hasDynamicSlots = true;
+ }
+ const vFor = findDir(slotElement, "for");
+ const slotFunction = buildSlotFn(
+ slotProps,
+ vFor == null ? void 0 : vFor.exp,
+ slotChildren,
+ slotLoc
+ );
+ let vIf;
+ let vElse;
+ if (vIf = findDir(slotElement, "if")) {
+ hasDynamicSlots = true;
+ dynamicSlots.push(
+ createConditionalExpression(
+ vIf.exp,
+ buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
+ defaultFallback
+ )
+ );
+ } else if (vElse = findDir(
+ slotElement,
+ /^else(-if)?$/,
+ true
+ /* allowEmpty */
+ )) {
+ let j = i;
+ let prev;
+ while (j--) {
+ prev = children[j];
+ if (prev.type !== 3) {
+ break;
+ }
+ }
+ if (prev && isTemplateNode(prev) && findDir(prev, "if")) {
+ children.splice(i, 1);
+ i--;
+ let conditional = dynamicSlots[dynamicSlots.length - 1];
+ while (conditional.alternate.type === 19) {
+ conditional = conditional.alternate;
+ }
+ conditional.alternate = vElse.exp ? createConditionalExpression(
+ vElse.exp,
+ buildDynamicSlot(
+ slotName,
+ slotFunction,
+ conditionalBranchIndex++
+ ),
+ defaultFallback
+ ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
+ } else {
+ context.onError(
+ createCompilerError(30, vElse.loc)
+ );
+ }
+ } else if (vFor) {
+ hasDynamicSlots = true;
+ const parseResult = vFor.parseResult || parseForExpression(vFor.exp, context);
+ if (parseResult) {
+ dynamicSlots.push(
+ createCallExpression(context.helper(RENDER_LIST), [
+ parseResult.source,
+ createFunctionExpression(
+ createForLoopParams(parseResult),
+ buildDynamicSlot(slotName, slotFunction),
+ true
+ /* force newline */
+ )
+ ])
+ );
+ } else {
+ context.onError(
+ createCompilerError(32, vFor.loc)
+ );
+ }
+ } else {
+ if (staticSlotName) {
+ if (seenSlotNames.has(staticSlotName)) {
+ context.onError(
+ createCompilerError(
+ 38,
+ dirLoc
+ )
+ );
+ continue;
+ }
+ seenSlotNames.add(staticSlotName);
+ if (staticSlotName === "default") {
+ hasNamedDefaultSlot = true;
+ }
+ }
+ slotsProperties.push(createObjectProperty(slotName, slotFunction));
+ }
+ }
+ if (!onComponentSlot) {
+ const buildDefaultSlotProperty = (props, children2) => {
+ const fn = buildSlotFn(props, void 0, children2, loc);
+ if (context.compatConfig) {
+ fn.isNonScopedSlot = true;
+ }
+ return createObjectProperty(`default`, fn);
+ };
+ if (!hasTemplateSlots) {
+ slotsProperties.push(buildDefaultSlotProperty(void 0, children));
+ } else if (implicitDefaultChildren.length && // #3766
+ // with whitespace: 'preserve', whitespaces between slots will end up in
+ // implicitDefaultChildren. Ignore if all implicit children are whitespaces.
+ implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
+ if (hasNamedDefaultSlot) {
+ context.onError(
+ createCompilerError(
+ 39,
+ implicitDefaultChildren[0].loc
+ )
+ );
+ } else {
+ slotsProperties.push(
+ buildDefaultSlotProperty(void 0, implicitDefaultChildren)
+ );
+ }
+ }
+ }
+ const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
+ let slots = createObjectExpression(
+ slotsProperties.concat(
+ createObjectProperty(
+ `_`,
+ // 2 = compiled but dynamic = can skip normalization, but must run diff
+ // 1 = compiled and static = can skip normalization AND diff as optimized
+ createSimpleExpression(
+ slotFlag + (` /* ${shared.slotFlagsText[slotFlag]} */` ),
+ false
+ )
+ )
+ ),
+ loc
+ );
+ if (dynamicSlots.length) {
+ slots = createCallExpression(context.helper(CREATE_SLOTS), [
+ slots,
+ createArrayExpression(dynamicSlots)
+ ]);
+ }
+ return {
+ slots,
+ hasDynamicSlots
+ };
+}
+function buildDynamicSlot(name, fn, index) {
+ const props = [
+ createObjectProperty(`name`, name),
+ createObjectProperty(`fn`, fn)
+ ];
+ if (index != null) {
+ props.push(
+ createObjectProperty(`key`, createSimpleExpression(String(index), true))
+ );
+ }
+ return createObjectExpression(props);
+}
+function hasForwardedSlots(children) {
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ switch (child.type) {
+ case 1:
+ if (child.tagType === 2 || hasForwardedSlots(child.children)) {
+ return true;
+ }
+ break;
+ case 9:
+ if (hasForwardedSlots(child.branches))
+ return true;
+ break;
+ case 10:
+ case 11:
+ if (hasForwardedSlots(child.children))
+ return true;
+ break;
+ }
+ }
+ return false;
+}
+function isNonWhitespaceContent(node) {
+ if (node.type !== 2 && node.type !== 12)
+ return true;
+ return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
+}
+
+const directiveImportMap = /* @__PURE__ */ new WeakMap();
+const transformElement = (node, context) => {
+ return function postTransformElement() {
+ node = context.currentNode;
+ if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
+ return;
+ }
+ const { tag, props } = node;
+ const isComponent = node.tagType === 1;
+ let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
+ const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
+ let vnodeProps;
+ let vnodeChildren;
+ let vnodePatchFlag;
+ let patchFlag = 0;
+ let vnodeDynamicProps;
+ let dynamicPropNames;
+ let vnodeDirectives;
+ let shouldUseBlock = (
+ // dynamic component may resolve to plain elements
+ isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
+ // updates inside get proper isSVG flag at runtime. (#639, #643)
+ // This is technically web-specific, but splitting the logic out of core
+ // leads to too much unnecessary complexity.
+ (tag === "svg" || tag === "foreignObject")
+ );
+ if (props.length > 0) {
+ const propsBuildResult = buildProps(
+ node,
+ context,
+ void 0,
+ isComponent,
+ isDynamicComponent
+ );
+ vnodeProps = propsBuildResult.props;
+ patchFlag = propsBuildResult.patchFlag;
+ dynamicPropNames = propsBuildResult.dynamicPropNames;
+ const directives = propsBuildResult.directives;
+ vnodeDirectives = directives && directives.length ? createArrayExpression(
+ directives.map((dir) => buildDirectiveArgs(dir, context))
+ ) : void 0;
+ if (propsBuildResult.shouldUseBlock) {
+ shouldUseBlock = true;
+ }
+ }
+ if (node.children.length > 0) {
+ if (vnodeTag === KEEP_ALIVE) {
+ shouldUseBlock = true;
+ patchFlag |= 1024;
+ if (node.children.length > 1) {
+ context.onError(
+ createCompilerError(46, {
+ start: node.children[0].loc.start,
+ end: node.children[node.children.length - 1].loc.end,
+ source: ""
+ })
+ );
+ }
+ }
+ const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
+ vnodeTag !== TELEPORT && // explained above.
+ vnodeTag !== KEEP_ALIVE;
+ if (shouldBuildAsSlots) {
+ const { slots, hasDynamicSlots } = buildSlots(node, context);
+ vnodeChildren = slots;
+ if (hasDynamicSlots) {
+ patchFlag |= 1024;
+ }
+ } else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
+ const child = node.children[0];
+ const type = child.type;
+ const hasDynamicTextChild = type === 5 || type === 8;
+ if (hasDynamicTextChild && getConstantType(child, context) === 0) {
+ patchFlag |= 1;
+ }
+ if (hasDynamicTextChild || type === 2) {
+ vnodeChildren = child;
+ } else {
+ vnodeChildren = node.children;
+ }
+ } else {
+ vnodeChildren = node.children;
+ }
+ }
+ if (patchFlag !== 0) {
+ {
+ if (patchFlag < 0) {
+ vnodePatchFlag = patchFlag + ` /* ${shared.PatchFlagNames[patchFlag]} */`;
+ } else {
+ const flagNames = Object.keys(shared.PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => shared.PatchFlagNames[n]).join(`, `);
+ vnodePatchFlag = patchFlag + ` /* ${flagNames} */`;
+ }
+ }
+ if (dynamicPropNames && dynamicPropNames.length) {
+ vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
+ }
+ }
+ node.codegenNode = createVNodeCall(
+ context,
+ vnodeTag,
+ vnodeProps,
+ vnodeChildren,
+ vnodePatchFlag,
+ vnodeDynamicProps,
+ vnodeDirectives,
+ !!shouldUseBlock,
+ false,
+ isComponent,
+ node.loc
+ );
+ };
+};
+function resolveComponentType(node, context, ssr = false) {
+ let { tag } = node;
+ const isExplicitDynamic = isComponentTag(tag);
+ const isProp = findProp(node, "is");
+ if (isProp) {
+ if (isExplicitDynamic || isCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context
+ )) {
+ const exp = isProp.type === 6 ? isProp.value && createSimpleExpression(isProp.value.content, true) : isProp.exp;
+ if (exp) {
+ return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
+ exp
+ ]);
+ }
+ } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
+ tag = isProp.value.content.slice(4);
+ }
+ }
+ const isDir = !isExplicitDynamic && findDir(node, "is");
+ if (isDir && isDir.exp) {
+ {
+ context.onWarn(
+ createCompilerError(52, isDir.loc)
+ );
+ }
+ return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
+ isDir.exp
+ ]);
+ }
+ const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
+ if (builtIn) {
+ if (!ssr)
+ context.helper(builtIn);
+ return builtIn;
+ }
+ {
+ const fromSetup = resolveSetupReference(tag, context);
+ if (fromSetup) {
+ return fromSetup;
+ }
+ const dotIndex = tag.indexOf(".");
+ if (dotIndex > 0) {
+ const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
+ if (ns) {
+ return ns + tag.slice(dotIndex);
+ }
+ }
+ }
+ if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) {
+ context.helper(RESOLVE_COMPONENT);
+ context.components.add(tag + `__self`);
+ return toValidAssetId(tag, `component`);
+ }
+ context.helper(RESOLVE_COMPONENT);
+ context.components.add(tag);
+ return toValidAssetId(tag, `component`);
+}
+function resolveSetupReference(name, context) {
+ const bindings = context.bindingMetadata;
+ if (!bindings || bindings.__isScriptSetup === false) {
+ return;
+ }
+ const camelName = shared.camelize(name);
+ const PascalName = shared.capitalize(camelName);
+ const checkType = (type) => {
+ if (bindings[name] === type) {
+ return name;
+ }
+ if (bindings[camelName] === type) {
+ return camelName;
+ }
+ if (bindings[PascalName] === type) {
+ return PascalName;
+ }
+ };
+ const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const");
+ if (fromConst) {
+ return context.inline ? (
+ // in inline mode, const setup bindings (e.g. imports) can be used as-is
+ fromConst
+ ) : `$setup[${JSON.stringify(fromConst)}]`;
+ }
+ const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref");
+ if (fromMaybeRef) {
+ return context.inline ? (
+ // setup scope bindings that may be refs need to be unrefed
+ `${context.helperString(UNREF)}(${fromMaybeRef})`
+ ) : `$setup[${JSON.stringify(fromMaybeRef)}]`;
+ }
+}
+function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
+ const { tag, loc: elementLoc, children } = node;
+ let properties = [];
+ const mergeArgs = [];
+ const runtimeDirectives = [];
+ const hasChildren = children.length > 0;
+ let shouldUseBlock = false;
+ let patchFlag = 0;
+ let hasRef = false;
+ let hasClassBinding = false;
+ let hasStyleBinding = false;
+ let hasHydrationEventBinding = false;
+ let hasDynamicKeys = false;
+ let hasVnodeHook = false;
+ const dynamicPropNames = [];
+ const pushMergeArg = (arg) => {
+ if (properties.length) {
+ mergeArgs.push(
+ createObjectExpression(dedupeProperties(properties), elementLoc)
+ );
+ properties = [];
+ }
+ if (arg)
+ mergeArgs.push(arg);
+ };
+ const analyzePatchFlag = ({ key, value }) => {
+ if (isStaticExp(key)) {
+ const name = key.content;
+ const isEventHandler = shared.isOn(name);
+ if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
+ // dedicated fast path.
+ name.toLowerCase() !== "onclick" && // omit v-model handlers
+ name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
+ !shared.isReservedProp(name)) {
+ hasHydrationEventBinding = true;
+ }
+ if (isEventHandler && shared.isReservedProp(name)) {
+ hasVnodeHook = true;
+ }
+ if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
+ return;
+ }
+ if (name === "ref") {
+ hasRef = true;
+ } else if (name === "class") {
+ hasClassBinding = true;
+ } else if (name === "style") {
+ hasStyleBinding = true;
+ } else if (name !== "key" && !dynamicPropNames.includes(name)) {
+ dynamicPropNames.push(name);
+ }
+ if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
+ dynamicPropNames.push(name);
+ }
+ } else {
+ hasDynamicKeys = true;
+ }
+ };
+ for (let i = 0; i < props.length; i++) {
+ const prop = props[i];
+ if (prop.type === 6) {
+ const { loc, name, value } = prop;
+ let isStatic = true;
+ if (name === "ref") {
+ hasRef = true;
+ if (context.scopes.vFor > 0) {
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression("ref_for", true),
+ createSimpleExpression("true")
+ )
+ );
+ }
+ if (value && context.inline) {
+ const binding = context.bindingMetadata[value.content];
+ if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") {
+ isStatic = false;
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression("ref_key", true),
+ createSimpleExpression(value.content, true, value.loc)
+ )
+ );
+ }
+ }
+ }
+ if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context
+ ))) {
+ continue;
+ }
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression(
+ name,
+ true,
+ getInnerRange(loc, 0, name.length)
+ ),
+ createSimpleExpression(
+ value ? value.content : "",
+ isStatic,
+ value ? value.loc : loc
+ )
+ )
+ );
+ } else {
+ const { name, arg, exp, loc, modifiers } = prop;
+ const isVBind = name === "bind";
+ const isVOn = name === "on";
+ if (name === "slot") {
+ if (!isComponent) {
+ context.onError(
+ createCompilerError(40, loc)
+ );
+ }
+ continue;
+ }
+ if (name === "once" || name === "memo") {
+ continue;
+ }
+ if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context
+ ))) {
+ continue;
+ }
+ if (isVOn && ssr) {
+ continue;
+ }
+ if (
+ // #938: elements with dynamic keys should be forced into blocks
+ isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
+ // before children
+ isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
+ ) {
+ shouldUseBlock = true;
+ }
+ if (isVBind && isStaticArgOf(arg, "ref") && context.scopes.vFor > 0) {
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression("ref_for", true),
+ createSimpleExpression("true")
+ )
+ );
+ }
+ if (!arg && (isVBind || isVOn)) {
+ hasDynamicKeys = true;
+ if (exp) {
+ if (isVBind) {
+ pushMergeArg();
+ {
+ {
+ const hasOverridableKeys = mergeArgs.some((arg2) => {
+ if (arg2.type === 15) {
+ return arg2.properties.some(({ key }) => {
+ if (key.type !== 4 || !key.isStatic) {
+ return true;
+ }
+ return key.content !== "class" && key.content !== "style" && !shared.isOn(key.content);
+ });
+ } else {
+ return true;
+ }
+ });
+ if (hasOverridableKeys) {
+ checkCompatEnabled(
+ "COMPILER_V_BIND_OBJECT_ORDER",
+ context,
+ loc
+ );
+ }
+ }
+ if (isCompatEnabled(
+ "COMPILER_V_BIND_OBJECT_ORDER",
+ context
+ )) {
+ mergeArgs.unshift(exp);
+ continue;
+ }
+ }
+ mergeArgs.push(exp);
+ } else {
+ pushMergeArg({
+ type: 14,
+ loc,
+ callee: context.helper(TO_HANDLERS),
+ arguments: isComponent ? [exp] : [exp, `true`]
+ });
+ }
+ } else {
+ context.onError(
+ createCompilerError(
+ isVBind ? 34 : 35,
+ loc
+ )
+ );
+ }
+ continue;
+ }
+ if (isVBind && modifiers.includes("prop")) {
+ patchFlag |= 32;
+ }
+ const directiveTransform = context.directiveTransforms[name];
+ if (directiveTransform) {
+ const { props: props2, needRuntime } = directiveTransform(prop, node, context);
+ !ssr && props2.forEach(analyzePatchFlag);
+ if (isVOn && arg && !isStaticExp(arg)) {
+ pushMergeArg(createObjectExpression(props2, elementLoc));
+ } else {
+ properties.push(...props2);
+ }
+ if (needRuntime) {
+ runtimeDirectives.push(prop);
+ if (shared.isSymbol(needRuntime)) {
+ directiveImportMap.set(prop, needRuntime);
+ }
+ }
+ } else if (!shared.isBuiltInDirective(name)) {
+ runtimeDirectives.push(prop);
+ if (hasChildren) {
+ shouldUseBlock = true;
+ }
+ }
+ }
+ }
+ let propsExpression = void 0;
+ if (mergeArgs.length) {
+ pushMergeArg();
+ if (mergeArgs.length > 1) {
+ propsExpression = createCallExpression(
+ context.helper(MERGE_PROPS),
+ mergeArgs,
+ elementLoc
+ );
+ } else {
+ propsExpression = mergeArgs[0];
+ }
+ } else if (properties.length) {
+ propsExpression = createObjectExpression(
+ dedupeProperties(properties),
+ elementLoc
+ );
+ }
+ if (hasDynamicKeys) {
+ patchFlag |= 16;
+ } else {
+ if (hasClassBinding && !isComponent) {
+ patchFlag |= 2;
+ }
+ if (hasStyleBinding && !isComponent) {
+ patchFlag |= 4;
+ }
+ if (dynamicPropNames.length) {
+ patchFlag |= 8;
+ }
+ if (hasHydrationEventBinding) {
+ patchFlag |= 32;
+ }
+ }
+ if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
+ patchFlag |= 512;
+ }
+ if (!context.inSSR && propsExpression) {
+ switch (propsExpression.type) {
+ case 15:
+ let classKeyIndex = -1;
+ let styleKeyIndex = -1;
+ let hasDynamicKey = false;
+ for (let i = 0; i < propsExpression.properties.length; i++) {
+ const key = propsExpression.properties[i].key;
+ if (isStaticExp(key)) {
+ if (key.content === "class") {
+ classKeyIndex = i;
+ } else if (key.content === "style") {
+ styleKeyIndex = i;
+ }
+ } else if (!key.isHandlerKey) {
+ hasDynamicKey = true;
+ }
+ }
+ const classProp = propsExpression.properties[classKeyIndex];
+ const styleProp = propsExpression.properties[styleKeyIndex];
+ if (!hasDynamicKey) {
+ if (classProp && !isStaticExp(classProp.value)) {
+ classProp.value = createCallExpression(
+ context.helper(NORMALIZE_CLASS),
+ [classProp.value]
+ );
+ }
+ if (styleProp && // the static style is compiled into an object,
+ // so use `hasStyleBinding` to ensure that it is a dynamic style binding
+ (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
+ // v-bind:style with static literal object
+ styleProp.value.type === 17)) {
+ styleProp.value = createCallExpression(
+ context.helper(NORMALIZE_STYLE),
+ [styleProp.value]
+ );
+ }
+ } else {
+ propsExpression = createCallExpression(
+ context.helper(NORMALIZE_PROPS),
+ [propsExpression]
+ );
+ }
+ break;
+ case 14:
+ break;
+ default:
+ propsExpression = createCallExpression(
+ context.helper(NORMALIZE_PROPS),
+ [
+ createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
+ propsExpression
+ ])
+ ]
+ );
+ break;
+ }
+ }
+ return {
+ props: propsExpression,
+ directives: runtimeDirectives,
+ patchFlag,
+ dynamicPropNames,
+ shouldUseBlock
+ };
+}
+function dedupeProperties(properties) {
+ const knownProps = /* @__PURE__ */ new Map();
+ const deduped = [];
+ for (let i = 0; i < properties.length; i++) {
+ const prop = properties[i];
+ if (prop.key.type === 8 || !prop.key.isStatic) {
+ deduped.push(prop);
+ continue;
+ }
+ const name = prop.key.content;
+ const existing = knownProps.get(name);
+ if (existing) {
+ if (name === "style" || name === "class" || shared.isOn(name)) {
+ mergeAsArray(existing, prop);
+ }
+ } else {
+ knownProps.set(name, prop);
+ deduped.push(prop);
+ }
+ }
+ return deduped;
+}
+function mergeAsArray(existing, incoming) {
+ if (existing.value.type === 17) {
+ existing.value.elements.push(incoming.value);
+ } else {
+ existing.value = createArrayExpression(
+ [existing.value, incoming.value],
+ existing.loc
+ );
+ }
+}
+function buildDirectiveArgs(dir, context) {
+ const dirArgs = [];
+ const runtime = directiveImportMap.get(dir);
+ if (runtime) {
+ dirArgs.push(context.helperString(runtime));
+ } else {
+ const fromSetup = resolveSetupReference("v-" + dir.name, context);
+ if (fromSetup) {
+ dirArgs.push(fromSetup);
+ } else {
+ context.helper(RESOLVE_DIRECTIVE);
+ context.directives.add(dir.name);
+ dirArgs.push(toValidAssetId(dir.name, `directive`));
+ }
+ }
+ const { loc } = dir;
+ if (dir.exp)
+ dirArgs.push(dir.exp);
+ if (dir.arg) {
+ if (!dir.exp) {
+ dirArgs.push(`void 0`);
+ }
+ dirArgs.push(dir.arg);
+ }
+ if (Object.keys(dir.modifiers).length) {
+ if (!dir.arg) {
+ if (!dir.exp) {
+ dirArgs.push(`void 0`);
+ }
+ dirArgs.push(`void 0`);
+ }
+ const trueExpression = createSimpleExpression(`true`, false, loc);
+ dirArgs.push(
+ createObjectExpression(
+ dir.modifiers.map(
+ (modifier) => createObjectProperty(modifier, trueExpression)
+ ),
+ loc
+ )
+ );
+ }
+ return createArrayExpression(dirArgs, dir.loc);
+}
+function stringifyDynamicPropNames(props) {
+ let propsNamesString = `[`;
+ for (let i = 0, l = props.length; i < l; i++) {
+ propsNamesString += JSON.stringify(props[i]);
+ if (i < l - 1)
+ propsNamesString += ", ";
+ }
+ return propsNamesString + `]`;
+}
+function isComponentTag(tag) {
+ return tag === "component" || tag === "Component";
+}
+
+const transformSlotOutlet = (node, context) => {
+ if (isSlotOutlet(node)) {
+ const { children, loc } = node;
+ const { slotName, slotProps } = processSlotOutlet(node, context);
+ const slotArgs = [
+ context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
+ slotName,
+ "{}",
+ "undefined",
+ "true"
+ ];
+ let expectedLen = 2;
+ if (slotProps) {
+ slotArgs[2] = slotProps;
+ expectedLen = 3;
+ }
+ if (children.length) {
+ slotArgs[3] = createFunctionExpression([], children, false, false, loc);
+ expectedLen = 4;
+ }
+ if (context.scopeId && !context.slotted) {
+ expectedLen = 5;
+ }
+ slotArgs.splice(expectedLen);
+ node.codegenNode = createCallExpression(
+ context.helper(RENDER_SLOT),
+ slotArgs,
+ loc
+ );
+ }
+};
+function processSlotOutlet(node, context) {
+ let slotName = `"default"`;
+ let slotProps = void 0;
+ const nonNameProps = [];
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 6) {
+ if (p.value) {
+ if (p.name === "name") {
+ slotName = JSON.stringify(p.value.content);
+ } else {
+ p.name = shared.camelize(p.name);
+ nonNameProps.push(p);
+ }
+ }
+ } else {
+ if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
+ if (p.exp)
+ slotName = p.exp;
+ } else {
+ if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
+ p.arg.content = shared.camelize(p.arg.content);
+ }
+ nonNameProps.push(p);
+ }
+ }
+ }
+ if (nonNameProps.length > 0) {
+ const { props, directives } = buildProps(
+ node,
+ context,
+ nonNameProps,
+ false,
+ false
+ );
+ slotProps = props;
+ if (directives.length) {
+ context.onError(
+ createCompilerError(
+ 36,
+ directives[0].loc
+ )
+ );
+ }
+ }
+ return {
+ slotName,
+ slotProps
+ };
+}
+
+const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+const transformOn = (dir, node, context, augmentor) => {
+ const { loc, modifiers, arg } = dir;
+ if (!dir.exp && !modifiers.length) {
+ context.onError(createCompilerError(35, loc));
+ }
+ let eventName;
+ if (arg.type === 4) {
+ if (arg.isStatic) {
+ let rawName = arg.content;
+ if (rawName.startsWith("vnode")) {
+ context.onWarn(
+ createCompilerError(51, arg.loc)
+ );
+ }
+ if (rawName.startsWith("vue:")) {
+ rawName = `vnode-${rawName.slice(4)}`;
+ }
+ const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
+ // for non-element and vnode lifecycle event listeners, auto convert
+ // it to camelCase. See issue #2249
+ shared.toHandlerKey(shared.camelize(rawName))
+ ) : (
+ // preserve case for plain element listeners that have uppercase
+ // letters, as these may be custom elements' custom events
+ `on:${rawName}`
+ );
+ eventName = createSimpleExpression(eventString, true, arg.loc);
+ } else {
+ eventName = createCompoundExpression([
+ `${context.helperString(TO_HANDLER_KEY)}(`,
+ arg,
+ `)`
+ ]);
+ }
+ } else {
+ eventName = arg;
+ eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
+ eventName.children.push(`)`);
+ }
+ let exp = dir.exp;
+ if (exp && !exp.content.trim()) {
+ exp = void 0;
+ }
+ let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
+ if (exp) {
+ const isMemberExp = isMemberExpression(exp.content, context);
+ const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
+ const hasMultipleStatements = exp.content.includes(`;`);
+ if (context.prefixIdentifiers) {
+ isInlineStatement && context.addIdentifiers(`$event`);
+ exp = dir.exp = processExpression(
+ exp,
+ context,
+ false,
+ hasMultipleStatements
+ );
+ isInlineStatement && context.removeIdentifiers(`$event`);
+ shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once
+ !context.inVOnce && // runtime constants don't need to be cached
+ // (this is analyzed by compileScript in SFC <script setup>)
+ !(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component -
+ // we need to use the original function to preserve arity,
+ // e.g. <transition> relies on checking cb.length to determine
+ // transition end handling. Inline function is ok since its arity
+ // is preserved even when cached.
+ !(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot)
+ // it must be passed fresh to avoid stale values.
+ !hasScopeRef(exp, context.identifiers);
+ if (shouldCache && isMemberExp) {
+ if (exp.type === 4) {
+ exp.content = `${exp.content} && ${exp.content}(...args)`;
+ } else {
+ exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];
+ }
+ }
+ }
+ if (isInlineStatement || shouldCache && isMemberExp) {
+ exp = createCompoundExpression([
+ `${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `
+//@ts-ignore
+` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
+ exp,
+ hasMultipleStatements ? `}` : `)`
+ ]);
+ }
+ }
+ let ret = {
+ props: [
+ createObjectProperty(
+ eventName,
+ exp || createSimpleExpression(`() => {}`, false, loc)
+ )
+ ]
+ };
+ if (augmentor) {
+ ret = augmentor(ret);
+ }
+ if (shouldCache) {
+ ret.props[0].value = context.cache(ret.props[0].value);
+ }
+ ret.props.forEach((p) => p.key.isHandlerKey = true);
+ return ret;
+};
+
+const transformBind = (dir, _node, context) => {
+ const { exp, modifiers, loc } = dir;
+ const arg = dir.arg;
+ if (arg.type !== 4) {
+ arg.children.unshift(`(`);
+ arg.children.push(`) || ""`);
+ } else if (!arg.isStatic) {
+ arg.content = `${arg.content} || ""`;
+ }
+ if (modifiers.includes("camel")) {
+ if (arg.type === 4) {
+ if (arg.isStatic) {
+ arg.content = shared.camelize(arg.content);
+ } else {
+ arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
+ }
+ } else {
+ arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
+ arg.children.push(`)`);
+ }
+ }
+ if (!context.inSSR) {
+ if (modifiers.includes("prop")) {
+ injectPrefix(arg, ".");
+ }
+ if (modifiers.includes("attr")) {
+ injectPrefix(arg, "^");
+ }
+ }
+ if (!exp || exp.type === 4 && !exp.content.trim()) {
+ context.onError(createCompilerError(34, loc));
+ return {
+ props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
+ };
+ }
+ return {
+ props: [createObjectProperty(arg, exp)]
+ };
+};
+const injectPrefix = (arg, prefix) => {
+ if (arg.type === 4) {
+ if (arg.isStatic) {
+ arg.content = prefix + arg.content;
+ } else {
+ arg.content = `\`${prefix}\${${arg.content}}\``;
+ }
+ } else {
+ arg.children.unshift(`'${prefix}' + (`);
+ arg.children.push(`)`);
+ }
+};
+
+const transformText = (node, context) => {
+ if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
+ return () => {
+ const children = node.children;
+ let currentContainer = void 0;
+ let hasText = false;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isText$1(child)) {
+ hasText = true;
+ for (let j = i + 1; j < children.length; j++) {
+ const next = children[j];
+ if (isText$1(next)) {
+ if (!currentContainer) {
+ currentContainer = children[i] = createCompoundExpression(
+ [child],
+ child.loc
+ );
+ }
+ currentContainer.children.push(` + `, next);
+ children.splice(j, 1);
+ j--;
+ } else {
+ currentContainer = void 0;
+ break;
+ }
+ }
+ }
+ }
+ if (!hasText || // if this is a plain element with a single text child, leave it
+ // as-is since the runtime has dedicated fast path for this by directly
+ // setting textContent of the element.
+ // for component root it's always normalized anyway.
+ children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
+ // custom directives can potentially add DOM elements arbitrarily,
+ // we need to avoid setting textContent of the element at runtime
+ // to avoid accidentally overwriting the DOM elements added
+ // by the user through custom directives.
+ !node.props.find(
+ (p) => p.type === 7 && !context.directiveTransforms[p.name]
+ ) && // in compat mode, <template> tags with no special directives
+ // will be rendered as a fragment so its children must be
+ // converted into vnodes.
+ !(node.tag === "template"))) {
+ return;
+ }
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isText$1(child) || child.type === 8) {
+ const callArgs = [];
+ if (child.type !== 2 || child.content !== " ") {
+ callArgs.push(child);
+ }
+ if (!context.ssr && getConstantType(child, context) === 0) {
+ callArgs.push(
+ 1 + (` /* ${shared.PatchFlagNames[1]} */` )
+ );
+ }
+ children[i] = {
+ type: 12,
+ content: child,
+ loc: child.loc,
+ codegenNode: createCallExpression(
+ context.helper(CREATE_TEXT),
+ callArgs
+ )
+ };
+ }
+ }
+ };
+ }
+};
+
+const seen$1 = /* @__PURE__ */ new WeakSet();
+const transformOnce = (node, context) => {
+ if (node.type === 1 && findDir(node, "once", true)) {
+ if (seen$1.has(node) || context.inVOnce || context.inSSR) {
+ return;
+ }
+ seen$1.add(node);
+ context.inVOnce = true;
+ context.helper(SET_BLOCK_TRACKING);
+ return () => {
+ context.inVOnce = false;
+ const cur = context.currentNode;
+ if (cur.codegenNode) {
+ cur.codegenNode = context.cache(
+ cur.codegenNode,
+ true
+ /* isVNode */
+ );
+ }
+ };
+ }
+};
+
+const transformModel = (dir, node, context) => {
+ const { exp, arg } = dir;
+ if (!exp) {
+ context.onError(
+ createCompilerError(41, dir.loc)
+ );
+ return createTransformProps();
+ }
+ const rawExp = exp.loc.source;
+ const expString = exp.type === 4 ? exp.content : rawExp;
+ const bindingType = context.bindingMetadata[rawExp];
+ if (bindingType === "props" || bindingType === "props-aliased") {
+ context.onError(createCompilerError(44, exp.loc));
+ return createTransformProps();
+ }
+ const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
+ if (!expString.trim() || !isMemberExpression(expString, context) && !maybeRef) {
+ context.onError(
+ createCompilerError(42, exp.loc)
+ );
+ return createTransformProps();
+ }
+ if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {
+ context.onError(
+ createCompilerError(43, exp.loc)
+ );
+ return createTransformProps();
+ }
+ const propName = arg ? arg : createSimpleExpression("modelValue", true);
+ const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
+ let assignmentExp;
+ const eventArg = context.isTS ? `($event: any)` : `$event`;
+ if (maybeRef) {
+ if (bindingType === "setup-ref") {
+ assignmentExp = createCompoundExpression([
+ `${eventArg} => ((`,
+ createSimpleExpression(rawExp, false, exp.loc),
+ `).value = $event)`
+ ]);
+ } else {
+ const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`;
+ assignmentExp = createCompoundExpression([
+ `${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,
+ createSimpleExpression(rawExp, false, exp.loc),
+ `).value = $event : ${altAssignment})`
+ ]);
+ }
+ } else {
+ assignmentExp = createCompoundExpression([
+ `${eventArg} => ((`,
+ exp,
+ `) = $event)`
+ ]);
+ }
+ const props = [
+ // modelValue: foo
+ createObjectProperty(propName, dir.exp),
+ // "onUpdate:modelValue": $event => (foo = $event)
+ createObjectProperty(eventName, assignmentExp)
+ ];
+ if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) {
+ props[1].value = context.cache(props[1].value);
+ }
+ if (dir.modifiers.length && node.tagType === 1) {
+ const modifiers = dir.modifiers.map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
+ const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
+ props.push(
+ createObjectProperty(
+ modifiersKey,
+ createSimpleExpression(
+ `{ ${modifiers} }`,
+ false,
+ dir.loc,
+ 2
+ )
+ )
+ );
+ }
+ return createTransformProps(props);
+};
+function createTransformProps(props = []) {
+ return { props };
+}
+
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+const transformFilter = (node, context) => {
+ if (!isCompatEnabled("COMPILER_FILTER", context)) {
+ return;
+ }
+ if (node.type === 5) {
+ rewriteFilter(node.content, context);
+ }
+ if (node.type === 1) {
+ node.props.forEach((prop) => {
+ if (prop.type === 7 && prop.name !== "for" && prop.exp) {
+ rewriteFilter(prop.exp, context);
+ }
+ });
+ }
+};
+function rewriteFilter(node, context) {
+ if (node.type === 4) {
+ parseFilter(node, context);
+ } else {
+ for (let i = 0; i < node.children.length; i++) {
+ const child = node.children[i];
+ if (typeof child !== "object")
+ continue;
+ if (child.type === 4) {
+ parseFilter(child, context);
+ } else if (child.type === 8) {
+ rewriteFilter(node, context);
+ } else if (child.type === 5) {
+ rewriteFilter(child.content, context);
+ }
+ }
+ }
+}
+function parseFilter(node, context) {
+ const exp = node.content;
+ let inSingle = false;
+ let inDouble = false;
+ let inTemplateString = false;
+ let inRegex = false;
+ let curly = 0;
+ let square = 0;
+ let paren = 0;
+ let lastFilterIndex = 0;
+ let c, prev, i, expression, filters = [];
+ for (i = 0; i < exp.length; i++) {
+ prev = c;
+ c = exp.charCodeAt(i);
+ if (inSingle) {
+ if (c === 39 && prev !== 92)
+ inSingle = false;
+ } else if (inDouble) {
+ if (c === 34 && prev !== 92)
+ inDouble = false;
+ } else if (inTemplateString) {
+ if (c === 96 && prev !== 92)
+ inTemplateString = false;
+ } else if (inRegex) {
+ if (c === 47 && prev !== 92)
+ inRegex = false;
+ } else if (c === 124 && // pipe
+ exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
+ if (expression === void 0) {
+ lastFilterIndex = i + 1;
+ expression = exp.slice(0, i).trim();
+ } else {
+ pushFilter();
+ }
+ } else {
+ switch (c) {
+ case 34:
+ inDouble = true;
+ break;
+ case 39:
+ inSingle = true;
+ break;
+ case 96:
+ inTemplateString = true;
+ break;
+ case 40:
+ paren++;
+ break;
+ case 41:
+ paren--;
+ break;
+ case 91:
+ square++;
+ break;
+ case 93:
+ square--;
+ break;
+ case 123:
+ curly++;
+ break;
+ case 125:
+ curly--;
+ break;
+ }
+ if (c === 47) {
+ let j = i - 1;
+ let p;
+ for (; j >= 0; j--) {
+ p = exp.charAt(j);
+ if (p !== " ")
+ break;
+ }
+ if (!p || !validDivisionCharRE.test(p)) {
+ inRegex = true;
+ }
+ }
+ }
+ }
+ if (expression === void 0) {
+ expression = exp.slice(0, i).trim();
+ } else if (lastFilterIndex !== 0) {
+ pushFilter();
+ }
+ function pushFilter() {
+ filters.push(exp.slice(lastFilterIndex, i).trim());
+ lastFilterIndex = i + 1;
+ }
+ if (filters.length) {
+ warnDeprecation(
+ "COMPILER_FILTER",
+ context,
+ node.loc
+ );
+ for (i = 0; i < filters.length; i++) {
+ expression = wrapFilter(expression, filters[i], context);
+ }
+ node.content = expression;
+ }
+}
+function wrapFilter(exp, filter, context) {
+ context.helper(RESOLVE_FILTER);
+ const i = filter.indexOf("(");
+ if (i < 0) {
+ context.filters.add(filter);
+ return `${toValidAssetId(filter, "filter")}(${exp})`;
+ } else {
+ const name = filter.slice(0, i);
+ const args = filter.slice(i + 1);
+ context.filters.add(name);
+ return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
+ }
+}
+
+const seen = /* @__PURE__ */ new WeakSet();
+const transformMemo = (node, context) => {
+ if (node.type === 1) {
+ const dir = findDir(node, "memo");
+ if (!dir || seen.has(node)) {
+ return;
+ }
+ seen.add(node);
+ return () => {
+ const codegenNode = node.codegenNode || context.currentNode.codegenNode;
+ if (codegenNode && codegenNode.type === 13) {
+ if (node.tagType !== 1) {
+ convertToBlock(codegenNode, context);
+ }
+ node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
+ dir.exp,
+ createFunctionExpression(void 0, codegenNode),
+ `_cache`,
+ String(context.cached++)
+ ]);
+ }
+ };
+ }
+};
+
+function getBaseTransformPreset(prefixIdentifiers) {
+ return [
+ [
+ transformOnce,
+ transformIf,
+ transformMemo,
+ transformFor,
+ ...[transformFilter] ,
+ ...prefixIdentifiers ? [
+ // order is important
+ trackVForSlotScopes,
+ transformExpression
+ ] : [],
+ transformSlotOutlet,
+ transformElement,
+ trackSlotScopes,
+ transformText
+ ],
+ {
+ on: transformOn,
+ bind: transformBind,
+ model: transformModel
+ }
+ ];
+}
+function baseCompile(template, options = {}) {
+ const onError = options.onError || defaultOnError;
+ const isModuleMode = options.mode === "module";
+ const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
+ if (!prefixIdentifiers && options.cacheHandlers) {
+ onError(createCompilerError(49));
+ }
+ if (options.scopeId && !isModuleMode) {
+ onError(createCompilerError(50));
+ }
+ const ast = shared.isString(template) ? baseParse(template, options) : template;
+ const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
+ if (options.isTS) {
+ const { expressionPlugins } = options;
+ if (!expressionPlugins || !expressionPlugins.includes("typescript")) {
+ options.expressionPlugins = [...expressionPlugins || [], "typescript"];
+ }
+ }
+ transform(
+ ast,
+ shared.extend({}, options, {
+ prefixIdentifiers,
+ nodeTransforms: [
+ ...nodeTransforms,
+ ...options.nodeTransforms || []
+ // user transforms
+ ],
+ directiveTransforms: shared.extend(
+ {},
+ directiveTransforms,
+ options.directiveTransforms || {}
+ // user transforms
+ )
+ })
+ );
+ return generate(
+ ast,
+ shared.extend({}, options, {
+ prefixIdentifiers
+ })
+ );
+}
+
+const noopDirectiveTransform = () => ({ props: [] });
+
+exports.generateCodeFrame = shared.generateCodeFrame;
+exports.BASE_TRANSITION = BASE_TRANSITION;
+exports.CAMELIZE = CAMELIZE;
+exports.CAPITALIZE = CAPITALIZE;
+exports.CREATE_BLOCK = CREATE_BLOCK;
+exports.CREATE_COMMENT = CREATE_COMMENT;
+exports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK;
+exports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE;
+exports.CREATE_SLOTS = CREATE_SLOTS;
+exports.CREATE_STATIC = CREATE_STATIC;
+exports.CREATE_TEXT = CREATE_TEXT;
+exports.CREATE_VNODE = CREATE_VNODE;
+exports.FRAGMENT = FRAGMENT;
+exports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS;
+exports.IS_MEMO_SAME = IS_MEMO_SAME;
+exports.IS_REF = IS_REF;
+exports.KEEP_ALIVE = KEEP_ALIVE;
+exports.MERGE_PROPS = MERGE_PROPS;
+exports.NORMALIZE_CLASS = NORMALIZE_CLASS;
+exports.NORMALIZE_PROPS = NORMALIZE_PROPS;
+exports.NORMALIZE_STYLE = NORMALIZE_STYLE;
+exports.OPEN_BLOCK = OPEN_BLOCK;
+exports.POP_SCOPE_ID = POP_SCOPE_ID;
+exports.PUSH_SCOPE_ID = PUSH_SCOPE_ID;
+exports.RENDER_LIST = RENDER_LIST;
+exports.RENDER_SLOT = RENDER_SLOT;
+exports.RESOLVE_COMPONENT = RESOLVE_COMPONENT;
+exports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE;
+exports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT;
+exports.RESOLVE_FILTER = RESOLVE_FILTER;
+exports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING;
+exports.SUSPENSE = SUSPENSE;
+exports.TELEPORT = TELEPORT;
+exports.TO_DISPLAY_STRING = TO_DISPLAY_STRING;
+exports.TO_HANDLERS = TO_HANDLERS;
+exports.TO_HANDLER_KEY = TO_HANDLER_KEY;
+exports.TS_NODE_TYPES = TS_NODE_TYPES;
+exports.UNREF = UNREF;
+exports.WITH_CTX = WITH_CTX;
+exports.WITH_DIRECTIVES = WITH_DIRECTIVES;
+exports.WITH_MEMO = WITH_MEMO;
+exports.advancePositionWithClone = advancePositionWithClone;
+exports.advancePositionWithMutation = advancePositionWithMutation;
+exports.assert = assert;
+exports.baseCompile = baseCompile;
+exports.baseParse = baseParse;
+exports.buildDirectiveArgs = buildDirectiveArgs;
+exports.buildProps = buildProps;
+exports.buildSlots = buildSlots;
+exports.checkCompatEnabled = checkCompatEnabled;
+exports.convertToBlock = convertToBlock;
+exports.createArrayExpression = createArrayExpression;
+exports.createAssignmentExpression = createAssignmentExpression;
+exports.createBlockStatement = createBlockStatement;
+exports.createCacheExpression = createCacheExpression;
+exports.createCallExpression = createCallExpression;
+exports.createCompilerError = createCompilerError;
+exports.createCompoundExpression = createCompoundExpression;
+exports.createConditionalExpression = createConditionalExpression;
+exports.createForLoopParams = createForLoopParams;
+exports.createFunctionExpression = createFunctionExpression;
+exports.createIfStatement = createIfStatement;
+exports.createInterpolation = createInterpolation;
+exports.createObjectExpression = createObjectExpression;
+exports.createObjectProperty = createObjectProperty;
+exports.createReturnStatement = createReturnStatement;
+exports.createRoot = createRoot;
+exports.createSequenceExpression = createSequenceExpression;
+exports.createSimpleExpression = createSimpleExpression;
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
+exports.createTemplateLiteral = createTemplateLiteral;
+exports.createTransformContext = createTransformContext;
+exports.createVNodeCall = createVNodeCall;
+exports.extractIdentifiers = extractIdentifiers;
+exports.findDir = findDir;
+exports.findProp = findProp;
+exports.forAliasRE = forAliasRE;
+exports.generate = generate;
+exports.getBaseTransformPreset = getBaseTransformPreset;
+exports.getConstantType = getConstantType;
+exports.getInnerRange = getInnerRange;
+exports.getMemoedVNodeCall = getMemoedVNodeCall;
+exports.getVNodeBlockHelper = getVNodeBlockHelper;
+exports.getVNodeHelper = getVNodeHelper;
+exports.hasDynamicKeyVBind = hasDynamicKeyVBind;
+exports.hasScopeRef = hasScopeRef;
+exports.helperNameMap = helperNameMap;
+exports.injectProp = injectProp;
+exports.isBuiltInType = isBuiltInType;
+exports.isCoreComponent = isCoreComponent;
+exports.isFunctionType = isFunctionType;
+exports.isInDestructureAssignment = isInDestructureAssignment;
+exports.isMemberExpression = isMemberExpression;
+exports.isMemberExpressionBrowser = isMemberExpressionBrowser;
+exports.isMemberExpressionNode = isMemberExpressionNode;
+exports.isReferencedIdentifier = isReferencedIdentifier;
+exports.isSimpleIdentifier = isSimpleIdentifier;
+exports.isSlotOutlet = isSlotOutlet;
+exports.isStaticArgOf = isStaticArgOf;
+exports.isStaticExp = isStaticExp;
+exports.isStaticProperty = isStaticProperty;
+exports.isStaticPropertyKey = isStaticPropertyKey;
+exports.isTemplateNode = isTemplateNode;
+exports.isText = isText$1;
+exports.isVSlot = isVSlot;
+exports.locStub = locStub;
+exports.noopDirectiveTransform = noopDirectiveTransform;
+exports.processExpression = processExpression;
+exports.processFor = processFor;
+exports.processIf = processIf;
+exports.processSlotOutlet = processSlotOutlet;
+exports.registerRuntimeHelpers = registerRuntimeHelpers;
+exports.resolveComponentType = resolveComponentType;
+exports.stringifyExpression = stringifyExpression;
+exports.toValidAssetId = toValidAssetId;
+exports.trackSlotScopes = trackSlotScopes;
+exports.trackVForSlotScopes = trackVForSlotScopes;
+exports.transform = transform;
+exports.transformBind = transformBind;
+exports.transformElement = transformElement;
+exports.transformExpression = transformExpression;
+exports.transformModel = transformModel;
+exports.transformOn = transformOn;
+exports.traverseNode = traverseNode;
+exports.walkBlockDeclarations = walkBlockDeclarations;
+exports.walkFunctionParams = walkFunctionParams;
+exports.walkIdentifiers = walkIdentifiers;
+exports.warnDeprecation = warnDeprecation;
diff --git a/.output/server/node_modules/@vue/compiler-core/dist/compiler-core.cjs.prod.js b/.output/server/node_modules/@vue/compiler-core/dist/compiler-core.cjs.prod.js
new file mode 100644
index 0000000..446fe64
--- /dev/null
+++ b/.output/server/node_modules/@vue/compiler-core/dist/compiler-core.cjs.prod.js
@@ -0,0 +1,5374 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('@vue/shared');
+var parser = require('@babel/parser');
+var sourceMapJs = require('source-map-js');
+var estreeWalker = require('estree-walker');
+
+function defaultOnError(error) {
+ throw error;
+}
+function defaultOnWarn(msg) {
+}
+function createCompilerError(code, loc, messages, additionalMessage) {
+ const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
+ const error = new SyntaxError(String(msg));
+ error.code = code;
+ error.loc = loc;
+ return error;
+}
+const errorMessages = {
+ // parse errors
+ [0]: "Illegal comment.",
+ [1]: "CDATA section is allowed only in XML context.",
+ [2]: "Duplicate attribute.",
+ [3]: "End tag cannot have attributes.",
+ [4]: "Illegal '/' in tags.",
+ [5]: "Unexpected EOF in tag.",
+ [6]: "Unexpected EOF in CDATA section.",
+ [7]: "Unexpected EOF in comment.",
+ [8]: "Unexpected EOF in script.",
+ [9]: "Unexpected EOF in tag.",
+ [10]: "Incorrectly closed comment.",
+ [11]: "Incorrectly opened comment.",
+ [12]: "Illegal tag name. Use '<' to print '<'.",
+ [13]: "Attribute value was expected.",
+ [14]: "End tag name was expected.",
+ [15]: "Whitespace was expected.",
+ [16]: "Unexpected '<!--' in comment.",
+ [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
+ [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
+ [19]: "Attribute name cannot start with '='.",
+ [21]: "'<?' is allowed only in XML context.",
+ [20]: `Unexpected null character.`,
+ [22]: "Illegal '/' in tags.",
+ // Vue-specific parse errors
+ [23]: "Invalid end tag.",
+ [24]: "Element is missing end tag.",
+ [25]: "Interpolation end sign was not found.",
+ [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
+ [26]: "Legal directive name was expected.",
+ // transform errors
+ [28]: `v-if/v-else-if is missing expression.`,
+ [29]: `v-if/else branches must use unique keys.`,
+ [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
+ [31]: `v-for is missing expression.`,
+ [32]: `v-for has invalid expression.`,
+ [33]: `<template v-for> key should be placed on the <template> tag.`,
+ [34]: `v-bind is missing expression.`,
+ [35]: `v-on is missing expression.`,
+ [36]: `Unexpected custom directive on <slot> outlet.`,
+ [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
+ [38]: `Duplicate slot names found. `,
+ [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
+ [40]: `v-slot can only be used on components or <template> tags.`,
+ [41]: `v-model is missing expression.`,
+ [42]: `v-model value must be a valid JavaScript member expression.`,
+ [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
+ [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
+Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+ [45]: `Error parsing JavaScript expression: `,
+ [46]: `<KeepAlive> expects exactly one child component.`,
+ // generic errors
+ [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+ [48]: `ES module mode is not supported in this build of compiler.`,
+ [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+ [50]: `"scopeId" option is only supported in module mode.`,
+ // deprecations
+ [51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
+ [52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
+ // just to fulfill types
+ [53]: ``
+};
+
+const FRAGMENT = Symbol(``);
+const TELEPORT = Symbol(``);
+const SUSPENSE = Symbol(``);
+const KEEP_ALIVE = Symbol(``);
+const BASE_TRANSITION = Symbol(``);
+const OPEN_BLOCK = Symbol(``);
+const CREATE_BLOCK = Symbol(``);
+const CREATE_ELEMENT_BLOCK = Symbol(``);
+const CREATE_VNODE = Symbol(``);
+const CREATE_ELEMENT_VNODE = Symbol(``);
+const CREATE_COMMENT = Symbol(``);
+const CREATE_TEXT = Symbol(``);
+const CREATE_STATIC = Symbol(``);
+const RESOLVE_COMPONENT = Symbol(``);
+const RESOLVE_DYNAMIC_COMPONENT = Symbol(
+ ``
+);
+const RESOLVE_DIRECTIVE = Symbol(``);
+const RESOLVE_FILTER = Symbol(``);
+const WITH_DIRECTIVES = Symbol(``);
+const RENDER_LIST = Symbol(``);
+const RENDER_SLOT = Symbol(``);
+const CREATE_SLOTS = Symbol(``);
+const TO_DISPLAY_STRING = Symbol(``);
+const MERGE_PROPS = Symbol(``);
+const NORMALIZE_CLASS = Symbol(``);
+const NORMALIZE_STYLE = Symbol(``);
+const NORMALIZE_PROPS = Symbol(``);
+const GUARD_REACTIVE_PROPS = Symbol(``);
+const TO_HANDLERS = Symbol(``);
+const CAMELIZE = Symbol(``);
+const CAPITALIZE = Symbol(``);
+const TO_HANDLER_KEY = Symbol(``);
+const SET_BLOCK_TRACKING = Symbol(``);
+const PUSH_SCOPE_ID = Symbol(``);
+const POP_SCOPE_ID = Symbol(``);
+const WITH_CTX = Symbol(``);
+const UNREF = Symbol(``);
+const IS_REF = Symbol(``);
+const WITH_MEMO = Symbol(``);
+const IS_MEMO_SAME = Symbol(``);
+const helperNameMap = {
+ [FRAGMENT]: `Fragment`,
+ [TELEPORT]: `Teleport`,
+ [SUSPENSE]: `Suspense`,
+ [KEEP_ALIVE]: `KeepAlive`,
+ [BASE_TRANSITION]: `BaseTransition`,
+ [OPEN_BLOCK]: `openBlock`,
+ [CREATE_BLOCK]: `createBlock`,
+ [CREATE_ELEMENT_BLOCK]: `createElementBlock`,
+ [CREATE_VNODE]: `createVNode`,
+ [CREATE_ELEMENT_VNODE]: `createElementVNode`,
+ [CREATE_COMMENT]: `createCommentVNode`,
+ [CREATE_TEXT]: `createTextVNode`,
+ [CREATE_STATIC]: `createStaticVNode`,
+ [RESOLVE_COMPONENT]: `resolveComponent`,
+ [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
+ [RESOLVE_DIRECTIVE]: `resolveDirective`,
+ [RESOLVE_FILTER]: `resolveFilter`,
+ [WITH_DIRECTIVES]: `withDirectives`,
+ [RENDER_LIST]: `renderList`,
+ [RENDER_SLOT]: `renderSlot`,
+ [CREATE_SLOTS]: `createSlots`,
+ [TO_DISPLAY_STRING]: `toDisplayString`,
+ [MERGE_PROPS]: `mergeProps`,
+ [NORMALIZE_CLASS]: `normalizeClass`,
+ [NORMALIZE_STYLE]: `normalizeStyle`,
+ [NORMALIZE_PROPS]: `normalizeProps`,
+ [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
+ [TO_HANDLERS]: `toHandlers`,
+ [CAMELIZE]: `camelize`,
+ [CAPITALIZE]: `capitalize`,
+ [TO_HANDLER_KEY]: `toHandlerKey`,
+ [SET_BLOCK_TRACKING]: `setBlockTracking`,
+ [PUSH_SCOPE_ID]: `pushScopeId`,
+ [POP_SCOPE_ID]: `popScopeId`,
+ [WITH_CTX]: `withCtx`,
+ [UNREF]: `unref`,
+ [IS_REF]: `isRef`,
+ [WITH_MEMO]: `withMemo`,
+ [IS_MEMO_SAME]: `isMemoSame`
+};
+function registerRuntimeHelpers(helpers) {
+ Object.getOwnPropertySymbols(helpers).forEach((s) => {
+ helperNameMap[s] = helpers[s];
+ });
+}
+
+const locStub = {
+ source: "",
+ start: { line: 1, column: 1, offset: 0 },
+ end: { line: 1, column: 1, offset: 0 }
+};
+function createRoot(children, loc = locStub) {
+ return {
+ type: 0,
+ children,
+ helpers: /* @__PURE__ */ new Set(),
+ components: [],
+ directives: [],
+ hoists: [],
+ imports: [],
+ cached: 0,
+ temps: 0,
+ codegenNode: void 0,
+ loc
+ };
+}
+function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
+ if (context) {
+ if (isBlock) {
+ context.helper(OPEN_BLOCK);
+ context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
+ } else {
+ context.helper(getVNodeHelper(context.inSSR, isComponent));
+ }
+ if (directives) {
+ context.helper(WITH_DIRECTIVES);
+ }
+ }
+ return {
+ type: 13,
+ tag,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ directives,
+ isBlock,
+ disableTracking,
+ isComponent,
+ loc
+ };
+}
+function createArrayExpression(elements, loc = locStub) {
+ return {
+ type: 17,
+ loc,
+ elements
+ };
+}
+function createObjectExpression(properties, loc = locStub) {
+ return {
+ type: 15,
+ loc,
+ properties
+ };
+}
+function createObjectProperty(key, value) {
+ return {
+ type: 16,
+ loc: locStub,
+ key: shared.isString(key) ? createSimpleExpression(key, true) : key,
+ value
+ };
+}
+function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
+ return {
+ type: 4,
+ loc,
+ content,
+ isStatic,
+ constType: isStatic ? 3 : constType
+ };
+}
+function createInterpolation(content, loc) {
+ return {
+ type: 5,
+ loc,
+ content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content
+ };
+}
+function createCompoundExpression(children, loc = locStub) {
+ return {
+ type: 8,
+ loc,
+ children
+ };
+}
+function createCallExpression(callee, args = [], loc = locStub) {
+ return {
+ type: 14,
+ loc,
+ callee,
+ arguments: args
+ };
+}
+function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
+ return {
+ type: 18,
+ params,
+ returns,
+ newline,
+ isSlot,
+ loc
+ };
+}
+function createConditionalExpression(test, consequent, alternate, newline = true) {
+ return {
+ type: 19,
+ test,
+ consequent,
+ alternate,
+ newline,
+ loc: locStub
+ };
+}
+function createCacheExpression(index, value, isVNode = false) {
+ return {
+ type: 20,
+ index,
+ value,
+ isVNode,
+ loc: locStub
+ };
+}
+function createBlockStatement(body) {
+ return {
+ type: 21,
+ body,
+ loc: locStub
+ };
+}
+function createTemplateLiteral(elements) {
+ return {
+ type: 22,
+ elements,
+ loc: locStub
+ };
+}
+function createIfStatement(test, consequent, alternate) {
+ return {
+ type: 23,
+ test,
+ consequent,
+ alternate,
+ loc: locStub
+ };
+}
+function createAssignmentExpression(left, right) {
+ return {
+ type: 24,
+ left,
+ right,
+ loc: locStub
+ };
+}
+function createSequenceExpression(expressions) {
+ return {
+ type: 25,
+ expressions,
+ loc: locStub
+ };
+}
+function createReturnStatement(returns) {
+ return {
+ type: 26,
+ returns,
+ loc: locStub
+ };
+}
+function getVNodeHelper(ssr, isComponent) {
+ return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
+}
+function getVNodeBlockHelper(ssr, isComponent) {
+ return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
+}
+function convertToBlock(node, { helper, removeHelper, inSSR }) {
+ if (!node.isBlock) {
+ node.isBlock = true;
+ removeHelper(getVNodeHelper(inSSR, node.isComponent));
+ helper(OPEN_BLOCK);
+ helper(getVNodeBlockHelper(inSSR, node.isComponent));
+ }
+}
+
+const isStaticExp = (p) => p.type === 4 && p.isStatic;
+const isBuiltInType = (tag, expected) => tag === expected || tag === shared.hyphenate(expected);
+function isCoreComponent(tag) {
+ if (isBuiltInType(tag, "Teleport")) {
+ return TELEPORT;
+ } else if (isBuiltInType(tag, "Suspense")) {
+ return SUSPENSE;
+ } else if (isBuiltInType(tag, "KeepAlive")) {
+ return KEEP_ALIVE;
+ } else if (isBuiltInType(tag, "BaseTransition")) {
+ return BASE_TRANSITION;
+ }
+}
+const nonIdentifierRE = /^\d|[^\$\w]/;
+const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
+const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
+const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
+const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
+const isMemberExpressionBrowser = (path) => {
+ path = path.trim().replace(whitespaceRE, (s) => s.trim());
+ let state = 0 /* inMemberExp */;
+ let stateStack = [];
+ let currentOpenBracketCount = 0;
+ let currentOpenParensCount = 0;
+ let currentStringType = null;
+ for (let i = 0; i < path.length; i++) {
+ const char = path.charAt(i);
+ switch (state) {
+ case 0 /* inMemberExp */:
+ if (char === "[") {
+ stateStack.push(state);
+ state = 1 /* inBrackets */;
+ currentOpenBracketCount++;
+ } else if (char === "(") {
+ stateStack.push(state);
+ state = 2 /* inParens */;
+ currentOpenParensCount++;
+ } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
+ return false;
+ }
+ break;
+ case 1 /* inBrackets */:
+ if (char === `'` || char === `"` || char === "`") {
+ stateStack.push(state);
+ state = 3 /* inString */;
+ currentStringType = char;
+ } else if (char === `[`) {
+ currentOpenBracketCount++;
+ } else if (char === `]`) {
+ if (!--currentOpenBracketCount) {
+ state = stateStack.pop();
+ }
+ }
+ break;
+ case 2 /* inParens */:
+ if (char === `'` || char === `"` || char === "`") {
+ stateStack.push(state);
+ state = 3 /* inString */;
+ currentStringType = char;
+ } else if (char === `(`) {
+ currentOpenParensCount++;
+ } else if (char === `)`) {
+ if (i === path.length - 1) {
+ return false;
+ }
+ if (!--currentOpenParensCount) {
+ state = stateStack.pop();
+ }
+ }
+ break;
+ case 3 /* inString */:
+ if (char === currentStringType) {
+ state = stateStack.pop();
+ currentStringType = null;
+ }
+ break;
+ }
+ }
+ return !currentOpenBracketCount && !currentOpenParensCount;
+};
+const isMemberExpressionNode = (path, context) => {
+ try {
+ let ret = parser.parseExpression(path, {
+ plugins: context.expressionPlugins
+ });
+ if (ret.type === "TSAsExpression" || ret.type === "TSTypeAssertion") {
+ ret = ret.expression;
+ }
+ return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier";
+ } catch (e) {
+ return false;
+ }
+};
+const isMemberExpression = isMemberExpressionNode;
+function getInnerRange(loc, offset, length) {
+ const source = loc.source.slice(offset, offset + length);
+ const newLoc = {
+ source,
+ start: advancePositionWithClone(loc.start, loc.source, offset),
+ end: loc.end
+ };
+ if (length != null) {
+ newLoc.end = advancePositionWithClone(
+ loc.start,
+ loc.source,
+ offset + length
+ );
+ }
+ return newLoc;
+}
+function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
+ return advancePositionWithMutation(
+ shared.extend({}, pos),
+ source,
+ numberOfCharacters
+ );
+}
+function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
+ let linesCount = 0;
+ let lastNewLinePos = -1;
+ for (let i = 0; i < numberOfCharacters; i++) {
+ if (source.charCodeAt(i) === 10) {
+ linesCount++;
+ lastNewLinePos = i;
+ }
+ }
+ pos.offset += numberOfCharacters;
+ pos.line += linesCount;
+ pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
+ return pos;
+}
+function assert(condition, msg) {
+ if (!condition) {
+ throw new Error(msg || `unexpected compiler condition`);
+ }
+}
+function findDir(node, name, allowEmpty = false) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) {
+ return p;
+ }
+ }
+}
+function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 6) {
+ if (dynamicOnly)
+ continue;
+ if (p.name === name && (p.value || allowEmpty)) {
+ return p;
+ }
+ } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
+ return p;
+ }
+ }
+}
+function isStaticArgOf(arg, name) {
+ return !!(arg && isStaticExp(arg) && arg.content === name);
+}
+function hasDynamicKeyVBind(node) {
+ return node.props.some(
+ (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
+ p.arg.type !== 4 || // v-bind:[_ctx.foo]
+ !p.arg.isStatic)
+ // v-bind:[foo]
+ );
+}
+function isText$1(node) {
+ return node.type === 5 || node.type === 2;
+}
+function isVSlot(p) {
+ return p.type === 7 && p.name === "slot";
+}
+function isTemplateNode(node) {
+ return node.type === 1 && node.tagType === 3;
+}
+function isSlotOutlet(node) {
+ return node.type === 1 && node.tagType === 2;
+}
+const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
+function getUnnormalizedProps(props, callPath = []) {
+ if (props && !shared.isString(props) && props.type === 14) {
+ const callee = props.callee;
+ if (!shared.isString(callee) && propsHelperSet.has(callee)) {
+ return getUnnormalizedProps(
+ props.arguments[0],
+ callPath.concat(props)
+ );
+ }
+ }
+ return [props, callPath];
+}
+function injectProp(node, prop, context) {
+ let propsWithInjection;
+ let props = node.type === 13 ? node.props : node.arguments[2];
+ let callPath = [];
+ let parentCall;
+ if (props && !shared.isString(props) && props.type === 14) {
+ const ret = getUnnormalizedProps(props);
+ props = ret[0];
+ callPath = ret[1];
+ parentCall = callPath[callPath.length - 1];
+ }
+ if (props == null || shared.isString(props)) {
+ propsWithInjection = createObjectExpression([prop]);
+ } else if (props.type === 14) {
+ const first = props.arguments[0];
+ if (!shared.isString(first) && first.type === 15) {
+ if (!hasProp(prop, first)) {
+ first.properties.unshift(prop);
+ }
+ } else {
+ if (props.callee === TO_HANDLERS) {
+ propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+ createObjectExpression([prop]),
+ props
+ ]);
+ } else {
+ props.arguments.unshift(createObjectExpression([prop]));
+ }
+ }
+ !propsWithInjection && (propsWithInjection = props);
+ } else if (props.type === 15) {
+ if (!hasProp(prop, props)) {
+ props.properties.unshift(prop);
+ }
+ propsWithInjection = props;
+ } else {
+ propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+ createObjectExpression([prop]),
+ props
+ ]);
+ if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
+ parentCall = callPath[callPath.length - 2];
+ }
+ }
+ if (node.type === 13) {
+ if (parentCall) {
+ parentCall.arguments[0] = propsWithInjection;
+ } else {
+ node.props = propsWithInjection;
+ }
+ } else {
+ if (parentCall) {
+ parentCall.arguments[0] = propsWithInjection;
+ } else {
+ node.arguments[2] = propsWithInjection;
+ }
+ }
+}
+function hasProp(prop, props) {
+ let result = false;
+ if (prop.key.type === 4) {
+ const propKeyName = prop.key.content;
+ result = props.properties.some(
+ (p) => p.key.type === 4 && p.key.content === propKeyName
+ );
+ }
+ return result;
+}
+function toValidAssetId(name, type) {
+ return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+ return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+ })}`;
+}
+function hasScopeRef(node, ids) {
+ if (!node || Object.keys(ids).length === 0) {
+ return false;
+ }
+ switch (node.type) {
+ case 1:
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
+ return true;
+ }
+ }
+ return node.children.some((c) => hasScopeRef(c, ids));
+ case 11:
+ if (hasScopeRef(node.source, ids)) {
+ return true;
+ }
+ return node.children.some((c) => hasScopeRef(c, ids));
+ case 9:
+ return node.branches.some((b) => hasScopeRef(b, ids));
+ case 10:
+ if (hasScopeRef(node.condition, ids)) {
+ return true;
+ }
+ return node.children.some((c) => hasScopeRef(c, ids));
+ case 4:
+ return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
+ case 8:
+ return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids));
+ case 5:
+ case 12:
+ return hasScopeRef(node.content, ids);
+ case 2:
+ case 3:
+ return false;
+ default:
+ return false;
+ }
+}
+function getMemoedVNodeCall(node) {
+ if (node.type === 14 && node.callee === WITH_MEMO) {
+ return node.arguments[1].returns;
+ } else {
+ return node;
+ }
+}
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+
+const deprecationData = {
+ ["COMPILER_IS_ON_ELEMENT"]: {
+ message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
+ },
+ ["COMPILER_V_BIND_SYNC"]: {
+ message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
+ },
+ ["COMPILER_V_BIND_PROP"]: {
+ message: `.prop modifier for v-bind has been removed and no longer necessary. Vue 3 will automatically set a binding as DOM property when appropriate.`
+ },
+ ["COMPILER_V_BIND_OBJECT_ORDER"]: {
+ message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
+ },
+ ["COMPILER_V_ON_NATIVE"]: {
+ message: `.native modifier for v-on has been removed as is no longer necessary.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
+ },
+ ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
+ message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
+ },
+ ["COMPILER_NATIVE_TEMPLATE"]: {
+ message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
+ },
+ ["COMPILER_INLINE_TEMPLATE"]: {
+ message: `"inline-template" has been removed in Vue 3.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
+ },
+ ["COMPILER_FILTER"]: {
+ message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
+ link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
+ }
+};
+function getCompatValue(key, context) {
+ const config = context.options ? context.options.compatConfig : context.compatConfig;
+ const value = config && config[key];
+ if (key === "MODE") {
+ return value || 3;
+ } else {
+ return value;
+ }
+}
+function isCompatEnabled(key, context) {
+ const mode = getCompatValue("MODE", context);
+ const value = getCompatValue(key, context);
+ return mode === 3 ? value === true : value !== false;
+}
+function checkCompatEnabled(key, context, loc, ...args) {
+ const enabled = isCompatEnabled(key, context);
+ return enabled;
+}
+function warnDeprecation(key, context, loc, ...args) {
+ const val = getCompatValue(key, context);
+ if (val === "suppress-warning") {
+ return;
+ }
+ const { message, link } = deprecationData[key];
+ const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
+ Details: ${link}` : ``}`;
+ const err = new SyntaxError(msg);
+ err.code = key;
+ if (loc)
+ err.loc = loc;
+ context.onWarn(err);
+}
+
+const decodeRE = /&(gt|lt|amp|apos|quot);/g;
+const decodeMap = {
+ gt: ">",
+ lt: "<",
+ amp: "&",
+ apos: "'",
+ quot: '"'
+};
+const defaultParserOptions = {
+ delimiters: [`{{`, `}}`],
+ getNamespace: () => 0,
+ getTextMode: () => 0,
+ isVoidTag: shared.NO,
+ isPreTag: shared.NO,
+ isCustomElement: shared.NO,
+ decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),
+ onError: defaultOnError,
+ onWarn: defaultOnWarn,
+ comments: false
+};
+function baseParse(content, options = {}) {
+ const context = createParserContext(content, options);
+ const start = getCursor(context);
+ return createRoot(
+ parseChildren(context, 0, []),
+ getSelection(context, start)
+ );
+}
+function createParserContext(content, rawOptions) {
+ const options = shared.extend({}, defaultParserOptions);
+ let key;
+ for (key in rawOptions) {
+ options[key] = rawOptions[key] === void 0 ? defaultParserOptions[key] : rawOptions[key];
+ }
+ return {
+ options,
+ column: 1,
+ line: 1,
+ offset: 0,
+ originalSource: content,
+ source: content,
+ inPre: false,
+ inVPre: false,
+ onWarn: options.onWarn
+ };
+}
+function parseChildren(context, mode, ancestors) {
+ const parent = last(ancestors);
+ const ns = parent ? parent.ns : 0;
+ const nodes = [];
+ while (!isEnd(context, mode, ancestors)) {
+ const s = context.source;
+ let node = void 0;
+ if (mode === 0 || mode === 1) {
+ if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {
+ node = parseInterpolation(context, mode);
+ } else if (mode === 0 && s[0] === "<") {
+ if (s.length === 1) {
+ emitError(context, 5, 1);
+ } else if (s[1] === "!") {
+ if (startsWith(s, "<!--")) {
+ node = parseComment(context);
+ } else if (startsWith(s, "<!DOCTYPE")) {
+ node = parseBogusComment(context);
+ } else if (startsWith(s, "<![CDATA[")) {
+ if (ns !== 0) {
+ node = parseCDATA(context, ancestors);
+ } else {
+ emitError(context, 1);
+ node = parseBogusComment(context);
+ }
+ } else {
+ emitError(context, 11);
+ node = parseBogusComment(context);
+ }
+ } else if (s[1] === "/") {
+ if (s.length === 2) {
+ emitError(context, 5, 2);
+ } else if (s[2] === ">") {
+ emitError(context, 14, 2);
+ advanceBy(context, 3);
+ continue;
+ } else if (/[a-z]/i.test(s[2])) {
+ emitError(context, 23);
+ parseTag(context, 1 /* End */, parent);
+ continue;
+ } else {
+ emitError(
+ context,
+ 12,
+ 2
+ );
+ node = parseBogusComment(context);
+ }
+ } else if (/[a-z]/i.test(s[1])) {
+ node = parseElement(context, ancestors);
+ if (isCompatEnabled(
+ "COMPILER_NATIVE_TEMPLATE",
+ context
+ ) && node && node.tag === "template" && !node.props.some(
+ (p) => p.type === 7 && isSpecialTemplateDirective(p.name)
+ )) {
+ node = node.children;
+ }
+ } else if (s[1] === "?") {
+ emitError(
+ context,
+ 21,
+ 1
+ );
+ node = parseBogusComment(context);
+ } else {
+ emitError(context, 12, 1);
+ }
+ }
+ }
+ if (!node) {
+ node = parseText(context, mode);
+ }
+ if (shared.isArray(node)) {
+ for (let i = 0; i < node.length; i++) {
+ pushNode(nodes, node[i]);
+ }
+ } else {
+ pushNode(nodes, node);
+ }
+ }
+ let removedWhitespace = false;
+ if (mode !== 2 && mode !== 1) {
+ const shouldCondense = context.options.whitespace !== "preserve";
+ for (let i = 0; i < nodes.length; i++) {
+ const node = nodes[i];
+ if (node.type === 2) {
+ if (!context.inPre) {
+ if (!/[^\t\r\n\f ]/.test(node.content)) {
+ const prev = nodes[i - 1];
+ const next = nodes[i + 1];
+ if (!prev || !next || shouldCondense && (prev.type === 3 && next.type === 3 || prev.type === 3 && next.type === 1 || prev.type === 1 && next.type === 3 || prev.type === 1 && next.type === 1 && /[\r\n]/.test(node.content))) {
+ removedWhitespace = true;
+ nodes[i] = null;
+ } else {
+ node.content = " ";
+ }
+ } else if (shouldCondense) {
+ node.content = node.content.replace(/[\t\r\n\f ]+/g, " ");
+ }
+ } else {
+ node.content = node.content.replace(/\r\n/g, "\n");
+ }
+ } else if (node.type === 3 && !context.options.comments) {
+ removedWhitespace = true;
+ nodes[i] = null;
+ }
+ }
+ if (context.inPre && parent && context.options.isPreTag(parent.tag)) {
+ const first = nodes[0];
+ if (first && first.type === 2) {
+ first.content = first.content.replace(/^\r?\n/, "");
+ }
+ }
+ }
+ return removedWhitespace ? nodes.filter(Boolean) : nodes;
+}
+function pushNode(nodes, node) {
+ if (node.type === 2) {
+ const prev = last(nodes);
+ if (prev && prev.type === 2 && prev.loc.end.offset === node.loc.start.offset) {
+ prev.content += node.content;
+ prev.loc.end = node.loc.end;
+ prev.loc.source += node.loc.source;
+ return;
+ }
+ }
+ nodes.push(node);
+}
+function parseCDATA(context, ancestors) {
+ advanceBy(context, 9);
+ const nodes = parseChildren(context, 3, ancestors);
+ if (context.source.length === 0) {
+ emitError(context, 6);
+ } else {
+ advanceBy(context, 3);
+ }
+ return nodes;
+}
+function parseComment(context) {
+ const start = getCursor(context);
+ let content;
+ const match = /--(\!)?>/.exec(context.source);
+ if (!match) {
+ content = context.source.slice(4);
+ advanceBy(context, context.source.length);
+ emitError(context, 7);
+ } else {
+ if (match.index <= 3) {
+ emitError(context, 0);
+ }
+ if (match[1]) {
+ emitError(context, 10);
+ }
+ content = context.source.slice(4, match.index);
+ const s = context.source.slice(0, match.index);
+ let prevIndex = 1, nestedIndex = 0;
+ while ((nestedIndex = s.indexOf("<!--", prevIndex)) !== -1) {
+ advanceBy(context, nestedIndex - prevIndex + 1);
+ if (nestedIndex + 4 < s.length) {
+ emitError(context, 16);
+ }
+ prevIndex = nestedIndex + 1;
+ }
+ advanceBy(context, match.index + match[0].length - prevIndex + 1);
+ }
+ return {
+ type: 3,
+ content,
+ loc: getSelection(context, start)
+ };
+}
+function parseBogusComment(context) {
+ const start = getCursor(context);
+ const contentStart = context.source[1] === "?" ? 1 : 2;
+ let content;
+ const closeIndex = context.source.indexOf(">");
+ if (closeIndex === -1) {
+ content = context.source.slice(contentStart);
+ advanceBy(context, context.source.length);
+ } else {
+ content = context.source.slice(contentStart, closeIndex);
+ advanceBy(context, closeIndex + 1);
+ }
+ return {
+ type: 3,
+ content,
+ loc: getSelection(context, start)
+ };
+}
+function parseElement(context, ancestors) {
+ const wasInPre = context.inPre;
+ const wasInVPre = context.inVPre;
+ const parent = last(ancestors);
+ const element = parseTag(context, 0 /* Start */, parent);
+ const isPreBoundary = context.inPre && !wasInPre;
+ const isVPreBoundary = context.inVPre && !wasInVPre;
+ if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
+ if (isPreBoundary) {
+ context.inPre = false;
+ }
+ if (isVPreBoundary) {
+ context.inVPre = false;
+ }
+ return element;
+ }
+ ancestors.push(element);
+ const mode = context.options.getTextMode(element, parent);
+ const children = parseChildren(context, mode, ancestors);
+ ancestors.pop();
+ {
+ const inlineTemplateProp = element.props.find(
+ (p) => p.type === 6 && p.name === "inline-template"
+ );
+ if (inlineTemplateProp && checkCompatEnabled(
+ "COMPILER_INLINE_TEMPLATE",
+ context,
+ inlineTemplateProp.loc
+ )) {
+ const loc = getSelection(context, element.loc.end);
+ inlineTemplateProp.value = {
+ type: 2,
+ content: loc.source,
+ loc
+ };
+ }
+ }
+ element.children = children;
+ if (startsWithEndTagOpen(context.source, element.tag)) {
+ parseTag(context, 1 /* End */, parent);
+ } else {
+ emitError(context, 24, 0, element.loc.start);
+ if (context.source.length === 0 && element.tag.toLowerCase() === "script") {
+ const first = children[0];
+ if (first && startsWith(first.loc.source, "<!--")) {
+ emitError(context, 8);
+ }
+ }
+ }
+ element.loc = getSelection(context, element.loc.start);
+ if (isPreBoundary) {
+ context.inPre = false;
+ }
+ if (isVPreBoundary) {
+ context.inVPre = false;
+ }
+ return element;
+}
+const isSpecialTemplateDirective = /* @__PURE__ */ shared.makeMap(
+ `if,else,else-if,for,slot`
+);
+function parseTag(context, type, parent) {
+ const start = getCursor(context);
+ const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source);
+ const tag = match[1];
+ const ns = context.options.getNamespace(tag, parent);
+ advanceBy(context, match[0].length);
+ advanceSpaces(context);
+ const cursor = getCursor(context);
+ const currentSource = context.source;
+ if (context.options.isPreTag(tag)) {
+ context.inPre = true;
+ }
+ let props = parseAttributes(context, type);
+ if (type === 0 /* Start */ && !context.inVPre && props.some((p) => p.type === 7 && p.name === "pre")) {
+ context.inVPre = true;
+ shared.extend(context, cursor);
+ context.source = currentSource;
+ props = parseAttributes(context, type).filter((p) => p.name !== "v-pre");
+ }
+ let isSelfClosing = false;
+ if (context.source.length === 0) {
+ emitError(context, 9);
+ } else {
+ isSelfClosing = startsWith(context.source, "/>");
+ if (type === 1 /* End */ && isSelfClosing) {
+ emitError(context, 4);
+ }
+ advanceBy(context, isSelfClosing ? 2 : 1);
+ }
+ if (type === 1 /* End */) {
+ return;
+ }
+ let tagType = 0;
+ if (!context.inVPre) {
+ if (tag === "slot") {
+ tagType = 2;
+ } else if (tag === "template") {
+ if (props.some(
+ (p) => p.type === 7 && isSpecialTemplateDirective(p.name)
+ )) {
+ tagType = 3;
+ }
+ } else if (isComponent(tag, props, context)) {
+ tagType = 1;
+ }
+ }
+ return {
+ type: 1,
+ ns,
+ tag,
+ tagType,
+ props,
+ isSelfClosing,
+ children: [],
+ loc: getSelection(context, start),
+ codegenNode: void 0
+ // to be created during transform phase
+ };
+}
+function isComponent(tag, props, context) {
+ const options = context.options;
+ if (options.isCustomElement(tag)) {
+ return false;
+ }
+ if (tag === "component" || /^[A-Z]/.test(tag) || isCoreComponent(tag) || options.isBuiltInComponent && options.isBuiltInComponent(tag) || options.isNativeTag && !options.isNativeTag(tag)) {
+ return true;
+ }
+ for (let i = 0; i < props.length; i++) {
+ const p = props[i];
+ if (p.type === 6) {
+ if (p.name === "is" && p.value) {
+ if (p.value.content.startsWith("vue:")) {
+ return true;
+ } else if (checkCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context,
+ p.loc
+ )) {
+ return true;
+ }
+ }
+ } else {
+ if (p.name === "is") {
+ return true;
+ } else if (
+ // :is on plain element - only treat as component in compat mode
+ p.name === "bind" && isStaticArgOf(p.arg, "is") && true && checkCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context,
+ p.loc
+ )
+ ) {
+ return true;
+ }
+ }
+ }
+}
+function parseAttributes(context, type) {
+ const props = [];
+ const attributeNames = /* @__PURE__ */ new Set();
+ while (context.source.length > 0 && !startsWith(context.source, ">") && !startsWith(context.source, "/>")) {
+ if (startsWith(context.source, "/")) {
+ emitError(context, 22);
+ advanceBy(context, 1);
+ advanceSpaces(context);
+ continue;
+ }
+ if (type === 1 /* End */) {
+ emitError(context, 3);
+ }
+ const attr = parseAttribute(context, attributeNames);
+ if (attr.type === 6 && attr.value && attr.name === "class") {
+ attr.value.content = attr.value.content.replace(/\s+/g, " ").trim();
+ }
+ if (type === 0 /* Start */) {
+ props.push(attr);
+ }
+ if (/^[^\t\r\n\f />]/.test(context.source)) {
+ emitError(context, 15);
+ }
+ advanceSpaces(context);
+ }
+ return props;
+}
+function parseAttribute(context, nameSet) {
+ var _a;
+ const start = getCursor(context);
+ const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source);
+ const name = match[0];
+ if (nameSet.has(name)) {
+ emitError(context, 2);
+ }
+ nameSet.add(name);
+ if (name[0] === "=") {
+ emitError(context, 19);
+ }
+ {
+ const pattern = /["'<]/g;
+ let m;
+ while (m = pattern.exec(name)) {
+ emitError(
+ context,
+ 17,
+ m.index
+ );
+ }
+ }
+ advanceBy(context, name.length);
+ let value = void 0;
+ if (/^[\t\r\n\f ]*=/.test(context.source)) {
+ advanceSpaces(context);
+ advanceBy(context, 1);
+ advanceSpaces(context);
+ value = parseAttributeValue(context);
+ if (!value) {
+ emitError(context, 13);
+ }
+ }
+ const loc = getSelection(context, start);
+ if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(name)) {
+ const match2 = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(
+ name
+ );
+ let isPropShorthand = startsWith(name, ".");
+ let dirName = match2[1] || (isPropShorthand || startsWith(name, ":") ? "bind" : startsWith(name, "@") ? "on" : "slot");
+ let arg;
+ if (match2[2]) {
+ const isSlot = dirName === "slot";
+ const startOffset = name.lastIndexOf(
+ match2[2],
+ name.length - (((_a = match2[3]) == null ? void 0 : _a.length) || 0)
+ );
+ const loc2 = getSelection(
+ context,
+ getNewPosition(context, start, startOffset),
+ getNewPosition(
+ context,
+ start,
+ startOffset + match2[2].length + (isSlot && match2[3] || "").length
+ )
+ );
+ let content = match2[2];
+ let isStatic = true;
+ if (content.startsWith("[")) {
+ isStatic = false;
+ if (!content.endsWith("]")) {
+ emitError(
+ context,
+ 27
+ );
+ content = content.slice(1);
+ } else {
+ content = content.slice(1, content.length - 1);
+ }
+ } else if (isSlot) {
+ content += match2[3] || "";
+ }
+ arg = {
+ type: 4,
+ content,
+ isStatic,
+ constType: isStatic ? 3 : 0,
+ loc: loc2
+ };
+ }
+ if (value && value.isQuoted) {
+ const valueLoc = value.loc;
+ valueLoc.start.offset++;
+ valueLoc.start.column++;
+ valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);
+ valueLoc.source = valueLoc.source.slice(1, -1);
+ }
+ const modifiers = match2[3] ? match2[3].slice(1).split(".") : [];
+ if (isPropShorthand)
+ modifiers.push("prop");
+ if (dirName === "bind" && arg) {
+ if (modifiers.includes("sync") && checkCompatEnabled(
+ "COMPILER_V_BIND_SYNC",
+ context,
+ loc,
+ arg.loc.source
+ )) {
+ dirName = "model";
+ modifiers.splice(modifiers.indexOf("sync"), 1);
+ }
+ }
+ return {
+ type: 7,
+ name: dirName,
+ exp: value && {
+ type: 4,
+ content: value.content,
+ isStatic: false,
+ // Treat as non-constant by default. This can be potentially set to
+ // other values by `transformExpression` to make it eligible for hoisting.
+ constType: 0,
+ loc: value.loc
+ },
+ arg,
+ modifiers,
+ loc
+ };
+ }
+ if (!context.inVPre && startsWith(name, "v-")) {
+ emitError(context, 26);
+ }
+ return {
+ type: 6,
+ name,
+ value: value && {
+ type: 2,
+ content: value.content,
+ loc: value.loc
+ },
+ loc
+ };
+}
+function parseAttributeValue(context) {
+ const start = getCursor(context);
+ let content;
+ const quote = context.source[0];
+ const isQuoted = quote === `"` || quote === `'`;
+ if (isQuoted) {
+ advanceBy(context, 1);
+ const endIndex = context.source.indexOf(quote);
+ if (endIndex === -1) {
+ content = parseTextData(
+ context,
+ context.source.length,
+ 4
+ );
+ } else {
+ content = parseTextData(context, endIndex, 4);
+ advanceBy(context, 1);
+ }
+ } else {
+ const match = /^[^\t\r\n\f >]+/.exec(context.source);
+ if (!match) {
+ return void 0;
+ }
+ const unexpectedChars = /["'<=`]/g;
+ let m;
+ while (m = unexpectedChars.exec(match[0])) {
+ emitError(
+ context,
+ 18,
+ m.index
+ );
+ }
+ content = parseTextData(context, match[0].length, 4);
+ }
+ return { content, isQuoted, loc: getSelection(context, start) };
+}
+function parseInterpolation(context, mode) {
+ const [open, close] = context.options.delimiters;
+ const closeIndex = context.source.indexOf(close, open.length);
+ if (closeIndex === -1) {
+ emitError(context, 25);
+ return void 0;
+ }
+ const start = getCursor(context);
+ advanceBy(context, open.length);
+ const innerStart = getCursor(context);
+ const innerEnd = getCursor(context);
+ const rawContentLength = closeIndex - open.length;
+ const rawContent = context.source.slice(0, rawContentLength);
+ const preTrimContent = parseTextData(context, rawContentLength, mode);
+ const content = preTrimContent.trim();
+ const startOffset = preTrimContent.indexOf(content);
+ if (startOffset > 0) {
+ advancePositionWithMutation(innerStart, rawContent, startOffset);
+ }
+ const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);
+ advancePositionWithMutation(innerEnd, rawContent, endOffset);
+ advanceBy(context, close.length);
+ return {
+ type: 5,
+ content: {
+ type: 4,
+ isStatic: false,
+ // Set `isConstant` to false by default and will decide in transformExpression
+ constType: 0,
+ content,
+ loc: getSelection(context, innerStart, innerEnd)
+ },
+ loc: getSelection(context, start)
+ };
+}
+function parseText(context, mode) {
+ const endTokens = mode === 3 ? ["]]>"] : ["<", context.options.delimiters[0]];
+ let endIndex = context.source.length;
+ for (let i = 0; i < endTokens.length; i++) {
+ const index = context.source.indexOf(endTokens[i], 1);
+ if (index !== -1 && endIndex > index) {
+ endIndex = index;
+ }
+ }
+ const start = getCursor(context);
+ const content = parseTextData(context, endIndex, mode);
+ return {
+ type: 2,
+ content,
+ loc: getSelection(context, start)
+ };
+}
+function parseTextData(context, length, mode) {
+ const rawText = context.source.slice(0, length);
+ advanceBy(context, length);
+ if (mode === 2 || mode === 3 || !rawText.includes("&")) {
+ return rawText;
+ } else {
+ return context.options.decodeEntities(
+ rawText,
+ mode === 4
+ );
+ }
+}
+function getCursor(context) {
+ const { column, line, offset } = context;
+ return { column, line, offset };
+}
+function getSelection(context, start, end) {
+ end = end || getCursor(context);
+ return {
+ start,
+ end,
+ source: context.originalSource.slice(start.offset, end.offset)
+ };
+}
+function last(xs) {
+ return xs[xs.length - 1];
+}
+function startsWith(source, searchString) {
+ return source.startsWith(searchString);
+}
+function advanceBy(context, numberOfCharacters) {
+ const { source } = context;
+ advancePositionWithMutation(context, source, numberOfCharacters);
+ context.source = source.slice(numberOfCharacters);
+}
+function advanceSpaces(context) {
+ const match = /^[\t\r\n\f ]+/.exec(context.source);
+ if (match) {
+ advanceBy(context, match[0].length);
+ }
+}
+function getNewPosition(context, start, numberOfCharacters) {
+ return advancePositionWithClone(
+ start,
+ context.originalSource.slice(start.offset, numberOfCharacters),
+ numberOfCharacters
+ );
+}
+function emitError(context, code, offset, loc = getCursor(context)) {
+ if (offset) {
+ loc.offset += offset;
+ loc.column += offset;
+ }
+ context.options.onError(
+ createCompilerError(code, {
+ start: loc,
+ end: loc,
+ source: ""
+ })
+ );
+}
+function isEnd(context, mode, ancestors) {
+ const s = context.source;
+ switch (mode) {
+ case 0:
+ if (startsWith(s, "</")) {
+ for (let i = ancestors.length - 1; i >= 0; --i) {
+ if (startsWithEndTagOpen(s, ancestors[i].tag)) {
+ return true;
+ }
+ }
+ }
+ break;
+ case 1:
+ case 2: {
+ const parent = last(ancestors);
+ if (parent && startsWithEndTagOpen(s, parent.tag)) {
+ return true;
+ }
+ break;
+ }
+ case 3:
+ if (startsWith(s, "]]>")) {
+ return true;
+ }
+ break;
+ }
+ return !s;
+}
+function startsWithEndTagOpen(source, tag) {
+ return startsWith(source, "</") && source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() && /[\t\r\n\f />]/.test(source[2 + tag.length] || ">");
+}
+
+function hoistStatic(root, context) {
+ walk(
+ root,
+ context,
+ // Root node is unfortunately non-hoistable due to potential parent
+ // fallthrough attributes.
+ isSingleElementRoot(root, root.children[0])
+ );
+}
+function isSingleElementRoot(root, child) {
+ const { children } = root;
+ return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
+}
+function walk(node, context, doNotHoistNode = false) {
+ const { children } = node;
+ const originalCount = children.length;
+ let hoistedCount = 0;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (child.type === 1 && child.tagType === 0) {
+ const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
+ if (constantType > 0) {
+ if (constantType >= 2) {
+ child.codegenNode.patchFlag = -1 + (``);
+ child.codegenNode = context.hoist(child.codegenNode);
+ hoistedCount++;
+ continue;
+ }
+ } else {
+ const codegenNode = child.codegenNode;
+ if (codegenNode.type === 13) {
+ const flag = getPatchFlag(codegenNode);
+ if ((!flag || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
+ const props = getNodeProps(child);
+ if (props) {
+ codegenNode.props = context.hoist(props);
+ }
+ }
+ if (codegenNode.dynamicProps) {
+ codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
+ }
+ }
+ }
+ }
+ if (child.type === 1) {
+ const isComponent = child.tagType === 1;
+ if (isComponent) {
+ context.scopes.vSlot++;
+ }
+ walk(child, context);
+ if (isComponent) {
+ context.scopes.vSlot--;
+ }
+ } else if (child.type === 11) {
+ walk(child, context, child.children.length === 1);
+ } else if (child.type === 9) {
+ for (let i2 = 0; i2 < child.branches.length; i2++) {
+ walk(
+ child.branches[i2],
+ context,
+ child.branches[i2].children.length === 1
+ );
+ }
+ }
+ }
+ if (hoistedCount && context.transformHoist) {
+ context.transformHoist(children, context, node);
+ }
+ if (hoistedCount && hoistedCount === originalCount && node.type === 1 && node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) {
+ const hoisted = context.hoist(
+ createArrayExpression(node.codegenNode.children)
+ );
+ if (context.hmr) {
+ hoisted.content = `[...${hoisted.content}]`;
+ }
+ node.codegenNode.children = hoisted;
+ }
+}
+function getConstantType(node, context) {
+ const { constantCache } = context;
+ switch (node.type) {
+ case 1:
+ if (node.tagType !== 0) {
+ return 0;
+ }
+ const cached = constantCache.get(node);
+ if (cached !== void 0) {
+ return cached;
+ }
+ const codegenNode = node.codegenNode;
+ if (codegenNode.type !== 13) {
+ return 0;
+ }
+ if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject") {
+ return 0;
+ }
+ const flag = getPatchFlag(codegenNode);
+ if (!flag) {
+ let returnType2 = 3;
+ const generatedPropsType = getGeneratedPropsConstantType(node, context);
+ if (generatedPropsType === 0) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ if (generatedPropsType < returnType2) {
+ returnType2 = generatedPropsType;
+ }
+ for (let i = 0; i < node.children.length; i++) {
+ const childType = getConstantType(node.children[i], context);
+ if (childType === 0) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ if (childType < returnType2) {
+ returnType2 = childType;
+ }
+ }
+ if (returnType2 > 1) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7 && p.name === "bind" && p.exp) {
+ const expType = getConstantType(p.exp, context);
+ if (expType === 0) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ if (expType < returnType2) {
+ returnType2 = expType;
+ }
+ }
+ }
+ }
+ if (codegenNode.isBlock) {
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 7) {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ }
+ context.removeHelper(OPEN_BLOCK);
+ context.removeHelper(
+ getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
+ );
+ codegenNode.isBlock = false;
+ context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
+ }
+ constantCache.set(node, returnType2);
+ return returnType2;
+ } else {
+ constantCache.set(node, 0);
+ return 0;
+ }
+ case 2:
+ case 3:
+ return 3;
+ case 9:
+ case 11:
+ case 10:
+ return 0;
+ case 5:
+ case 12:
+ return getConstantType(node.content, context);
+ case 4:
+ return node.constType;
+ case 8:
+ let returnType = 3;
+ for (let i = 0; i < node.children.length; i++) {
+ const child = node.children[i];
+ if (shared.isString(child) || shared.isSymbol(child)) {
+ continue;
+ }
+ const childType = getConstantType(child, context);
+ if (childType === 0) {
+ return 0;
+ } else if (childType < returnType) {
+ returnType = childType;
+ }
+ }
+ return returnType;
+ default:
+ return 0;
+ }
+}
+const allowHoistedHelperSet = /* @__PURE__ */ new Set([
+ NORMALIZE_CLASS,
+ NORMALIZE_STYLE,
+ NORMALIZE_PROPS,
+ GUARD_REACTIVE_PROPS
+]);
+function getConstantTypeOfHelperCall(value, context) {
+ if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
+ const arg = value.arguments[0];
+ if (arg.type === 4) {
+ return getConstantType(arg, context);
+ } else if (arg.type === 14) {
+ return getConstantTypeOfHelperCall(arg, context);
+ }
+ }
+ return 0;
+}
+function getGeneratedPropsConstantType(node, context) {
+ let returnType = 3;
+ const props = getNodeProps(node);
+ if (props && props.type === 15) {
+ const { properties } = props;
+ for (let i = 0; i < properties.length; i++) {
+ const { key, value } = properties[i];
+ const keyType = getConstantType(key, context);
+ if (keyType === 0) {
+ return keyType;
+ }
+ if (keyType < returnType) {
+ returnType = keyType;
+ }
+ let valueType;
+ if (value.type === 4) {
+ valueType = getConstantType(value, context);
+ } else if (value.type === 14) {
+ valueType = getConstantTypeOfHelperCall(value, context);
+ } else {
+ valueType = 0;
+ }
+ if (valueType === 0) {
+ return valueType;
+ }
+ if (valueType < returnType) {
+ returnType = valueType;
+ }
+ }
+ }
+ return returnType;
+}
+function getNodeProps(node) {
+ const codegenNode = node.codegenNode;
+ if (codegenNode.type === 13) {
+ return codegenNode.props;
+ }
+}
+function getPatchFlag(node) {
+ const flag = node.patchFlag;
+ return flag ? parseInt(flag, 10) : void 0;
+}
+
+function createTransformContext(root, {
+ filename = "",
+ prefixIdentifiers = false,
+ hoistStatic: hoistStatic2 = false,
+ hmr = false,
+ cacheHandlers = false,
+ nodeTransforms = [],
+ directiveTransforms = {},
+ transformHoist = null,
+ isBuiltInComponent = shared.NOOP,
+ isCustomElement = shared.NOOP,
+ expressionPlugins = [],
+ scopeId = null,
+ slotted = true,
+ ssr = false,
+ inSSR = false,
+ ssrCssVars = ``,
+ bindingMetadata = shared.EMPTY_OBJ,
+ inline = false,
+ isTS = false,
+ onError = defaultOnError,
+ onWarn = defaultOnWarn,
+ compatConfig
+}) {
+ const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
+ const context = {
+ // options
+ selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])),
+ prefixIdentifiers,
+ hoistStatic: hoistStatic2,
+ hmr,
+ cacheHandlers,
+ nodeTransforms,
+ directiveTransforms,
+ transformHoist,
+ isBuiltInComponent,
+ isCustomElement,
+ expressionPlugins,
+ scopeId,
+ slotted,
+ ssr,
+ inSSR,
+ ssrCssVars,
+ bindingMetadata,
+ inline,
+ isTS,
+ onError,
+ onWarn,
+ compatConfig,
+ // state
+ root,
+ helpers: /* @__PURE__ */ new Map(),
+ components: /* @__PURE__ */ new Set(),
+ directives: /* @__PURE__ */ new Set(),
+ hoists: [],
+ imports: [],
+ constantCache: /* @__PURE__ */ new WeakMap(),
+ temps: 0,
+ cached: 0,
+ identifiers: /* @__PURE__ */ Object.create(null),
+ scopes: {
+ vFor: 0,
+ vSlot: 0,
+ vPre: 0,
+ vOnce: 0
+ },
+ parent: null,
+ currentNode: root,
+ childIndex: 0,
+ inVOnce: false,
+ // methods
+ helper(name) {
+ const count = context.helpers.get(name) || 0;
+ context.helpers.set(name, count + 1);
+ return name;
+ },
+ removeHelper(name) {
+ const count = context.helpers.get(name);
+ if (count) {
+ const currentCount = count - 1;
+ if (!currentCount) {
+ context.helpers.delete(name);
+ } else {
+ context.helpers.set(name, currentCount);
+ }
+ }
+ },
+ helperString(name) {
+ return `_${helperNameMap[context.helper(name)]}`;
+ },
+ replaceNode(node) {
+ context.parent.children[context.childIndex] = context.currentNode = node;
+ },
+ removeNode(node) {
+ const list = context.parent.children;
+ const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
+ if (!node || node === context.currentNode) {
+ context.currentNode = null;
+ context.onNodeRemoved();
+ } else {
+ if (context.childIndex > removalIndex) {
+ context.childIndex--;
+ context.onNodeRemoved();
+ }
+ }
+ context.parent.children.splice(removalIndex, 1);
+ },
+ onNodeRemoved: () => {
+ },
+ addIdentifiers(exp) {
+ {
+ if (shared.isString(exp)) {
+ addId(exp);
+ } else if (exp.identifiers) {
+ exp.identifiers.forEach(addId);
+ } else if (exp.type === 4) {
+ addId(exp.content);
+ }
+ }
+ },
+ removeIdentifiers(exp) {
+ {
+ if (shared.isString(exp)) {
+ removeId(exp);
+ } else if (exp.identifiers) {
+ exp.identifiers.forEach(removeId);
+ } else if (exp.type === 4) {
+ removeId(exp.content);
+ }
+ }
+ },
+ hoist(exp) {
+ if (shared.isString(exp))
+ exp = createSimpleExpression(exp);
+ context.hoists.push(exp);
+ const identifier = createSimpleExpression(
+ `_hoisted_${context.hoists.length}`,
+ false,
+ exp.loc,
+ 2
+ );
+ identifier.hoisted = exp;
+ return identifier;
+ },
+ cache(exp, isVNode = false) {
+ return createCacheExpression(context.cached++, exp, isVNode);
+ }
+ };
+ {
+ context.filters = /* @__PURE__ */ new Set();
+ }
+ function addId(id) {
+ const { identifiers } = context;
+ if (identifiers[id] === void 0) {
+ identifiers[id] = 0;
+ }
+ identifiers[id]++;
+ }
+ function removeId(id) {
+ context.identifiers[id]--;
+ }
+ return context;
+}
+function transform(root, options) {
+ const context = createTransformContext(root, options);
+ traverseNode(root, context);
+ if (options.hoistStatic) {
+ hoistStatic(root, context);
+ }
+ if (!options.ssr) {
+ createRootCodegen(root, context);
+ }
+ root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
+ root.components = [...context.components];
+ root.directives = [...context.directives];
+ root.imports = context.imports;
+ root.hoists = context.hoists;
+ root.temps = context.temps;
+ root.cached = context.cached;
+ {
+ root.filters = [...context.filters];
+ }
+}
+function createRootCodegen(root, context) {
+ const { helper } = context;
+ const { children } = root;
+ if (children.length === 1) {
+ const child = children[0];
+ if (isSingleElementRoot(root, child) && child.codegenNode) {
+ const codegenNode = child.codegenNode;
+ if (codegenNode.type === 13) {
+ convertToBlock(codegenNode, context);
+ }
+ root.codegenNode = codegenNode;
+ } else {
+ root.codegenNode = child;
+ }
+ } else if (children.length > 1) {
+ let patchFlag = 64;
+ shared.PatchFlagNames[64];
+ root.codegenNode = createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ void 0,
+ root.children,
+ patchFlag + (``),
+ void 0,
+ void 0,
+ true,
+ void 0,
+ false
+ /* isComponent */
+ );
+ } else ;
+}
+function traverseChildren(parent, context) {
+ let i = 0;
+ const nodeRemoved = () => {
+ i--;
+ };
+ for (; i < parent.children.length; i++) {
+ const child = parent.children[i];
+ if (shared.isString(child))
+ continue;
+ context.parent = parent;
+ context.childIndex = i;
+ context.onNodeRemoved = nodeRemoved;
+ traverseNode(child, context);
+ }
+}
+function traverseNode(node, context) {
+ context.currentNode = node;
+ const { nodeTransforms } = context;
+ const exitFns = [];
+ for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
+ const onExit = nodeTransforms[i2](node, context);
+ if (onExit) {
+ if (shared.isArray(onExit)) {
+ exitFns.push(...onExit);
+ } else {
+ exitFns.push(onExit);
+ }
+ }
+ if (!context.currentNode) {
+ return;
+ } else {
+ node = context.currentNode;
+ }
+ }
+ switch (node.type) {
+ case 3:
+ if (!context.ssr) {
+ context.helper(CREATE_COMMENT);
+ }
+ break;
+ case 5:
+ if (!context.ssr) {
+ context.helper(TO_DISPLAY_STRING);
+ }
+ break;
+ case 9:
+ for (let i2 = 0; i2 < node.branches.length; i2++) {
+ traverseNode(node.branches[i2], context);
+ }
+ break;
+ case 10:
+ case 11:
+ case 1:
+ case 0:
+ traverseChildren(node, context);
+ break;
+ }
+ context.currentNode = node;
+ let i = exitFns.length;
+ while (i--) {
+ exitFns[i]();
+ }
+}
+function createStructuralDirectiveTransform(name, fn) {
+ const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n);
+ return (node, context) => {
+ if (node.type === 1) {
+ const { props } = node;
+ if (node.tagType === 3 && props.some(isVSlot)) {
+ return;
+ }
+ const exitFns = [];
+ for (let i = 0; i < props.length; i++) {
+ const prop = props[i];
+ if (prop.type === 7 && matches(prop.name)) {
+ props.splice(i, 1);
+ i--;
+ const onExit = fn(node, prop, context);
+ if (onExit)
+ exitFns.push(onExit);
+ }
+ }
+ return exitFns;
+ }
+ };
+}
+
+const PURE_ANNOTATION = `/*#__PURE__*/`;
+const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
+function createCodegenContext(ast, {
+ mode = "function",
+ prefixIdentifiers = mode === "module",
+ sourceMap = false,
+ filename = `template.vue.html`,
+ scopeId = null,
+ optimizeImports = false,
+ runtimeGlobalName = `Vue`,
+ runtimeModuleName = `vue`,
+ ssrRuntimeModuleName = "vue/server-renderer",
+ ssr = false,
+ isTS = false,
+ inSSR = false
+}) {
+ const context = {
+ mode,
+ prefixIdentifiers,
+ sourceMap,
+ filename,
+ scopeId,
+ optimizeImports,
+ runtimeGlobalName,
+ runtimeModuleName,
+ ssrRuntimeModuleName,
+ ssr,
+ isTS,
+ inSSR,
+ source: ast.loc.source,
+ code: ``,
+ column: 1,
+ line: 1,
+ offset: 0,
+ indentLevel: 0,
+ pure: false,
+ map: void 0,
+ helper(key) {
+ return `_${helperNameMap[key]}`;
+ },
+ push(code, node) {
+ context.code += code;
+ if (context.map) {
+ if (node) {
+ let name;
+ if (node.type === 4 && !node.isStatic) {
+ const content = node.content.replace(/^_ctx\./, "");
+ if (content !== node.content && isSimpleIdentifier(content)) {
+ name = content;
+ }
+ }
+ addMapping(node.loc.start, name);
+ }
+ advancePositionWithMutation(context, code);
+ if (node && node.loc !== locStub) {
+ addMapping(node.loc.end);
+ }
+ }
+ },
+ indent() {
+ newline(++context.indentLevel);
+ },
+ deindent(withoutNewLine = false) {
+ if (withoutNewLine) {
+ --context.indentLevel;
+ } else {
+ newline(--context.indentLevel);
+ }
+ },
+ newline() {
+ newline(context.indentLevel);
+ }
+ };
+ function newline(n) {
+ context.push("\n" + ` `.repeat(n));
+ }
+ function addMapping(loc, name) {
+ context.map.addMapping({
+ name,
+ source: context.filename,
+ original: {
+ line: loc.line,
+ column: loc.column - 1
+ // source-map column is 0 based
+ },
+ generated: {
+ line: context.line,
+ column: context.column - 1
+ }
+ });
+ }
+ if (sourceMap) {
+ context.map = new sourceMapJs.SourceMapGenerator();
+ context.map.setSourceContent(filename, context.source);
+ }
+ return context;
+}
+function generate(ast, options = {}) {
+ const context = createCodegenContext(ast, options);
+ if (options.onContextCreated)
+ options.onContextCreated(context);
+ const {
+ mode,
+ push,
+ prefixIdentifiers,
+ indent,
+ deindent,
+ newline,
+ scopeId,
+ ssr
+ } = context;
+ const helpers = Array.from(ast.helpers);
+ const hasHelpers = helpers.length > 0;
+ const useWithBlock = !prefixIdentifiers && mode !== "module";
+ const genScopeId = scopeId != null && mode === "module";
+ const isSetupInlined = !!options.inline;
+ const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;
+ if (mode === "module") {
+ genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);
+ } else {
+ genFunctionPreamble(ast, preambleContext);
+ }
+ const functionName = ssr ? `ssrRender` : `render`;
+ const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
+ if (options.bindingMetadata && !options.inline) {
+ args.push("$props", "$setup", "$data", "$options");
+ }
+ const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", ");
+ if (isSetupInlined) {
+ push(`(${signature}) => {`);
+ } else {
+ push(`function ${functionName}(${signature}) {`);
+ }
+ indent();
+ if (useWithBlock) {
+ push(`with (_ctx) {`);
+ indent();
+ if (hasHelpers) {
+ push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue`);
+ push(`
+`);
+ newline();
+ }
+ }
+ if (ast.components.length) {
+ genAssets(ast.components, "component", context);
+ if (ast.directives.length || ast.temps > 0) {
+ newline();
+ }
+ }
+ if (ast.directives.length) {
+ genAssets(ast.directives, "directive", context);
+ if (ast.temps > 0) {
+ newline();
+ }
+ }
+ if (ast.filters && ast.filters.length) {
+ newline();
+ genAssets(ast.filters, "filter", context);
+ newline();
+ }
+ if (ast.temps > 0) {
+ push(`let `);
+ for (let i = 0; i < ast.temps; i++) {
+ push(`${i > 0 ? `, ` : ``}_temp${i}`);
+ }
+ }
+ if (ast.components.length || ast.directives.length || ast.temps) {
+ push(`
+`);
+ newline();
+ }
+ if (!ssr) {
+ push(`return `);
+ }
+ if (ast.codegenNode) {
+ genNode(ast.codegenNode, context);
+ } else {
+ push(`null`);
+ }
+ if (useWithBlock) {
+ deindent();
+ push(`}`);
+ }
+ deindent();
+ push(`}`);
+ return {
+ ast,
+ code: context.code,
+ preamble: isSetupInlined ? preambleContext.code : ``,
+ // SourceMapGenerator does have toJSON() method but it's not in the types
+ map: context.map ? context.map.toJSON() : void 0
+ };
+}
+function genFunctionPreamble(ast, context) {
+ const {
+ ssr,
+ prefixIdentifiers,
+ push,
+ newline,
+ runtimeModuleName,
+ runtimeGlobalName,
+ ssrRuntimeModuleName
+ } = context;
+ const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;
+ const helpers = Array.from(ast.helpers);
+ if (helpers.length > 0) {
+ if (prefixIdentifiers) {
+ push(`const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding}
+`);
+ } else {
+ push(`const _Vue = ${VueBinding}
+`);
+ if (ast.hoists.length) {
+ const staticHelpers = [
+ CREATE_VNODE,
+ CREATE_ELEMENT_VNODE,
+ CREATE_COMMENT,
+ CREATE_TEXT,
+ CREATE_STATIC
+ ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
+ push(`const { ${staticHelpers} } = _Vue
+`);
+ }
+ }
+ }
+ if (ast.ssrHelpers && ast.ssrHelpers.length) {
+ push(
+ `const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}")
+`
+ );
+ }
+ genHoists(ast.hoists, context);
+ newline();
+ push(`return `);
+}
+function genModulePreamble(ast, context, genScopeId, inline) {
+ const {
+ push,
+ newline,
+ optimizeImports,
+ runtimeModuleName,
+ ssrRuntimeModuleName
+ } = context;
+ if (genScopeId && ast.hoists.length) {
+ ast.helpers.add(PUSH_SCOPE_ID);
+ ast.helpers.add(POP_SCOPE_ID);
+ }
+ if (ast.helpers.size) {
+ const helpers = Array.from(ast.helpers);
+ if (optimizeImports) {
+ push(
+ `import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
+`
+ );
+ push(
+ `
+// Binding optimization for webpack code-split
+const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")}
+`
+ );
+ } else {
+ push(
+ `import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
+`
+ );
+ }
+ }
+ if (ast.ssrHelpers && ast.ssrHelpers.length) {
+ push(
+ `import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}"
+`
+ );
+ }
+ if (ast.imports.length) {
+ genImports(ast.imports, context);
+ newline();
+ }
+ genHoists(ast.hoists, context);
+ newline();
+ if (!inline) {
+ push(`export `);
+ }
+}
+function genAssets(assets, type, { helper, push, newline, isTS }) {
+ const resolver = helper(
+ type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
+ );
+ for (let i = 0; i < assets.length; i++) {
+ let id = assets[i];
+ const maybeSelfReference = id.endsWith("__self");
+ if (maybeSelfReference) {
+ id = id.slice(0, -6);
+ }
+ push(
+ `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
+ );
+ if (i < assets.length - 1) {
+ newline();
+ }
+ }
+}
+function genHoists(hoists, context) {
+ if (!hoists.length) {
+ return;
+ }
+ context.pure = true;
+ const { push, newline, helper, scopeId, mode } = context;
+ const genScopeId = scopeId != null && mode !== "function";
+ newline();
+ if (genScopeId) {
+ push(
+ `const _withScopeId = n => (${helper(
+ PUSH_SCOPE_ID
+ )}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`
+ );
+ newline();
+ }
+ for (let i = 0; i < hoists.length; i++) {
+ const exp = hoists[i];
+ if (exp) {
+ const needScopeIdWrapper = genScopeId && exp.type === 13;
+ push(
+ `const _hoisted_${i + 1} = ${needScopeIdWrapper ? `${PURE_ANNOTATION} _withScopeId(() => ` : ``}`
+ );
+ genNode(exp, context);
+ if (needScopeIdWrapper) {
+ push(`)`);
+ }
+ newline();
+ }
+ }
+ context.pure = false;
+}
+function genImports(importsOptions, context) {
+ if (!importsOptions.length) {
+ return;
+ }
+ importsOptions.forEach((imports) => {
+ context.push(`import `);
+ genNode(imports.exp, context);
+ context.push(` from '${imports.path}'`);
+ context.newline();
+ });
+}
+function isText(n) {
+ return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
+}
+function genNodeListAsArray(nodes, context) {
+ const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n));
+ context.push(`[`);
+ multilines && context.indent();
+ genNodeList(nodes, context, multilines);
+ multilines && context.deindent();
+ context.push(`]`);
+}
+function genNodeList(nodes, context, multilines = false, comma = true) {
+ const { push, newline } = context;
+ for (let i = 0; i < nodes.length; i++) {
+ const node = nodes[i];
+ if (shared.isString(node)) {
+ push(node);
+ } else if (shared.isArray(node)) {
+ genNodeListAsArray(node, context);
+ } else {
+ genNode(node, context);
+ }
+ if (i < nodes.length - 1) {
+ if (multilines) {
+ comma && push(",");
+ newline();
+ } else {
+ comma && push(", ");
+ }
+ }
+ }
+}
+function genNode(node, context) {
+ if (shared.isString(node)) {
+ context.push(node);
+ return;
+ }
+ if (shared.isSymbol(node)) {
+ context.push(context.helper(node));
+ return;
+ }
+ switch (node.type) {
+ case 1:
+ case 9:
+ case 11:
+ genNode(node.codegenNode, context);
+ break;
+ case 2:
+ genText(node, context);
+ break;
+ case 4:
+ genExpression(node, context);
+ break;
+ case 5:
+ genInterpolation(node, context);
+ break;
+ case 12:
+ genNode(node.codegenNode, context);
+ break;
+ case 8:
+ genCompoundExpression(node, context);
+ break;
+ case 3:
+ genComment(node, context);
+ break;
+ case 13:
+ genVNodeCall(node, context);
+ break;
+ case 14:
+ genCallExpression(node, context);
+ break;
+ case 15:
+ genObjectExpression(node, context);
+ break;
+ case 17:
+ genArrayExpression(node, context);
+ break;
+ case 18:
+ genFunctionExpression(node, context);
+ break;
+ case 19:
+ genConditionalExpression(node, context);
+ break;
+ case 20:
+ genCacheExpression(node, context);
+ break;
+ case 21:
+ genNodeList(node.body, context, true, false);
+ break;
+ case 22:
+ genTemplateLiteral(node, context);
+ break;
+ case 23:
+ genIfStatement(node, context);
+ break;
+ case 24:
+ genAssignmentExpression(node, context);
+ break;
+ case 25:
+ genSequenceExpression(node, context);
+ break;
+ case 26:
+ genReturnStatement(node, context);
+ break;
+ }
+}
+function genText(node, context) {
+ context.push(JSON.stringify(node.content), node);
+}
+function genExpression(node, context) {
+ const { content, isStatic } = node;
+ context.push(isStatic ? JSON.stringify(content) : content, node);
+}
+function genInterpolation(node, context) {
+ const { push, helper, pure } = context;
+ if (pure)
+ push(PURE_ANNOTATION);
+ push(`${helper(TO_DISPLAY_STRING)}(`);
+ genNode(node.content, context);
+ push(`)`);
+}
+function genCompoundExpression(node, context) {
+ for (let i = 0; i < node.children.length; i++) {
+ const child = node.children[i];
+ if (shared.isString(child)) {
+ context.push(child);
+ } else {
+ genNode(child, context);
+ }
+ }
+}
+function genExpressionAsPropertyKey(node, context) {
+ const { push } = context;
+ if (node.type === 8) {
+ push(`[`);
+ genCompoundExpression(node, context);
+ push(`]`);
+ } else if (node.isStatic) {
+ const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
+ push(text, node);
+ } else {
+ push(`[${node.content}]`, node);
+ }
+}
+function genComment(node, context) {
+ const { push, helper, pure } = context;
+ if (pure) {
+ push(PURE_ANNOTATION);
+ }
+ push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
+}
+function genVNodeCall(node, context) {
+ const { push, helper, pure } = context;
+ const {
+ tag,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ directives,
+ isBlock,
+ disableTracking,
+ isComponent
+ } = node;
+ if (directives) {
+ push(helper(WITH_DIRECTIVES) + `(`);
+ }
+ if (isBlock) {
+ push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
+ }
+ if (pure) {
+ push(PURE_ANNOTATION);
+ }
+ const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
+ push(helper(callHelper) + `(`, node);
+ genNodeList(
+ genNullableArgs([tag, props, children, patchFlag, dynamicProps]),
+ context
+ );
+ push(`)`);
+ if (isBlock) {
+ push(`)`);
+ }
+ if (directives) {
+ push(`, `);
+ genNode(directives, context);
+ push(`)`);
+ }
+}
+function genNullableArgs(args) {
+ let i = args.length;
+ while (i--) {
+ if (args[i] != null)
+ break;
+ }
+ return args.slice(0, i + 1).map((arg) => arg || `null`);
+}
+function genCallExpression(node, context) {
+ const { push, helper, pure } = context;
+ const callee = shared.isString(node.callee) ? node.callee : helper(node.callee);
+ if (pure) {
+ push(PURE_ANNOTATION);
+ }
+ push(callee + `(`, node);
+ genNodeList(node.arguments, context);
+ push(`)`);
+}
+function genObjectExpression(node, context) {
+ const { push, indent, deindent, newline } = context;
+ const { properties } = node;
+ if (!properties.length) {
+ push(`{}`, node);
+ return;
+ }
+ const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
+ push(multilines ? `{` : `{ `);
+ multilines && indent();
+ for (let i = 0; i < properties.length; i++) {
+ const { key, value } = properties[i];
+ genExpressionAsPropertyKey(key, context);
+ push(`: `);
+ genNode(value, context);
+ if (i < properties.length - 1) {
+ push(`,`);
+ newline();
+ }
+ }
+ multilines && deindent();
+ push(multilines ? `}` : ` }`);
+}
+function genArrayExpression(node, context) {
+ genNodeListAsArray(node.elements, context);
+}
+function genFunctionExpression(node, context) {
+ const { push, indent, deindent } = context;
+ const { params, returns, body, newline, isSlot } = node;
+ if (isSlot) {
+ push(`_${helperNameMap[WITH_CTX]}(`);
+ }
+ push(`(`, node);
+ if (shared.isArray(params)) {
+ genNodeList(params, context);
+ } else if (params) {
+ genNode(params, context);
+ }
+ push(`) => `);
+ if (newline || body) {
+ push(`{`);
+ indent();
+ }
+ if (returns) {
+ if (newline) {
+ push(`return `);
+ }
+ if (shared.isArray(returns)) {
+ genNodeListAsArray(returns, context);
+ } else {
+ genNode(returns, context);
+ }
+ } else if (body) {
+ genNode(body, context);
+ }
+ if (newline || body) {
+ deindent();
+ push(`}`);
+ }
+ if (isSlot) {
+ if (node.isNonScopedSlot) {
+ push(`, undefined, true`);
+ }
+ push(`)`);
+ }
+}
+function genConditionalExpression(node, context) {
+ const { test, consequent, alternate, newline: needNewline } = node;
+ const { push, indent, deindent, newline } = context;
+ if (test.type === 4) {
+ const needsParens = !isSimpleIdentifier(test.content);
+ needsParens && push(`(`);
+ genExpression(test, context);
+ needsParens && push(`)`);
+ } else {
+ push(`(`);
+ genNode(test, context);
+ push(`)`);
+ }
+ needNewline && indent();
+ context.indentLevel++;
+ needNewline || push(` `);
+ push(`? `);
+ genNode(consequent, context);
+ context.indentLevel--;
+ needNewline && newline();
+ needNewline || push(` `);
+ push(`: `);
+ const isNested = alternate.type === 19;
+ if (!isNested) {
+ context.indentLevel++;
+ }
+ genNode(alternate, context);
+ if (!isNested) {
+ context.indentLevel--;
+ }
+ needNewline && deindent(
+ true
+ /* without newline */
+ );
+}
+function genCacheExpression(node, context) {
+ const { push, helper, indent, deindent, newline } = context;
+ push(`_cache[${node.index}] || (`);
+ if (node.isVNode) {
+ indent();
+ push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
+ newline();
+ }
+ push(`_cache[${node.index}] = `);
+ genNode(node.value, context);
+ if (node.isVNode) {
+ push(`,`);
+ newline();
+ push(`${helper(SET_BLOCK_TRACKING)}(1),`);
+ newline();
+ push(`_cache[${node.index}]`);
+ deindent();
+ }
+ push(`)`);
+}
+function genTemplateLiteral(node, context) {
+ const { push, indent, deindent } = context;
+ push("`");
+ const l = node.elements.length;
+ const multilines = l > 3;
+ for (let i = 0; i < l; i++) {
+ const e = node.elements[i];
+ if (shared.isString(e)) {
+ push(e.replace(/(`|\$|\\)/g, "\\$1"));
+ } else {
+ push("${");
+ if (multilines)
+ indent();
+ genNode(e, context);
+ if (multilines)
+ deindent();
+ push("}");
+ }
+ }
+ push("`");
+}
+function genIfStatement(node, context) {
+ const { push, indent, deindent } = context;
+ const { test, consequent, alternate } = node;
+ push(`if (`);
+ genNode(test, context);
+ push(`) {`);
+ indent();
+ genNode(consequent, context);
+ deindent();
+ push(`}`);
+ if (alternate) {
+ push(` else `);
+ if (alternate.type === 23) {
+ genIfStatement(alternate, context);
+ } else {
+ push(`{`);
+ indent();
+ genNode(alternate, context);
+ deindent();
+ push(`}`);
+ }
+ }
+}
+function genAssignmentExpression(node, context) {
+ genNode(node.left, context);
+ context.push(` = `);
+ genNode(node.right, context);
+}
+function genSequenceExpression(node, context) {
+ context.push(`(`);
+ genNodeList(node.expressions, context);
+ context.push(`)`);
+}
+function genReturnStatement({ returns }, context) {
+ context.push(`return `);
+ if (shared.isArray(returns)) {
+ genNodeListAsArray(returns, context);
+ } else {
+ genNode(returns, context);
+ }
+}
+
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
+ const rootExp = root.type === "Program" && root.body[0].type === "ExpressionStatement" && root.body[0].expression;
+ estreeWalker.walk(root, {
+ enter(node, parent) {
+ parent && parentStack.push(parent);
+ if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) {
+ return this.skip();
+ }
+ if (node.type === "Identifier") {
+ const isLocal = !!knownIds[node.name];
+ const isRefed = isReferencedIdentifier(node, parent, parentStack);
+ if (includeAll || isRefed && !isLocal) {
+ onIdentifier(node, parent, parentStack, isRefed, isLocal);
+ }
+ } else if (node.type === "ObjectProperty" && parent.type === "ObjectPattern") {
+ node.inPattern = true;
+ } else if (isFunctionType(node)) {
+ walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
+ } else if (node.type === "BlockStatement") {
+ walkBlockDeclarations(
+ node,
+ (id) => markScopeIdentifier(node, id, knownIds)
+ );
+ }
+ },
+ leave(node, parent) {
+ parent && parentStack.pop();
+ if (node !== rootExp && node.scopeIds) {
+ for (const id of node.scopeIds) {
+ knownIds[id]--;
+ if (knownIds[id] === 0) {
+ delete knownIds[id];
+ }
+ }
+ }
+ }
+ });
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+ if (!parent) {
+ return true;
+ }
+ if (id.name === "arguments") {
+ return false;
+ }
+ if (isReferenced(id, parent)) {
+ return true;
+ }
+ switch (parent.type) {
+ case "AssignmentExpression":
+ case "AssignmentPattern":
+ return true;
+ case "ObjectPattern":
+ case "ArrayPattern":
+ return isInDestructureAssignment(parent, parentStack);
+ }
+ return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+ if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
+ let i = parentStack.length;
+ while (i--) {
+ const p = parentStack[i];
+ if (p.type === "AssignmentExpression") {
+ return true;
+ } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
+ break;
+ }
+ }
+ }
+ return false;
+}
+function walkFunctionParams(node, onIdent) {
+ for (const p of node.params) {
+ for (const id of extractIdentifiers(p)) {
+ onIdent(id);
+ }
+ }
+}
+function walkBlockDeclarations(block, onIdent) {
+ for (const stmt of block.body) {
+ if (stmt.type === "VariableDeclaration") {
+ if (stmt.declare)
+ continue;
+ for (const decl of stmt.declarations) {
+ for (const id of extractIdentifiers(decl.id)) {
+ onIdent(id);
+ }
+ }
+ } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+ if (stmt.declare || !stmt.id)
+ continue;
+ onIdent(stmt.id);
+ } else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
+ const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+ if (variable && variable.type === "VariableDeclaration") {
+ for (const decl of variable.declarations) {
+ for (const id of extractIdentifiers(decl.id)) {
+ onIdent(id);
+ }
+ }
+ }
+ }
+ }
+}
+function extractIdentifiers(param, nodes = []) {
+ switch (param.type) {
+ case "Identifier":
+ nodes.push(param);
+ break;
+ case "MemberExpression":
+ let object = param;
+ while (object.type === "MemberExpression") {
+ object = object.object;
+ }
+ nodes.push(object);
+ break;
+ case "ObjectPattern":
+ for (const prop of param.properties) {
+ if (prop.type === "RestElement") {
+ extractIdentifiers(prop.argument, nodes);
+ } else {
+ extractIdentifiers(prop.value, nodes);
+ }
+ }
+ break;
+ case "ArrayPattern":
+ param.elements.forEach((element) => {
+ if (element)
+ extractIdentifiers(element, nodes);
+ });
+ break;
+ case "RestElement":
+ extractIdentifiers(param.argument, nodes);
+ break;
+ case "AssignmentPattern":
+ extractIdentifiers(param.left, nodes);
+ break;
+ }
+ return nodes;
+}
+function markScopeIdentifier(node, child, knownIds) {
+ const { name } = child;
+ if (node.scopeIds && node.scopeIds.has(name)) {
+ return;
+ }
+ if (name in knownIds) {
+ knownIds[name]++;
+ } else {
+ knownIds[name] = 1;
+ }
+ (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
+}
+const isFunctionType = (node) => {
+ return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+function isReferenced(node, parent, grandparent) {
+ switch (parent.type) {
+ case "MemberExpression":
+ case "OptionalMemberExpression":
+ if (parent.property === node) {
+ return !!parent.computed;
+ }
+ return parent.object === node;
+ case "JSXMemberExpression":
+ return parent.object === node;
+ case "VariableDeclarator":
+ return parent.init === node;
+ case "ArrowFunctionExpression":
+ return parent.body === node;
+ case "PrivateName":
+ return false;
+ case "ClassMethod":
+ case "ClassPrivateMethod":
+ case "ObjectMethod":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return false;
+ case "ObjectProperty":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return !grandparent || grandparent.type !== "ObjectPattern";
+ case "ClassProperty":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return true;
+ case "ClassPrivateProperty":
+ return parent.key !== node;
+ case "ClassDeclaration":
+ case "ClassExpression":
+ return parent.superClass === node;
+ case "AssignmentExpression":
+ return parent.right === node;
+ case "AssignmentPattern":
+ return parent.right === node;
+ case "LabeledStatement":
+ return false;
+ case "CatchClause":
+ return false;
+ case "RestElement":
+ return false;
+ case "BreakStatement":
+ case "ContinueStatement":
+ return false;
+ case "FunctionDeclaration":
+ case "FunctionExpression":
+ return false;
+ case "ExportNamespaceSpecifier":
+ case "ExportDefaultSpecifier":
+ return false;
+ case "ExportSpecifier":
+ if (grandparent == null ? void 0 : grandparent.source) {
+ return false;
+ }
+ return parent.local === node;
+ case "ImportDefaultSpecifier":
+ case "ImportNamespaceSpecifier":
+ case "ImportSpecifier":
+ return false;
+ case "ImportAttribute":
+ return false;
+ case "JSXAttribute":
+ return false;
+ case "ObjectPattern":
+ case "ArrayPattern":
+ return false;
+ case "MetaProperty":
+ return false;
+ case "ObjectTypeProperty":
+ return parent.key !== node;
+ case "TSEnumMember":
+ return parent.id !== node;
+ case "TSPropertySignature":
+ if (parent.key === node) {
+ return !!parent.computed;
+ }
+ return true;
+ }
+ return true;
+}
+const TS_NODE_TYPES = [
+ "TSAsExpression",
+ // foo as number
+ "TSTypeAssertion",
+ // (<number>foo)
+ "TSNonNullExpression",
+ // foo!
+ "TSInstantiationExpression",
+ // foo<string>
+ "TSSatisfiesExpression"
+ // foo satisfies T
+];
+
+const isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap("true,false,null,this");
+const constantBailRE = /\w\s*\(|\.[^\d]/;
+const transformExpression = (node, context) => {
+ if (node.type === 5) {
+ node.content = processExpression(
+ node.content,
+ context
+ );
+ } else if (node.type === 1) {
+ for (let i = 0; i < node.props.length; i++) {
+ const dir = node.props[i];
+ if (dir.type === 7 && dir.name !== "for") {
+ const exp = dir.exp;
+ const arg = dir.arg;
+ if (exp && exp.type === 4 && !(dir.name === "on" && arg)) {
+ dir.exp = processExpression(
+ exp,
+ context,
+ // slot args must be processed as function params
+ dir.name === "slot"
+ );
+ }
+ if (arg && arg.type === 4 && !arg.isStatic) {
+ dir.arg = processExpression(arg, context);
+ }
+ }
+ }
+ }
+};
+function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
+ if (!context.prefixIdentifiers || !node.content.trim()) {
+ return node;
+ }
+ const { inline, bindingMetadata } = context;
+ const rewriteIdentifier = (raw, parent, id) => {
+ const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw];
+ if (inline) {
+ const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
+ const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
+ const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
+ if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) {
+ return raw;
+ } else if (type === "setup-ref") {
+ return `${raw}.value`;
+ } else if (type === "setup-maybe-ref") {
+ return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : `${context.helperString(UNREF)}(${raw})`;
+ } else if (type === "setup-let") {
+ if (isAssignmentLVal) {
+ const { right: rVal, operator } = parent;
+ const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);
+ const rExpString = stringifyExpression(
+ processExpression(
+ createSimpleExpression(rExp, false),
+ context,
+ false,
+ false,
+ knownIds
+ )
+ );
+ return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
+` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
+ } else if (isUpdateArg) {
+ id.start = parent.start;
+ id.end = parent.end;
+ const { prefix: isPrefix, operator } = parent;
+ const prefix = isPrefix ? operator : ``;
+ const postfix = isPrefix ? `` : operator;
+ return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
+` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
+ } else if (isDestructureAssignment) {
+ return raw;
+ } else {
+ return `${context.helperString(UNREF)}(${raw})`;
+ }
+ } else if (type === "props") {
+ return shared.genPropsAccessExp(raw);
+ } else if (type === "props-aliased") {
+ return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
+ }
+ } else {
+ if (type && type.startsWith("setup") || type === "literal-const") {
+ return `$setup.${raw}`;
+ } else if (type === "props-aliased") {
+ return `$props['${bindingMetadata.__propsAliases[raw]}']`;
+ } else if (type) {
+ return `$${type}.${raw}`;
+ }
+ }
+ return `_ctx.${raw}`;
+ };
+ const rawExp = node.content;
+ const bailConstant = constantBailRE.test(rawExp);
+ if (isSimpleIdentifier(rawExp)) {
+ const isScopeVarReference = context.identifiers[rawExp];
+ const isAllowedGlobal = shared.isGloballyAllowed(rawExp);
+ const isLiteral = isLiteralWhitelisted(rawExp);
+ if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {
+ if (isConst(bindingMetadata[rawExp])) {
+ node.constType = 1;
+ }
+ node.content = rewriteIdentifier(rawExp);
+ } else if (!isScopeVarReference) {
+ if (isLiteral) {
+ node.constType = 3;
+ } else {
+ node.constType = 2;
+ }
+ }
+ return node;
+ }
+ let ast;
+ const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
+ try {
+ ast = parser.parse(source, {
+ plugins: context.expressionPlugins
+ }).program;
+ } catch (e) {
+ context.onError(
+ createCompilerError(
+ 45,
+ node.loc,
+ void 0,
+ e.message
+ )
+ );
+ return node;
+ }
+ const ids = [];
+ const parentStack = [];
+ const knownIds = Object.create(context.identifiers);
+ walkIdentifiers(
+ ast,
+ (node2, parent, _, isReferenced, isLocal) => {
+ if (isStaticPropertyKey(node2, parent)) {
+ return;
+ }
+ if (node2.name.startsWith("_filter_")) {
+ return;
+ }
+ const needPrefix = isReferenced && canPrefix(node2);
+ if (needPrefix && !isLocal) {
+ if (isStaticProperty(parent) && parent.shorthand) {
+ node2.prefix = `${node2.name}: `;
+ }
+ node2.name = rewriteIdentifier(node2.name, parent, node2);
+ ids.push(node2);
+ } else {
+ if (!(needPrefix && isLocal) && !bailConstant) {
+ node2.isConstant = true;
+ }
+ ids.push(node2);
+ }
+ },
+ true,
+ // invoke on ALL identifiers
+ parentStack,
+ knownIds
+ );
+ const children = [];
+ ids.sort((a, b) => a.start - b.start);
+ ids.forEach((id, i) => {
+ const start = id.start - 1;
+ const end = id.end - 1;
+ const last = ids[i - 1];
+ const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
+ if (leadingText.length || id.prefix) {
+ children.push(leadingText + (id.prefix || ``));
+ }
+ const source2 = rawExp.slice(start, end);
+ children.push(
+ createSimpleExpression(
+ id.name,
+ false,
+ {
+ source: source2,
+ start: advancePositionWithClone(node.loc.start, source2, start),
+ end: advancePositionWithClone(node.loc.start, source2, end)
+ },
+ id.isConstant ? 3 : 0
+ )
+ );
+ if (i === ids.length - 1 && end < rawExp.length) {
+ children.push(rawExp.slice(end));
+ }
+ });
+ let ret;
+ if (children.length) {
+ ret = createCompoundExpression(children, node.loc);
+ } else {
+ ret = node;
+ ret.constType = bailConstant ? 0 : 3;
+ }
+ ret.identifiers = Object.keys(knownIds);
+ return ret;
+}
+function canPrefix(id) {
+ if (shared.isGloballyAllowed(id.name)) {
+ return false;
+ }
+ if (id.name === "require") {
+ return false;
+ }
+ return true;
+}
+function stringifyExpression(exp) {
+ if (shared.isString(exp)) {
+ return exp;
+ } else if (exp.type === 4) {
+ return exp.content;
+ } else {
+ return exp.children.map(stringifyExpression).join("");
+ }
+}
+function isConst(type) {
+ return type === "setup-const" || type === "literal-const";
+}
+
+const transformIf = createStructuralDirectiveTransform(
+ /^(if|else|else-if)$/,
+ (node, dir, context) => {
+ return processIf(node, dir, context, (ifNode, branch, isRoot) => {
+ const siblings = context.parent.children;
+ let i = siblings.indexOf(ifNode);
+ let key = 0;
+ while (i-- >= 0) {
+ const sibling = siblings[i];
+ if (sibling && sibling.type === 9) {
+ key += sibling.branches.length;
+ }
+ }
+ return () => {
+ if (isRoot) {
+ ifNode.codegenNode = createCodegenNodeForBranch(
+ branch,
+ key,
+ context
+ );
+ } else {
+ const parentCondition = getParentCondition(ifNode.codegenNode);
+ parentCondition.alternate = createCodegenNodeForBranch(
+ branch,
+ key + ifNode.branches.length - 1,
+ context
+ );
+ }
+ };
+ });
+ }
+);
+function processIf(node, dir, context, processCodegen) {
+ if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
+ const loc = dir.exp ? dir.exp.loc : node.loc;
+ context.onError(
+ createCompilerError(28, dir.loc)
+ );
+ dir.exp = createSimpleExpression(`true`, false, loc);
+ }
+ if (context.prefixIdentifiers && dir.exp) {
+ dir.exp = processExpression(dir.exp, context);
+ }
+ if (dir.name === "if") {
+ const branch = createIfBranch(node, dir);
+ const ifNode = {
+ type: 9,
+ loc: node.loc,
+ branches: [branch]
+ };
+ context.replaceNode(ifNode);
+ if (processCodegen) {
+ return processCodegen(ifNode, branch, true);
+ }
+ } else {
+ const siblings = context.parent.children;
+ let i = siblings.indexOf(node);
+ while (i-- >= -1) {
+ const sibling = siblings[i];
+ if (sibling && sibling.type === 3) {
+ context.removeNode(sibling);
+ continue;
+ }
+ if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
+ context.removeNode(sibling);
+ continue;
+ }
+ if (sibling && sibling.type === 9) {
+ if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
+ context.onError(
+ createCompilerError(30, node.loc)
+ );
+ }
+ context.removeNode();
+ const branch = createIfBranch(node, dir);
+ {
+ const key = branch.userKey;
+ if (key) {
+ sibling.branches.forEach(({ userKey }) => {
+ if (isSameKey(userKey, key)) {
+ context.onError(
+ createCompilerError(
+ 29,
+ branch.userKey.loc
+ )
+ );
+ }
+ });
+ }
+ }
+ sibling.branches.push(branch);
+ const onExit = processCodegen && processCodegen(sibling, branch, false);
+ traverseNode(branch, context);
+ if (onExit)
+ onExit();
+ context.currentNode = null;
+ } else {
+ context.onError(
+ createCompilerError(30, node.loc)
+ );
+ }
+ break;
+ }
+ }
+}
+function createIfBranch(node, dir) {
+ const isTemplateIf = node.tagType === 3;
+ return {
+ type: 10,
+ loc: node.loc,
+ condition: dir.name === "else" ? void 0 : dir.exp,
+ children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
+ userKey: findProp(node, `key`),
+ isTemplateIf
+ };
+}
+function createCodegenNodeForBranch(branch, keyIndex, context) {
+ if (branch.condition) {
+ return createConditionalExpression(
+ branch.condition,
+ createChildrenCodegenNode(branch, keyIndex, context),
+ // make sure to pass in asBlock: true so that the comment node call
+ // closes the current block.
+ createCallExpression(context.helper(CREATE_COMMENT), [
+ '""',
+ "true"
+ ])
+ );
+ } else {
+ return createChildrenCodegenNode(branch, keyIndex, context);
+ }
+}
+function createChildrenCodegenNode(branch, keyIndex, context) {
+ const { helper } = context;
+ const keyProperty = createObjectProperty(
+ `key`,
+ createSimpleExpression(
+ `${keyIndex}`,
+ false,
+ locStub,
+ 2
+ )
+ );
+ const { children } = branch;
+ const firstChild = children[0];
+ const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
+ if (needFragmentWrapper) {
+ if (children.length === 1 && firstChild.type === 11) {
+ const vnodeCall = firstChild.codegenNode;
+ injectProp(vnodeCall, keyProperty, context);
+ return vnodeCall;
+ } else {
+ let patchFlag = 64;
+ shared.PatchFlagNames[64];
+ return createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ createObjectExpression([keyProperty]),
+ children,
+ patchFlag + (``),
+ void 0,
+ void 0,
+ true,
+ false,
+ false,
+ branch.loc
+ );
+ }
+ } else {
+ const ret = firstChild.codegenNode;
+ const vnodeCall = getMemoedVNodeCall(ret);
+ if (vnodeCall.type === 13) {
+ convertToBlock(vnodeCall, context);
+ }
+ injectProp(vnodeCall, keyProperty, context);
+ return ret;
+ }
+}
+function isSameKey(a, b) {
+ if (!a || a.type !== b.type) {
+ return false;
+ }
+ if (a.type === 6) {
+ if (a.value.content !== b.value.content) {
+ return false;
+ }
+ } else {
+ const exp = a.exp;
+ const branchExp = b.exp;
+ if (exp.type !== branchExp.type) {
+ return false;
+ }
+ if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
+ return false;
+ }
+ }
+ return true;
+}
+function getParentCondition(node) {
+ while (true) {
+ if (node.type === 19) {
+ if (node.alternate.type === 19) {
+ node = node.alternate;
+ } else {
+ return node;
+ }
+ } else if (node.type === 20) {
+ node = node.value;
+ }
+ }
+}
+
+const transformFor = createStructuralDirectiveTransform(
+ "for",
+ (node, dir, context) => {
+ const { helper, removeHelper } = context;
+ return processFor(node, dir, context, (forNode) => {
+ const renderExp = createCallExpression(helper(RENDER_LIST), [
+ forNode.source
+ ]);
+ const isTemplate = isTemplateNode(node);
+ const memo = findDir(node, "memo");
+ const keyProp = findProp(node, `key`);
+ const keyExp = keyProp && (keyProp.type === 6 ? createSimpleExpression(keyProp.value.content, true) : keyProp.exp);
+ const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;
+ if (isTemplate) {
+ if (memo) {
+ memo.exp = processExpression(
+ memo.exp,
+ context
+ );
+ }
+ if (keyProperty && keyProp.type !== 6) {
+ keyProperty.value = processExpression(
+ keyProperty.value,
+ context
+ );
+ }
+ }
+ const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
+ const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
+ forNode.codegenNode = createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ void 0,
+ renderExp,
+ fragmentFlag + (``),
+ void 0,
+ void 0,
+ true,
+ !isStableFragment,
+ false,
+ node.loc
+ );
+ return () => {
+ let childBlock;
+ const { children } = forNode;
+ if (isTemplate) {
+ node.children.some((c) => {
+ if (c.type === 1) {
+ const key = findProp(c, "key");
+ if (key) {
+ context.onError(
+ createCompilerError(
+ 33,
+ key.loc
+ )
+ );
+ return true;
+ }
+ }
+ });
+ }
+ const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
+ const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
+ if (slotOutlet) {
+ childBlock = slotOutlet.codegenNode;
+ if (isTemplate && keyProperty) {
+ injectProp(childBlock, keyProperty, context);
+ }
+ } else if (needFragmentWrapper) {
+ childBlock = createVNodeCall(
+ context,
+ helper(FRAGMENT),
+ keyProperty ? createObjectExpression([keyProperty]) : void 0,
+ node.children,
+ 64 + (``),
+ void 0,
+ void 0,
+ true,
+ void 0,
+ false
+ /* isComponent */
+ );
+ } else {
+ childBlock = children[0].codegenNode;
+ if (isTemplate && keyProperty) {
+ injectProp(childBlock, keyProperty, context);
+ }
+ if (childBlock.isBlock !== !isStableFragment) {
+ if (childBlock.isBlock) {
+ removeHelper(OPEN_BLOCK);
+ removeHelper(
+ getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
+ );
+ } else {
+ removeHelper(
+ getVNodeHelper(context.inSSR, childBlock.isComponent)
+ );
+ }
+ }
+ childBlock.isBlock = !isStableFragment;
+ if (childBlock.isBlock) {
+ helper(OPEN_BLOCK);
+ helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
+ } else {
+ helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
+ }
+ }
+ if (memo) {
+ const loop = createFunctionExpression(
+ createForLoopParams(forNode.parseResult, [
+ createSimpleExpression(`_cached`)
+ ])
+ );
+ loop.body = createBlockStatement([
+ createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
+ createCompoundExpression([
+ `if (_cached`,
+ ...keyExp ? [` && _cached.key === `, keyExp] : [],
+ ` && ${context.helperString(
+ IS_MEMO_SAME
+ )}(_cached, _memo)) return _cached`
+ ]),
+ createCompoundExpression([`const _item = `, childBlock]),
+ createSimpleExpression(`_item.memo = _memo`),
+ createSimpleExpression(`return _item`)
+ ]);
+ renderExp.arguments.push(
+ loop,
+ createSimpleExpression(`_cache`),
+ createSimpleExpression(String(context.cached++))
+ );
+ } else {
+ renderExp.arguments.push(
+ createFunctionExpression(
+ createForLoopParams(forNode.parseResult),
+ childBlock,
+ true
+ /* force newline */
+ )
+ );
+ }
+ };
+ });
+ }
+);
+function processFor(node, dir, context, processCodegen) {
+ if (!dir.exp) {
+ context.onError(
+ createCompilerError(31, dir.loc)
+ );
+ return;
+ }
+ const parseResult = parseForExpression(
+ // can only be simple expression because vFor transform is applied
+ // before expression transform.
+ dir.exp,
+ context
+ );
+ if (!parseResult) {
+ context.onError(
+ createCompilerError(32, dir.loc)
+ );
+ return;
+ }
+ const { addIdentifiers, removeIdentifiers, scopes } = context;
+ const { source, value, key, index } = parseResult;
+ const forNode = {
+ type: 11,
+ loc: dir.loc,
+ source,
+ valueAlias: value,
+ keyAlias: key,
+ objectIndexAlias: index,
+ parseResult,
+ children: isTemplateNode(node) ? node.children : [node]
+ };
+ context.replaceNode(forNode);
+ scopes.vFor++;
+ if (context.prefixIdentifiers) {
+ value && addIdentifiers(value);
+ key && addIdentifiers(key);
+ index && addIdentifiers(index);
+ }
+ const onExit = processCodegen && processCodegen(forNode);
+ return () => {
+ scopes.vFor--;
+ if (context.prefixIdentifiers) {
+ value && removeIdentifiers(value);
+ key && removeIdentifiers(key);
+ index && removeIdentifiers(index);
+ }
+ if (onExit)
+ onExit();
+ };
+}
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+function parseForExpression(input, context) {
+ const loc = input.loc;
+ const exp = input.content;
+ const inMatch = exp.match(forAliasRE);
+ if (!inMatch)
+ return;
+ const [, LHS, RHS] = inMatch;
+ const result = {
+ source: createAliasExpression(
+ loc,
+ RHS.trim(),
+ exp.indexOf(RHS, LHS.length)
+ ),
+ value: void 0,
+ key: void 0,
+ index: void 0
+ };
+ if (context.prefixIdentifiers) {
+ result.source = processExpression(
+ result.source,
+ context
+ );
+ }
+ let valueContent = LHS.trim().replace(stripParensRE, "").trim();
+ const trimmedOffset = LHS.indexOf(valueContent);
+ const iteratorMatch = valueContent.match(forIteratorRE);
+ if (iteratorMatch) {
+ valueContent = valueContent.replace(forIteratorRE, "").trim();
+ const keyContent = iteratorMatch[1].trim();
+ let keyOffset;
+ if (keyContent) {
+ keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
+ result.key = createAliasExpression(loc, keyContent, keyOffset);
+ if (context.prefixIdentifiers) {
+ result.key = processExpression(result.key, context, true);
+ }
+ }
+ if (iteratorMatch[2]) {
+ const indexContent = iteratorMatch[2].trim();
+ if (indexContent) {
+ result.index = createAliasExpression(
+ loc,
+ indexContent,
+ exp.indexOf(
+ indexContent,
+ result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
+ )
+ );
+ if (context.prefixIdentifiers) {
+ result.index = processExpression(result.index, context, true);
+ }
+ }
+ }
+ }
+ if (valueContent) {
+ result.value = createAliasExpression(loc, valueContent, trimmedOffset);
+ if (context.prefixIdentifiers) {
+ result.value = processExpression(result.value, context, true);
+ }
+ }
+ return result;
+}
+function createAliasExpression(range, content, offset) {
+ return createSimpleExpression(
+ content,
+ false,
+ getInnerRange(range, offset, content.length)
+ );
+}
+function createForLoopParams({ value, key, index }, memoArgs = []) {
+ return createParamsList([value, key, index, ...memoArgs]);
+}
+function createParamsList(args) {
+ let i = args.length;
+ while (i--) {
+ if (args[i])
+ break;
+ }
+ return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
+}
+
+const defaultFallback = createSimpleExpression(`undefined`, false);
+const trackSlotScopes = (node, context) => {
+ if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
+ const vSlot = findDir(node, "slot");
+ if (vSlot) {
+ const slotProps = vSlot.exp;
+ if (context.prefixIdentifiers) {
+ slotProps && context.addIdentifiers(slotProps);
+ }
+ context.scopes.vSlot++;
+ return () => {
+ if (context.prefixIdentifiers) {
+ slotProps && context.removeIdentifiers(slotProps);
+ }
+ context.scopes.vSlot--;
+ };
+ }
+ }
+};
+const trackVForSlotScopes = (node, context) => {
+ let vFor;
+ if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
+ const result = vFor.parseResult = parseForExpression(
+ vFor.exp,
+ context
+ );
+ if (result) {
+ const { value, key, index } = result;
+ const { addIdentifiers, removeIdentifiers } = context;
+ value && addIdentifiers(value);
+ key && addIdentifiers(key);
+ index && addIdentifiers(index);
+ return () => {
+ value && removeIdentifiers(value);
+ key && removeIdentifiers(key);
+ index && removeIdentifiers(index);
+ };
+ }
+ }
+};
+const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(
+ props,
+ children,
+ false,
+ true,
+ children.length ? children[0].loc : loc
+);
+function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
+ context.helper(WITH_CTX);
+ const { children, loc } = node;
+ const slotsProperties = [];
+ const dynamicSlots = [];
+ let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
+ if (!context.ssr && context.prefixIdentifiers) {
+ hasDynamicSlots = hasScopeRef(node, context.identifiers);
+ }
+ const onComponentSlot = findDir(node, "slot", true);
+ if (onComponentSlot) {
+ const { arg, exp } = onComponentSlot;
+ if (arg && !isStaticExp(arg)) {
+ hasDynamicSlots = true;
+ }
+ slotsProperties.push(
+ createObjectProperty(
+ arg || createSimpleExpression("default", true),
+ buildSlotFn(exp, void 0, children, loc)
+ )
+ );
+ }
+ let hasTemplateSlots = false;
+ let hasNamedDefaultSlot = false;
+ const implicitDefaultChildren = [];
+ const seenSlotNames = /* @__PURE__ */ new Set();
+ let conditionalBranchIndex = 0;
+ for (let i = 0; i < children.length; i++) {
+ const slotElement = children[i];
+ let slotDir;
+ if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
+ if (slotElement.type !== 3) {
+ implicitDefaultChildren.push(slotElement);
+ }
+ continue;
+ }
+ if (onComponentSlot) {
+ context.onError(
+ createCompilerError(37, slotDir.loc)
+ );
+ break;
+ }
+ hasTemplateSlots = true;
+ const { children: slotChildren, loc: slotLoc } = slotElement;
+ const {
+ arg: slotName = createSimpleExpression(`default`, true),
+ exp: slotProps,
+ loc: dirLoc
+ } = slotDir;
+ let staticSlotName;
+ if (isStaticExp(slotName)) {
+ staticSlotName = slotName ? slotName.content : `default`;
+ } else {
+ hasDynamicSlots = true;
+ }
+ const vFor = findDir(slotElement, "for");
+ const slotFunction = buildSlotFn(
+ slotProps,
+ vFor == null ? void 0 : vFor.exp,
+ slotChildren,
+ slotLoc
+ );
+ let vIf;
+ let vElse;
+ if (vIf = findDir(slotElement, "if")) {
+ hasDynamicSlots = true;
+ dynamicSlots.push(
+ createConditionalExpression(
+ vIf.exp,
+ buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
+ defaultFallback
+ )
+ );
+ } else if (vElse = findDir(
+ slotElement,
+ /^else(-if)?$/,
+ true
+ /* allowEmpty */
+ )) {
+ let j = i;
+ let prev;
+ while (j--) {
+ prev = children[j];
+ if (prev.type !== 3) {
+ break;
+ }
+ }
+ if (prev && isTemplateNode(prev) && findDir(prev, "if")) {
+ children.splice(i, 1);
+ i--;
+ let conditional = dynamicSlots[dynamicSlots.length - 1];
+ while (conditional.alternate.type === 19) {
+ conditional = conditional.alternate;
+ }
+ conditional.alternate = vElse.exp ? createConditionalExpression(
+ vElse.exp,
+ buildDynamicSlot(
+ slotName,
+ slotFunction,
+ conditionalBranchIndex++
+ ),
+ defaultFallback
+ ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
+ } else {
+ context.onError(
+ createCompilerError(30, vElse.loc)
+ );
+ }
+ } else if (vFor) {
+ hasDynamicSlots = true;
+ const parseResult = vFor.parseResult || parseForExpression(vFor.exp, context);
+ if (parseResult) {
+ dynamicSlots.push(
+ createCallExpression(context.helper(RENDER_LIST), [
+ parseResult.source,
+ createFunctionExpression(
+ createForLoopParams(parseResult),
+ buildDynamicSlot(slotName, slotFunction),
+ true
+ /* force newline */
+ )
+ ])
+ );
+ } else {
+ context.onError(
+ createCompilerError(32, vFor.loc)
+ );
+ }
+ } else {
+ if (staticSlotName) {
+ if (seenSlotNames.has(staticSlotName)) {
+ context.onError(
+ createCompilerError(
+ 38,
+ dirLoc
+ )
+ );
+ continue;
+ }
+ seenSlotNames.add(staticSlotName);
+ if (staticSlotName === "default") {
+ hasNamedDefaultSlot = true;
+ }
+ }
+ slotsProperties.push(createObjectProperty(slotName, slotFunction));
+ }
+ }
+ if (!onComponentSlot) {
+ const buildDefaultSlotProperty = (props, children2) => {
+ const fn = buildSlotFn(props, void 0, children2, loc);
+ if (context.compatConfig) {
+ fn.isNonScopedSlot = true;
+ }
+ return createObjectProperty(`default`, fn);
+ };
+ if (!hasTemplateSlots) {
+ slotsProperties.push(buildDefaultSlotProperty(void 0, children));
+ } else if (implicitDefaultChildren.length && // #3766
+ // with whitespace: 'preserve', whitespaces between slots will end up in
+ // implicitDefaultChildren. Ignore if all implicit children are whitespaces.
+ implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
+ if (hasNamedDefaultSlot) {
+ context.onError(
+ createCompilerError(
+ 39,
+ implicitDefaultChildren[0].loc
+ )
+ );
+ } else {
+ slotsProperties.push(
+ buildDefaultSlotProperty(void 0, implicitDefaultChildren)
+ );
+ }
+ }
+ }
+ const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
+ let slots = createObjectExpression(
+ slotsProperties.concat(
+ createObjectProperty(
+ `_`,
+ // 2 = compiled but dynamic = can skip normalization, but must run diff
+ // 1 = compiled and static = can skip normalization AND diff as optimized
+ createSimpleExpression(
+ slotFlag + (``),
+ false
+ )
+ )
+ ),
+ loc
+ );
+ if (dynamicSlots.length) {
+ slots = createCallExpression(context.helper(CREATE_SLOTS), [
+ slots,
+ createArrayExpression(dynamicSlots)
+ ]);
+ }
+ return {
+ slots,
+ hasDynamicSlots
+ };
+}
+function buildDynamicSlot(name, fn, index) {
+ const props = [
+ createObjectProperty(`name`, name),
+ createObjectProperty(`fn`, fn)
+ ];
+ if (index != null) {
+ props.push(
+ createObjectProperty(`key`, createSimpleExpression(String(index), true))
+ );
+ }
+ return createObjectExpression(props);
+}
+function hasForwardedSlots(children) {
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ switch (child.type) {
+ case 1:
+ if (child.tagType === 2 || hasForwardedSlots(child.children)) {
+ return true;
+ }
+ break;
+ case 9:
+ if (hasForwardedSlots(child.branches))
+ return true;
+ break;
+ case 10:
+ case 11:
+ if (hasForwardedSlots(child.children))
+ return true;
+ break;
+ }
+ }
+ return false;
+}
+function isNonWhitespaceContent(node) {
+ if (node.type !== 2 && node.type !== 12)
+ return true;
+ return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
+}
+
+const directiveImportMap = /* @__PURE__ */ new WeakMap();
+const transformElement = (node, context) => {
+ return function postTransformElement() {
+ node = context.currentNode;
+ if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
+ return;
+ }
+ const { tag, props } = node;
+ const isComponent = node.tagType === 1;
+ let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
+ const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
+ let vnodeProps;
+ let vnodeChildren;
+ let vnodePatchFlag;
+ let patchFlag = 0;
+ let vnodeDynamicProps;
+ let dynamicPropNames;
+ let vnodeDirectives;
+ let shouldUseBlock = (
+ // dynamic component may resolve to plain elements
+ isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
+ // updates inside get proper isSVG flag at runtime. (#639, #643)
+ // This is technically web-specific, but splitting the logic out of core
+ // leads to too much unnecessary complexity.
+ (tag === "svg" || tag === "foreignObject")
+ );
+ if (props.length > 0) {
+ const propsBuildResult = buildProps(
+ node,
+ context,
+ void 0,
+ isComponent,
+ isDynamicComponent
+ );
+ vnodeProps = propsBuildResult.props;
+ patchFlag = propsBuildResult.patchFlag;
+ dynamicPropNames = propsBuildResult.dynamicPropNames;
+ const directives = propsBuildResult.directives;
+ vnodeDirectives = directives && directives.length ? createArrayExpression(
+ directives.map((dir) => buildDirectiveArgs(dir, context))
+ ) : void 0;
+ if (propsBuildResult.shouldUseBlock) {
+ shouldUseBlock = true;
+ }
+ }
+ if (node.children.length > 0) {
+ if (vnodeTag === KEEP_ALIVE) {
+ shouldUseBlock = true;
+ patchFlag |= 1024;
+ }
+ const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
+ vnodeTag !== TELEPORT && // explained above.
+ vnodeTag !== KEEP_ALIVE;
+ if (shouldBuildAsSlots) {
+ const { slots, hasDynamicSlots } = buildSlots(node, context);
+ vnodeChildren = slots;
+ if (hasDynamicSlots) {
+ patchFlag |= 1024;
+ }
+ } else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
+ const child = node.children[0];
+ const type = child.type;
+ const hasDynamicTextChild = type === 5 || type === 8;
+ if (hasDynamicTextChild && getConstantType(child, context) === 0) {
+ patchFlag |= 1;
+ }
+ if (hasDynamicTextChild || type === 2) {
+ vnodeChildren = child;
+ } else {
+ vnodeChildren = node.children;
+ }
+ } else {
+ vnodeChildren = node.children;
+ }
+ }
+ if (patchFlag !== 0) {
+ {
+ vnodePatchFlag = String(patchFlag);
+ }
+ if (dynamicPropNames && dynamicPropNames.length) {
+ vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
+ }
+ }
+ node.codegenNode = createVNodeCall(
+ context,
+ vnodeTag,
+ vnodeProps,
+ vnodeChildren,
+ vnodePatchFlag,
+ vnodeDynamicProps,
+ vnodeDirectives,
+ !!shouldUseBlock,
+ false,
+ isComponent,
+ node.loc
+ );
+ };
+};
+function resolveComponentType(node, context, ssr = false) {
+ let { tag } = node;
+ const isExplicitDynamic = isComponentTag(tag);
+ const isProp = findProp(node, "is");
+ if (isProp) {
+ if (isExplicitDynamic || isCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context
+ )) {
+ const exp = isProp.type === 6 ? isProp.value && createSimpleExpression(isProp.value.content, true) : isProp.exp;
+ if (exp) {
+ return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
+ exp
+ ]);
+ }
+ } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
+ tag = isProp.value.content.slice(4);
+ }
+ }
+ const isDir = !isExplicitDynamic && findDir(node, "is");
+ if (isDir && isDir.exp) {
+ return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
+ isDir.exp
+ ]);
+ }
+ const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
+ if (builtIn) {
+ if (!ssr)
+ context.helper(builtIn);
+ return builtIn;
+ }
+ {
+ const fromSetup = resolveSetupReference(tag, context);
+ if (fromSetup) {
+ return fromSetup;
+ }
+ const dotIndex = tag.indexOf(".");
+ if (dotIndex > 0) {
+ const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
+ if (ns) {
+ return ns + tag.slice(dotIndex);
+ }
+ }
+ }
+ if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) {
+ context.helper(RESOLVE_COMPONENT);
+ context.components.add(tag + `__self`);
+ return toValidAssetId(tag, `component`);
+ }
+ context.helper(RESOLVE_COMPONENT);
+ context.components.add(tag);
+ return toValidAssetId(tag, `component`);
+}
+function resolveSetupReference(name, context) {
+ const bindings = context.bindingMetadata;
+ if (!bindings || bindings.__isScriptSetup === false) {
+ return;
+ }
+ const camelName = shared.camelize(name);
+ const PascalName = shared.capitalize(camelName);
+ const checkType = (type) => {
+ if (bindings[name] === type) {
+ return name;
+ }
+ if (bindings[camelName] === type) {
+ return camelName;
+ }
+ if (bindings[PascalName] === type) {
+ return PascalName;
+ }
+ };
+ const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const");
+ if (fromConst) {
+ return context.inline ? (
+ // in inline mode, const setup bindings (e.g. imports) can be used as-is
+ fromConst
+ ) : `$setup[${JSON.stringify(fromConst)}]`;
+ }
+ const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref");
+ if (fromMaybeRef) {
+ return context.inline ? (
+ // setup scope bindings that may be refs need to be unrefed
+ `${context.helperString(UNREF)}(${fromMaybeRef})`
+ ) : `$setup[${JSON.stringify(fromMaybeRef)}]`;
+ }
+}
+function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
+ const { tag, loc: elementLoc, children } = node;
+ let properties = [];
+ const mergeArgs = [];
+ const runtimeDirectives = [];
+ const hasChildren = children.length > 0;
+ let shouldUseBlock = false;
+ let patchFlag = 0;
+ let hasRef = false;
+ let hasClassBinding = false;
+ let hasStyleBinding = false;
+ let hasHydrationEventBinding = false;
+ let hasDynamicKeys = false;
+ let hasVnodeHook = false;
+ const dynamicPropNames = [];
+ const pushMergeArg = (arg) => {
+ if (properties.length) {
+ mergeArgs.push(
+ createObjectExpression(dedupeProperties(properties), elementLoc)
+ );
+ properties = [];
+ }
+ if (arg)
+ mergeArgs.push(arg);
+ };
+ const analyzePatchFlag = ({ key, value }) => {
+ if (isStaticExp(key)) {
+ const name = key.content;
+ const isEventHandler = shared.isOn(name);
+ if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
+ // dedicated fast path.
+ name.toLowerCase() !== "onclick" && // omit v-model handlers
+ name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
+ !shared.isReservedProp(name)) {
+ hasHydrationEventBinding = true;
+ }
+ if (isEventHandler && shared.isReservedProp(name)) {
+ hasVnodeHook = true;
+ }
+ if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
+ return;
+ }
+ if (name === "ref") {
+ hasRef = true;
+ } else if (name === "class") {
+ hasClassBinding = true;
+ } else if (name === "style") {
+ hasStyleBinding = true;
+ } else if (name !== "key" && !dynamicPropNames.includes(name)) {
+ dynamicPropNames.push(name);
+ }
+ if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
+ dynamicPropNames.push(name);
+ }
+ } else {
+ hasDynamicKeys = true;
+ }
+ };
+ for (let i = 0; i < props.length; i++) {
+ const prop = props[i];
+ if (prop.type === 6) {
+ const { loc, name, value } = prop;
+ let isStatic = true;
+ if (name === "ref") {
+ hasRef = true;
+ if (context.scopes.vFor > 0) {
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression("ref_for", true),
+ createSimpleExpression("true")
+ )
+ );
+ }
+ if (value && context.inline) {
+ const binding = context.bindingMetadata[value.content];
+ if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") {
+ isStatic = false;
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression("ref_key", true),
+ createSimpleExpression(value.content, true, value.loc)
+ )
+ );
+ }
+ }
+ }
+ if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context
+ ))) {
+ continue;
+ }
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression(
+ name,
+ true,
+ getInnerRange(loc, 0, name.length)
+ ),
+ createSimpleExpression(
+ value ? value.content : "",
+ isStatic,
+ value ? value.loc : loc
+ )
+ )
+ );
+ } else {
+ const { name, arg, exp, loc, modifiers } = prop;
+ const isVBind = name === "bind";
+ const isVOn = name === "on";
+ if (name === "slot") {
+ if (!isComponent) {
+ context.onError(
+ createCompilerError(40, loc)
+ );
+ }
+ continue;
+ }
+ if (name === "once" || name === "memo") {
+ continue;
+ }
+ if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled(
+ "COMPILER_IS_ON_ELEMENT",
+ context
+ ))) {
+ continue;
+ }
+ if (isVOn && ssr) {
+ continue;
+ }
+ if (
+ // #938: elements with dynamic keys should be forced into blocks
+ isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
+ // before children
+ isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
+ ) {
+ shouldUseBlock = true;
+ }
+ if (isVBind && isStaticArgOf(arg, "ref") && context.scopes.vFor > 0) {
+ properties.push(
+ createObjectProperty(
+ createSimpleExpression("ref_for", true),
+ createSimpleExpression("true")
+ )
+ );
+ }
+ if (!arg && (isVBind || isVOn)) {
+ hasDynamicKeys = true;
+ if (exp) {
+ if (isVBind) {
+ pushMergeArg();
+ {
+ if (isCompatEnabled(
+ "COMPILER_V_BIND_OBJECT_ORDER",
+ context
+ )) {
+ mergeArgs.unshift(exp);
+ continue;
+ }
+ }
+ mergeArgs.push(exp);
+ } else {
+ pushMergeArg({
+ type: 14,
+ loc,
+ callee: context.helper(TO_HANDLERS),
+ arguments: isComponent ? [exp] : [exp, `true`]
+ });
+ }
+ } else {
+ context.onError(
+ createCompilerError(
+ isVBind ? 34 : 35,
+ loc
+ )
+ );
+ }
+ continue;
+ }
+ if (isVBind && modifiers.includes("prop")) {
+ patchFlag |= 32;
+ }
+ const directiveTransform = context.directiveTransforms[name];
+ if (directiveTransform) {
+ const { props: props2, needRuntime } = directiveTransform(prop, node, context);
+ !ssr && props2.forEach(analyzePatchFlag);
+ if (isVOn && arg && !isStaticExp(arg)) {
+ pushMergeArg(createObjectExpression(props2, elementLoc));
+ } else {
+ properties.push(...props2);
+ }
+ if (needRuntime) {
+ runtimeDirectives.push(prop);
+ if (shared.isSymbol(needRuntime)) {
+ directiveImportMap.set(prop, needRuntime);
+ }
+ }
+ } else if (!shared.isBuiltInDirective(name)) {
+ runtimeDirectives.push(prop);
+ if (hasChildren) {
+ shouldUseBlock = true;
+ }
+ }
+ }
+ }
+ let propsExpression = void 0;
+ if (mergeArgs.length) {
+ pushMergeArg();
+ if (mergeArgs.length > 1) {
+ propsExpression = createCallExpression(
+ context.helper(MERGE_PROPS),
+ mergeArgs,
+ elementLoc
+ );
+ } else {
+ propsExpression = mergeArgs[0];
+ }
+ } else if (properties.length) {
+ propsExpression = createObjectExpression(
+ dedupeProperties(properties),
+ elementLoc
+ );
+ }
+ if (hasDynamicKeys) {
+ patchFlag |= 16;
+ } else {
+ if (hasClassBinding && !isComponent) {
+ patchFlag |= 2;
+ }
+ if (hasStyleBinding && !isComponent) {
+ patchFlag |= 4;
+ }
+ if (dynamicPropNames.length) {
+ patchFlag |= 8;
+ }
+ if (hasHydrationEventBinding) {
+ patchFlag |= 32;
+ }
+ }
+ if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
+ patchFlag |= 512;
+ }
+ if (!context.inSSR && propsExpression) {
+ switch (propsExpression.type) {
+ case 15:
+ let classKeyIndex = -1;
+ let styleKeyIndex = -1;
+ let hasDynamicKey = false;
+ for (let i = 0; i < propsExpression.properties.length; i++) {
+ const key = propsExpression.properties[i].key;
+ if (isStaticExp(key)) {
+ if (key.content === "class") {
+ classKeyIndex = i;
+ } else if (key.content === "style") {
+ styleKeyIndex = i;
+ }
+ } else if (!key.isHandlerKey) {
+ hasDynamicKey = true;
+ }
+ }
+ const classProp = propsExpression.properties[classKeyIndex];
+ const styleProp = propsExpression.properties[styleKeyIndex];
+ if (!hasDynamicKey) {
+ if (classProp && !isStaticExp(classProp.value)) {
+ classProp.value = createCallExpression(
+ context.helper(NORMALIZE_CLASS),
+ [classProp.value]
+ );
+ }
+ if (styleProp && // the static style is compiled into an object,
+ // so use `hasStyleBinding` to ensure that it is a dynamic style binding
+ (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
+ // v-bind:style with static literal object
+ styleProp.value.type === 17)) {
+ styleProp.value = createCallExpression(
+ context.helper(NORMALIZE_STYLE),
+ [styleProp.value]
+ );
+ }
+ } else {
+ propsExpression = createCallExpression(
+ context.helper(NORMALIZE_PROPS),
+ [propsExpression]
+ );
+ }
+ break;
+ case 14:
+ break;
+ default:
+ propsExpression = createCallExpression(
+ context.helper(NORMALIZE_PROPS),
+ [
+ createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
+ propsExpression
+ ])
+ ]
+ );
+ break;
+ }
+ }
+ return {
+ props: propsExpression,
+ directives: runtimeDirectives,
+ patchFlag,
+ dynamicPropNames,
+ shouldUseBlock
+ };
+}
+function dedupeProperties(properties) {
+ const knownProps = /* @__PURE__ */ new Map();
+ const deduped = [];
+ for (let i = 0; i < properties.length; i++) {
+ const prop = properties[i];
+ if (prop.key.type === 8 || !prop.key.isStatic) {
+ deduped.push(prop);
+ continue;
+ }
+ const name = prop.key.content;
+ const existing = knownProps.get(name);
+ if (existing) {
+ if (name === "style" || name === "class" || shared.isOn(name)) {
+ mergeAsArray(existing, prop);
+ }
+ } else {
+ knownProps.set(name, prop);
+ deduped.push(prop);
+ }
+ }
+ return deduped;
+}
+function mergeAsArray(existing, incoming) {
+ if (existing.value.type === 17) {
+ existing.value.elements.push(incoming.value);
+ } else {
+ existing.value = createArrayExpression(
+ [existing.value, incoming.value],
+ existing.loc
+ );
+ }
+}
+function buildDirectiveArgs(dir, context) {
+ const dirArgs = [];
+ const runtime = directiveImportMap.get(dir);
+ if (runtime) {
+ dirArgs.push(context.helperString(runtime));
+ } else {
+ const fromSetup = resolveSetupReference("v-" + dir.name, context);
+ if (fromSetup) {
+ dirArgs.push(fromSetup);
+ } else {
+ context.helper(RESOLVE_DIRECTIVE);
+ context.directives.add(dir.name);
+ dirArgs.push(toValidAssetId(dir.name, `directive`));
+ }
+ }
+ const { loc } = dir;
+ if (dir.exp)
+ dirArgs.push(dir.exp);
+ if (dir.arg) {
+ if (!dir.exp) {
+ dirArgs.push(`void 0`);
+ }
+ dirArgs.push(dir.arg);
+ }
+ if (Object.keys(dir.modifiers).length) {
+ if (!dir.arg) {
+ if (!dir.exp) {
+ dirArgs.push(`void 0`);
+ }
+ dirArgs.push(`void 0`);
+ }
+ const trueExpression = createSimpleExpression(`true`, false, loc);
+ dirArgs.push(
+ createObjectExpression(
+ dir.modifiers.map(
+ (modifier) => createObjectProperty(modifier, trueExpression)
+ ),
+ loc
+ )
+ );
+ }
+ return createArrayExpression(dirArgs, dir.loc);
+}
+function stringifyDynamicPropNames(props) {
+ let propsNamesString = `[`;
+ for (let i = 0, l = props.length; i < l; i++) {
+ propsNamesString += JSON.stringify(props[i]);
+ if (i < l - 1)
+ propsNamesString += ", ";
+ }
+ return propsNamesString + `]`;
+}
+function isComponentTag(tag) {
+ return tag === "component" || tag === "Component";
+}
+
+const transformSlotOutlet = (node, context) => {
+ if (isSlotOutlet(node)) {
+ const { children, loc } = node;
+ const { slotName, slotProps } = processSlotOutlet(node, context);
+ const slotArgs = [
+ context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
+ slotName,
+ "{}",
+ "undefined",
+ "true"
+ ];
+ let expectedLen = 2;
+ if (slotProps) {
+ slotArgs[2] = slotProps;
+ expectedLen = 3;
+ }
+ if (children.length) {
+ slotArgs[3] = createFunctionExpression([], children, false, false, loc);
+ expectedLen = 4;
+ }
+ if (context.scopeId && !context.slotted) {
+ expectedLen = 5;
+ }
+ slotArgs.splice(expectedLen);
+ node.codegenNode = createCallExpression(
+ context.helper(RENDER_SLOT),
+ slotArgs,
+ loc
+ );
+ }
+};
+function processSlotOutlet(node, context) {
+ let slotName = `"default"`;
+ let slotProps = void 0;
+ const nonNameProps = [];
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 6) {
+ if (p.value) {
+ if (p.name === "name") {
+ slotName = JSON.stringify(p.value.content);
+ } else {
+ p.name = shared.camelize(p.name);
+ nonNameProps.push(p);
+ }
+ }
+ } else {
+ if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
+ if (p.exp)
+ slotName = p.exp;
+ } else {
+ if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
+ p.arg.content = shared.camelize(p.arg.content);
+ }
+ nonNameProps.push(p);
+ }
+ }
+ }
+ if (nonNameProps.length > 0) {
+ const { props, directives } = buildProps(
+ node,
+ context,
+ nonNameProps,
+ false,
+ false
+ );
+ slotProps = props;
+ if (directives.length) {
+ context.onError(
+ createCompilerError(
+ 36,
+ directives[0].loc
+ )
+ );
+ }
+ }
+ return {
+ slotName,
+ slotProps
+ };
+}
+
+const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+const transformOn = (dir, node, context, augmentor) => {
+ const { loc, modifiers, arg } = dir;
+ if (!dir.exp && !modifiers.length) {
+ context.onError(createCompilerError(35, loc));
+ }
+ let eventName;
+ if (arg.type === 4) {
+ if (arg.isStatic) {
+ let rawName = arg.content;
+ if (rawName.startsWith("vue:")) {
+ rawName = `vnode-${rawName.slice(4)}`;
+ }
+ const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
+ // for non-element and vnode lifecycle event listeners, auto convert
+ // it to camelCase. See issue #2249
+ shared.toHandlerKey(shared.camelize(rawName))
+ ) : (
+ // preserve case for plain element listeners that have uppercase
+ // letters, as these may be custom elements' custom events
+ `on:${rawName}`
+ );
+ eventName = createSimpleExpression(eventString, true, arg.loc);
+ } else {
+ eventName = createCompoundExpression([
+ `${context.helperString(TO_HANDLER_KEY)}(`,
+ arg,
+ `)`
+ ]);
+ }
+ } else {
+ eventName = arg;
+ eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
+ eventName.children.push(`)`);
+ }
+ let exp = dir.exp;
+ if (exp && !exp.content.trim()) {
+ exp = void 0;
+ }
+ let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
+ if (exp) {
+ const isMemberExp = isMemberExpression(exp.content, context);
+ const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
+ const hasMultipleStatements = exp.content.includes(`;`);
+ if (context.prefixIdentifiers) {
+ isInlineStatement && context.addIdentifiers(`$event`);
+ exp = dir.exp = processExpression(
+ exp,
+ context,
+ false,
+ hasMultipleStatements
+ );
+ isInlineStatement && context.removeIdentifiers(`$event`);
+ shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once
+ !context.inVOnce && // runtime constants don't need to be cached
+ // (this is analyzed by compileScript in SFC <script setup>)
+ !(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component -
+ // we need to use the original function to preserve arity,
+ // e.g. <transition> relies on checking cb.length to determine
+ // transition end handling. Inline function is ok since its arity
+ // is preserved even when cached.
+ !(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot)
+ // it must be passed fresh to avoid stale values.
+ !hasScopeRef(exp, context.identifiers);
+ if (shouldCache && isMemberExp) {
+ if (exp.type === 4) {
+ exp.content = `${exp.content} && ${exp.content}(...args)`;
+ } else {
+ exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];
+ }
+ }
+ }
+ if (isInlineStatement || shouldCache && isMemberExp) {
+ exp = createCompoundExpression([
+ `${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `
+//@ts-ignore
+` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
+ exp,
+ hasMultipleStatements ? `}` : `)`
+ ]);
+ }
+ }
+ let ret = {
+ props: [
+ createObjectProperty(
+ eventName,
+ exp || createSimpleExpression(`() => {}`, false, loc)
+ )
+ ]
+ };
+ if (augmentor) {
+ ret = augmentor(ret);
+ }
+ if (shouldCache) {
+ ret.props[0].value = context.cache(ret.props[0].value);
+ }
+ ret.props.forEach((p) => p.key.isHandlerKey = true);
+ return ret;
+};
+
+const transformBind = (dir, _node, context) => {
+ const { exp, modifiers, loc } = dir;
+ const arg = dir.arg;
+ if (arg.type !== 4) {
+ arg.children.unshift(`(`);
+ arg.children.push(`) || ""`);
+ } else if (!arg.isStatic) {
+ arg.content = `${arg.content} || ""`;
+ }
+ if (modifiers.includes("camel")) {
+ if (arg.type === 4) {
+ if (arg.isStatic) {
+ arg.content = shared.camelize(arg.content);
+ } else {
+ arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
+ }
+ } else {
+ arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
+ arg.children.push(`)`);
+ }
+ }
+ if (!context.inSSR) {
+ if (modifiers.includes("prop")) {
+ injectPrefix(arg, ".");
+ }
+ if (modifiers.includes("attr")) {
+ injectPrefix(arg, "^");
+ }
+ }
+ if (!exp || exp.type === 4 && !exp.content.trim()) {
+ context.onError(createCompilerError(34, loc));
+ return {
+ props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
+ };
+ }
+ return {
+ props: [createObjectProperty(arg, exp)]
+ };
+};
+const injectPrefix = (arg, prefix) => {
+ if (arg.type === 4) {
+ if (arg.isStatic) {
+ arg.content = prefix + arg.content;
+ } else {
+ arg.content = `\`${prefix}\${${arg.content}}\``;
+ }
+ } else {
+ arg.children.unshift(`'${prefix}' + (`);
+ arg.children.push(`)`);
+ }
+};
+
+const transformText = (node, context) => {
+ if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
+ return () => {
+ const children = node.children;
+ let currentContainer = void 0;
+ let hasText = false;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isText$1(child)) {
+ hasText = true;
+ for (let j = i + 1; j < children.length; j++) {
+ const next = children[j];
+ if (isText$1(next)) {
+ if (!currentContainer) {
+ currentContainer = children[i] = createCompoundExpression(
+ [child],
+ child.loc
+ );
+ }
+ currentContainer.children.push(` + `, next);
+ children.splice(j, 1);
+ j--;
+ } else {
+ currentContainer = void 0;
+ break;
+ }
+ }
+ }
+ }
+ if (!hasText || // if this is a plain element with a single text child, leave it
+ // as-is since the runtime has dedicated fast path for this by directly
+ // setting textContent of the element.
+ // for component root it's always normalized anyway.
+ children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
+ // custom directives can potentially add DOM elements arbitrarily,
+ // we need to avoid setting textContent of the element at runtime
+ // to avoid accidentally overwriting the DOM elements added
+ // by the user through custom directives.
+ !node.props.find(
+ (p) => p.type === 7 && !context.directiveTransforms[p.name]
+ ) && // in compat mode, <template> tags with no special directives
+ // will be rendered as a fragment so its children must be
+ // converted into vnodes.
+ !(node.tag === "template"))) {
+ return;
+ }
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isText$1(child) || child.type === 8) {
+ const callArgs = [];
+ if (child.type !== 2 || child.content !== " ") {
+ callArgs.push(child);
+ }
+ if (!context.ssr && getConstantType(child, context) === 0) {
+ callArgs.push(
+ 1 + (``)
+ );
+ }
+ children[i] = {
+ type: 12,
+ content: child,
+ loc: child.loc,
+ codegenNode: createCallExpression(
+ context.helper(CREATE_TEXT),
+ callArgs
+ )
+ };
+ }
+ }
+ };
+ }
+};
+
+const seen$1 = /* @__PURE__ */ new WeakSet();
+const transformOnce = (node, context) => {
+ if (node.type === 1 && findDir(node, "once", true)) {
+ if (seen$1.has(node) || context.inVOnce || context.inSSR) {
+ return;
+ }
+ seen$1.add(node);
+ context.inVOnce = true;
+ context.helper(SET_BLOCK_TRACKING);
+ return () => {
+ context.inVOnce = false;
+ const cur = context.currentNode;
+ if (cur.codegenNode) {
+ cur.codegenNode = context.cache(
+ cur.codegenNode,
+ true
+ /* isVNode */
+ );
+ }
+ };
+ }
+};
+
+const transformModel = (dir, node, context) => {
+ const { exp, arg } = dir;
+ if (!exp) {
+ context.onError(
+ createCompilerError(41, dir.loc)
+ );
+ return createTransformProps();
+ }
+ const rawExp = exp.loc.source;
+ const expString = exp.type === 4 ? exp.content : rawExp;
+ const bindingType = context.bindingMetadata[rawExp];
+ if (bindingType === "props" || bindingType === "props-aliased") {
+ context.onError(createCompilerError(44, exp.loc));
+ return createTransformProps();
+ }
+ const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
+ if (!expString.trim() || !isMemberExpression(expString, context) && !maybeRef) {
+ context.onError(
+ createCompilerError(42, exp.loc)
+ );
+ return createTransformProps();
+ }
+ if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {
+ context.onError(
+ createCompilerError(43, exp.loc)
+ );
+ return createTransformProps();
+ }
+ const propName = arg ? arg : createSimpleExpression("modelValue", true);
+ const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
+ let assignmentExp;
+ const eventArg = context.isTS ? `($event: any)` : `$event`;
+ if (maybeRef) {
+ if (bindingType === "setup-ref") {
+ assignmentExp = createCompoundExpression([
+ `${eventArg} => ((`,
+ createSimpleExpression(rawExp, false, exp.loc),
+ `).value = $event)`
+ ]);
+ } else {
+ const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`;
+ assignmentExp = createCompoundExpression([
+ `${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,
+ createSimpleExpression(rawExp, false, exp.loc),
+ `).value = $event : ${altAssignment})`
+ ]);
+ }
+ } else {
+ assignmentExp = createCompoundExpression([
+ `${eventArg} => ((`,
+ exp,
+ `) = $event)`
+ ]);
+ }
+ const props = [
+ // modelValue: foo
+ createObjectProperty(propName, dir.exp),
+ // "onUpdate:modelValue": $event => (foo = $event)
+ createObjectProperty(eventName, assignmentExp)
+ ];
+ if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) {
+ props[1].value = context.cache(props[1].value);
+ }
+ if (dir.modifiers.length && node.tagType === 1) {
+ const modifiers = dir.modifiers.map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
+ const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
+ props.push(
+ createObjectProperty(
+ modifiersKey,
+ createSimpleExpression(
+ `{ ${modifiers} }`,
+ false,
+ dir.loc,
+ 2
+ )
+ )
+ );
+ }
+ return createTransformProps(props);
+};
+function createTransformProps(props = []) {
+ return { props };
+}
+
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+const transformFilter = (node, context) => {
+ if (!isCompatEnabled("COMPILER_FILTER", context)) {
+ return;
+ }
+ if (node.type === 5) {
+ rewriteFilter(node.content, context);
+ }
+ if (node.type === 1) {
+ node.props.forEach((prop) => {
+ if (prop.type === 7 && prop.name !== "for" && prop.exp) {
+ rewriteFilter(prop.exp, context);
+ }
+ });
+ }
+};
+function rewriteFilter(node, context) {
+ if (node.type === 4) {
+ parseFilter(node, context);
+ } else {
+ for (let i = 0; i < node.children.length; i++) {
+ const child = node.children[i];
+ if (typeof child !== "object")
+ continue;
+ if (child.type === 4) {
+ parseFilter(child, context);
+ } else if (child.type === 8) {
+ rewriteFilter(node, context);
+ } else if (child.type === 5) {
+ rewriteFilter(child.content, context);
+ }
+ }
+ }
+}
+function parseFilter(node, context) {
+ const exp = node.content;
+ let inSingle = false;
+ let inDouble = false;
+ let inTemplateString = false;
+ let inRegex = false;
+ let curly = 0;
+ let square = 0;
+ let paren = 0;
+ let lastFilterIndex = 0;
+ let c, prev, i, expression, filters = [];
+ for (i = 0; i < exp.length; i++) {
+ prev = c;
+ c = exp.charCodeAt(i);
+ if (inSingle) {
+ if (c === 39 && prev !== 92)
+ inSingle = false;
+ } else if (inDouble) {
+ if (c === 34 && prev !== 92)
+ inDouble = false;
+ } else if (inTemplateString) {
+ if (c === 96 && prev !== 92)
+ inTemplateString = false;
+ } else if (inRegex) {
+ if (c === 47 && prev !== 92)
+ inRegex = false;
+ } else if (c === 124 && // pipe
+ exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
+ if (expression === void 0) {
+ lastFilterIndex = i + 1;
+ expression = exp.slice(0, i).trim();
+ } else {
+ pushFilter();
+ }
+ } else {
+ switch (c) {
+ case 34:
+ inDouble = true;
+ break;
+ case 39:
+ inSingle = true;
+ break;
+ case 96:
+ inTemplateString = true;
+ break;
+ case 40:
+ paren++;
+ break;
+ case 41:
+ paren--;
+ break;
+ case 91:
+ square++;
+ break;
+ case 93:
+ square--;
+ break;
+ case 123:
+ curly++;
+ break;
+ case 125:
+ curly--;
+ break;
+ }
+ if (c === 47) {
+ let j = i - 1;
+ let p;
+ for (; j >= 0; j--) {
+ p = exp.charAt(j);
+ if (p !== " ")
+ break;
+ }
+ if (!p || !validDivisionCharRE.test(p)) {
+ inRegex = true;
+ }
+ }
+ }
+ }
+ if (expression === void 0) {
+ expression = exp.slice(0, i).trim();
+ } else if (lastFilterIndex !== 0) {
+ pushFilter();
+ }
+ function pushFilter() {
+ filters.push(exp.slice(lastFilterIndex, i).trim());
+ lastFilterIndex = i + 1;
+ }
+ if (filters.length) {
+ for (i = 0; i < filters.length; i++) {
+ expression = wrapFilter(expression, filters[i], context);
+ }
+ node.content = expression;
+ }
+}
+function wrapFilter(exp, filter, context) {
+ context.helper(RESOLVE_FILTER);
+ const i = filter.indexOf("(");
+ if (i < 0) {
+ context.filters.add(filter);
+ return `${toValidAssetId(filter, "filter")}(${exp})`;
+ } else {
+ const name = filter.slice(0, i);
+ const args = filter.slice(i + 1);
+ context.filters.add(name);
+ return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
+ }
+}
+
+const seen = /* @__PURE__ */ new WeakSet();
+const transformMemo = (node, context) => {
+ if (node.type === 1) {
+ const dir = findDir(node, "memo");
+ if (!dir || seen.has(node)) {
+ return;
+ }
+ seen.add(node);
+ return () => {
+ const codegenNode = node.codegenNode || context.currentNode.codegenNode;
+ if (codegenNode && codegenNode.type === 13) {
+ if (node.tagType !== 1) {
+ convertToBlock(codegenNode, context);
+ }
+ node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
+ dir.exp,
+ createFunctionExpression(void 0, codegenNode),
+ `_cache`,
+ String(context.cached++)
+ ]);
+ }
+ };
+ }
+};
+
+function getBaseTransformPreset(prefixIdentifiers) {
+ return [
+ [
+ transformOnce,
+ transformIf,
+ transformMemo,
+ transformFor,
+ ...[transformFilter] ,
+ ...prefixIdentifiers ? [
+ // order is important
+ trackVForSlotScopes,
+ transformExpression
+ ] : [],
+ transformSlotOutlet,
+ transformElement,
+ trackSlotScopes,
+ transformText
+ ],
+ {
+ on: transformOn,
+ bind: transformBind,
+ model: transformModel
+ }
+ ];
+}
+function baseCompile(template, options = {}) {
+ const onError = options.onError || defaultOnError;
+ const isModuleMode = options.mode === "module";
+ const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
+ if (!prefixIdentifiers && options.cacheHandlers) {
+ onError(createCompilerError(49));
+ }
+ if (options.scopeId && !isModuleMode) {
+ onError(createCompilerError(50));
+ }
+ const ast = shared.isString(template) ? baseParse(template, options) : template;
+ const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
+ if (options.isTS) {
+ const { expressionPlugins } = options;
+ if (!expressionPlugins || !expressionPlugins.includes("typescript")) {
+ options.expressionPlugins = [...expressionPlugins || [], "typescript"];
+ }
+ }
+ transform(
+ ast,
+ shared.extend({}, options, {
+ prefixIdentifiers,
+ nodeTransforms: [
+ ...nodeTransforms,
+ ...options.nodeTransforms || []
+ // user transforms
+ ],
+ directiveTransforms: shared.extend(
+ {},
+ directiveTransforms,
+ options.directiveTransforms || {}
+ // user transforms
+ )
+ })
+ );
+ return generate(
+ ast,
+ shared.extend({}, options, {
+ prefixIdentifiers
+ })
+ );
+}
+
+const noopDirectiveTransform = () => ({ props: [] });
+
+exports.generateCodeFrame = shared.generateCodeFrame;
+exports.BASE_TRANSITION = BASE_TRANSITION;
+exports.CAMELIZE = CAMELIZE;
+exports.CAPITALIZE = CAPITALIZE;
+exports.CREATE_BLOCK = CREATE_BLOCK;
+exports.CREATE_COMMENT = CREATE_COMMENT;
+exports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK;
+exports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE;
+exports.CREATE_SLOTS = CREATE_SLOTS;
+exports.CREATE_STATIC = CREATE_STATIC;
+exports.CREATE_TEXT = CREATE_TEXT;
+exports.CREATE_VNODE = CREATE_VNODE;
+exports.FRAGMENT = FRAGMENT;
+exports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS;
+exports.IS_MEMO_SAME = IS_MEMO_SAME;
+exports.IS_REF = IS_REF;
+exports.KEEP_ALIVE = KEEP_ALIVE;
+exports.MERGE_PROPS = MERGE_PROPS;
+exports.NORMALIZE_CLASS = NORMALIZE_CLASS;
+exports.NORMALIZE_PROPS = NORMALIZE_PROPS;
+exports.NORMALIZE_STYLE = NORMALIZE_STYLE;
+exports.OPEN_BLOCK = OPEN_BLOCK;
+exports.POP_SCOPE_ID = POP_SCOPE_ID;
+exports.PUSH_SCOPE_ID = PUSH_SCOPE_ID;
+exports.RENDER_LIST = RENDER_LIST;
+exports.RENDER_SLOT = RENDER_SLOT;
+exports.RESOLVE_COMPONENT = RESOLVE_COMPONENT;
+exports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE;
+exports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT;
+exports.RESOLVE_FILTER = RESOLVE_FILTER;
+exports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING;
+exports.SUSPENSE = SUSPENSE;
+exports.TELEPORT = TELEPORT;
+exports.TO_DISPLAY_STRING = TO_DISPLAY_STRING;
+exports.TO_HANDLERS = TO_HANDLERS;
+exports.TO_HANDLER_KEY = TO_HANDLER_KEY;
+exports.TS_NODE_TYPES = TS_NODE_TYPES;
+exports.UNREF = UNREF;
+exports.WITH_CTX = WITH_CTX;
+exports.WITH_DIRECTIVES = WITH_DIRECTIVES;
+exports.WITH_MEMO = WITH_MEMO;
+exports.advancePositionWithClone = advancePositionWithClone;
+exports.advancePositionWithMutation = advancePositionWithMutation;
+exports.assert = assert;
+exports.baseCompile = baseCompile;
+exports.baseParse = baseParse;
+exports.buildDirectiveArgs = buildDirectiveArgs;
+exports.buildProps = buildProps;
+exports.buildSlots = buildSlots;
+exports.checkCompatEnabled = checkCompatEnabled;
+exports.convertToBlock = convertToBlock;
+exports.createArrayExpression = createArrayExpression;
+exports.createAssignmentExpression = createAssignmentExpression;
+exports.createBlockStatement = createBlockStatement;
+exports.createCacheExpression = createCacheExpression;
+exports.createCallExpression = createCallExpression;
+exports.createCompilerError = createCompilerError;
+exports.createCompoundExpression = createCompoundExpression;
+exports.createConditionalExpression = createConditionalExpression;
+exports.createForLoopParams = createForLoopParams;
+exports.createFunctionExpression = createFunctionExpression;
+exports.createIfStatement = createIfStatement;
+exports.createInterpolation = createInterpolation;
+exports.createObjectExpression = createObjectExpression;
+exports.createObjectProperty = createObjectProperty;
+exports.createReturnStatement = createReturnStatement;
+exports.createRoot = createRoot;
+exports.createSequenceExpression = createSequenceExpression;
+exports.createSimpleExpression = createSimpleExpression;
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
+exports.createTemplateLiteral = createTemplateLiteral;
+exports.createTransformContext = createTransformContext;
+exports.createVNodeCall = createVNodeCall;
+exports.extractIdentifiers = extractIdentifiers;
+exports.findDir = findDir;
+exports.findProp = findProp;
+exports.forAliasRE = forAliasRE;
+exports.generate = generate;
+exports.getBaseTransformPreset = getBaseTransformPreset;
+exports.getConstantType = getConstantType;
+exports.getInnerRange = getInnerRange;
+exports.getMemoedVNodeCall = getMemoedVNodeCall;
+exports.getVNodeBlockHelper = getVNodeBlockHelper;
+exports.getVNodeHelper = getVNodeHelper;
+exports.hasDynamicKeyVBind = hasDynamicKeyVBind;
+exports.hasScopeRef = hasScopeRef;
+exports.helperNameMap = helperNameMap;
+exports.injectProp = injectProp;
+exports.isBuiltInType = isBuiltInType;
+exports.isCoreComponent = isCoreComponent;
+exports.isFunctionType = isFunctionType;
+exports.isInDestructureAssignment = isInDestructureAssignment;
+exports.isMemberExpression = isMemberExpression;
+exports.isMemberExpressionBrowser = isMemberExpressionBrowser;
+exports.isMemberExpressionNode = isMemberExpressionNode;
+exports.isReferencedIdentifier = isReferencedIdentifier;
+exports.isSimpleIdentifier = isSimpleIdentifier;
+exports.isSlotOutlet = isSlotOutlet;
+exports.isStaticArgOf = isStaticArgOf;
+exports.isStaticExp = isStaticExp;
+exports.isStaticProperty = isStaticProperty;
+exports.isStaticPropertyKey = isStaticPropertyKey;
+exports.isTemplateNode = isTemplateNode;
+exports.isText = isText$1;
+exports.isVSlot = isVSlot;
+exports.locStub = locStub;
+exports.noopDirectiveTransform = noopDirectiveTransform;
+exports.processExpression = processExpression;
+exports.processFor = processFor;
+exports.processIf = processIf;
+exports.processSlotOutlet = processSlotOutlet;
+exports.registerRuntimeHelpers = registerRuntimeHelpers;
+exports.resolveComponentType = resolveComponentType;
+exports.stringifyExpression = stringifyExpression;
+exports.toValidAssetId = toValidAssetId;
+exports.trackSlotScopes = trackSlotScopes;
+exports.trackVForSlotScopes = trackVForSlotScopes;
+exports.transform = transform;
+exports.transformBind = transformBind;
+exports.transformElement = transformElement;
+exports.transformExpression = transformExpression;
+exports.transformModel = transformModel;
+exports.transformOn = transformOn;
+exports.traverseNode = traverseNode;
+exports.walkBlockDeclarations = walkBlockDeclarations;
+exports.walkFunctionParams = walkFunctionParams;
+exports.walkIdentifiers = walkIdentifiers;
+exports.warnDeprecation = warnDeprecation;
diff --git a/.output/server/node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.js b/.output/server/node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.js
new file mode 100644
index 0000000..4e563e0
--- /dev/null
+++ b/.output/server/node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.js
@@ -0,0 +1,3047 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerCore = require('@vue/compiler-core');
+var shared = require('@vue/shared');
+
+const V_MODEL_RADIO = Symbol(`vModelRadio` );
+const V_MODEL_CHECKBOX = Symbol(`vModelCheckbox` );
+const V_MODEL_TEXT = Symbol(`vModelText` );
+const V_MODEL_SELECT = Symbol(`vModelSelect` );
+const V_MODEL_DYNAMIC = Symbol(`vModelDynamic` );
+const V_ON_WITH_MODIFIERS = Symbol(`vOnModifiersGuard` );
+const V_ON_WITH_KEYS = Symbol(`vOnKeysGuard` );
+const V_SHOW = Symbol(`vShow` );
+const TRANSITION = Symbol(`Transition` );
+const TRANSITION_GROUP = Symbol(`TransitionGroup` );
+compilerCore.registerRuntimeHelpers({
+ [V_MODEL_RADIO]: `vModelRadio`,
+ [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+ [V_MODEL_TEXT]: `vModelText`,
+ [V_MODEL_SELECT]: `vModelSelect`,
+ [V_MODEL_DYNAMIC]: `vModelDynamic`,
+ [V_ON_WITH_MODIFIERS]: `withModifiers`,
+ [V_ON_WITH_KEYS]: `withKeys`,
+ [V_SHOW]: `vShow`,
+ [TRANSITION]: `Transition`,
+ [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+var namedCharacterReferences = {
+ GT: ">",
+ gt: ">",
+ LT: "<",
+ lt: "<",
+ "ac;": "∾",
+ "af;": "",
+ AMP: "&",
+ amp: "&",
+ "ap;": "≈",
+ "DD;": "ⅅ",
+ "dd;": "ⅆ",
+ deg: "°",
+ "ee;": "ⅇ",
+ "eg;": "⪚",
+ "el;": "⪙",
+ ETH: "Ð",
+ eth: "ð",
+ "gE;": "≧",
+ "ge;": "≥",
+ "Gg;": "⋙",
+ "gg;": "≫",
+ "gl;": "≷",
+ "GT;": ">",
+ "Gt;": "≫",
+ "gt;": ">",
+ "ic;": "",
+ "ii;": "ⅈ",
+ "Im;": "ℑ",
+ "in;": "∈",
+ "it;": "",
+ "lE;": "≦",
+ "le;": "≤",
+ "lg;": "≶",
+ "Ll;": "⋘",
+ "ll;": "≪",
+ "LT;": "<",
+ "Lt;": "≪",
+ "lt;": "<",
+ "mp;": "∓",
+ "Mu;": "Μ",
+ "mu;": "μ",
+ "ne;": "≠",
+ "ni;": "∋",
+ not: "¬",
+ "Nu;": "Ν",
+ "nu;": "ν",
+ "Or;": "⩔",
+ "or;": "∨",
+ "oS;": "Ⓢ",
+ "Pi;": "Π",
+ "pi;": "π",
+ "pm;": "±",
+ "Pr;": "⪻",
+ "pr;": "≺",
+ "Re;": "ℜ",
+ REG: "®",
+ reg: "®",
+ "rx;": "℞",
+ "Sc;": "⪼",
+ "sc;": "≻",
+ shy: "",
+ uml: "¨",
+ "wp;": "℘",
+ "wr;": "≀",
+ "Xi;": "Ξ",
+ "xi;": "ξ",
+ yen: "¥",
+ "acd;": "∿",
+ "acE;": "∾̳",
+ "Acy;": "А",
+ "acy;": "а",
+ "Afr;": "𝔄",
+ "afr;": "𝔞",
+ "AMP;": "&",
+ "amp;": "&",
+ "And;": "⩓",
+ "and;": "∧",
+ "ang;": "∠",
+ "apE;": "⩰",
+ "ape;": "≊",
+ "ast;": "*",
+ Auml: "Ä",
+ auml: "ä",
+ "Bcy;": "Б",
+ "bcy;": "б",
+ "Bfr;": "𝔅",
+ "bfr;": "𝔟",
+ "bne;": "=⃥",
+ "bot;": "⊥",
+ "Cap;": "⋒",
+ "cap;": "∩",
+ cent: "¢",
+ "Cfr;": "ℭ",
+ "cfr;": "𝔠",
+ "Chi;": "Χ",
+ "chi;": "χ",
+ "cir;": "○",
+ COPY: "©",
+ copy: "©",
+ "Cup;": "⋓",
+ "cup;": "∪",
+ "Dcy;": "Д",
+ "dcy;": "д",
+ "deg;": "°",
+ "Del;": "∇",
+ "Dfr;": "𝔇",
+ "dfr;": "𝔡",
+ "die;": "¨",
+ "div;": "÷",
+ "Dot;": "¨",
+ "dot;": "˙",
+ "Ecy;": "Э",
+ "ecy;": "э",
+ "Efr;": "𝔈",
+ "efr;": "𝔢",
+ "egs;": "⪖",
+ "ell;": "ℓ",
+ "els;": "⪕",
+ "ENG;": "Ŋ",
+ "eng;": "ŋ",
+ "Eta;": "Η",
+ "eta;": "η",
+ "ETH;": "Ð",
+ "eth;": "ð",
+ Euml: "Ë",
+ euml: "ë",
+ "Fcy;": "Ф",
+ "fcy;": "ф",
+ "Ffr;": "𝔉",
+ "ffr;": "𝔣",
+ "gap;": "⪆",
+ "Gcy;": "Г",
+ "gcy;": "г",
+ "gEl;": "⪌",
+ "gel;": "⋛",
+ "geq;": "≥",
+ "ges;": "⩾",
+ "Gfr;": "𝔊",
+ "gfr;": "𝔤",
+ "ggg;": "⋙",
+ "gla;": "⪥",
+ "glE;": "⪒",
+ "glj;": "⪤",
+ "gnE;": "≩",
+ "gne;": "⪈",
+ "Hat;": "^",
+ "Hfr;": "ℌ",
+ "hfr;": "𝔥",
+ "Icy;": "И",
+ "icy;": "и",
+ "iff;": "⇔",
+ "Ifr;": "ℑ",
+ "ifr;": "𝔦",
+ "Int;": "∬",
+ "int;": "∫",
+ Iuml: "Ï",
+ iuml: "ï",
+ "Jcy;": "Й",
+ "jcy;": "й",
+ "Jfr;": "𝔍",
+ "jfr;": "𝔧",
+ "Kcy;": "К",
+ "kcy;": "к",
+ "Kfr;": "𝔎",
+ "kfr;": "𝔨",
+ "lap;": "⪅",
+ "lat;": "⪫",
+ "Lcy;": "Л",
+ "lcy;": "л",
+ "lEg;": "⪋",
+ "leg;": "⋚",
+ "leq;": "≤",
+ "les;": "⩽",
+ "Lfr;": "𝔏",
+ "lfr;": "𝔩",
+ "lgE;": "⪑",
+ "lnE;": "≨",
+ "lne;": "⪇",
+ "loz;": "◊",
+ "lrm;": "",
+ "Lsh;": "↰",
+ "lsh;": "↰",
+ macr: "¯",
+ "Map;": "⤅",
+ "map;": "↦",
+ "Mcy;": "М",
+ "mcy;": "м",
+ "Mfr;": "𝔐",
+ "mfr;": "𝔪",
+ "mho;": "℧",
+ "mid;": "∣",
+ "nap;": "≉",
+ nbsp: " ",
+ "Ncy;": "Н",
+ "ncy;": "н",
+ "Nfr;": "𝔑",
+ "nfr;": "𝔫",
+ "ngE;": "≧̸",
+ "nge;": "≱",
+ "nGg;": "⋙̸",
+ "nGt;": "≫⃒",
+ "ngt;": "≯",
+ "nis;": "⋼",
+ "niv;": "∋",
+ "nlE;": "≦̸",
+ "nle;": "≰",
+ "nLl;": "⋘̸",
+ "nLt;": "≪⃒",
+ "nlt;": "≮",
+ "Not;": "⫬",
+ "not;": "¬",
+ "npr;": "⊀",
+ "nsc;": "⊁",
+ "num;": "#",
+ "Ocy;": "О",
+ "ocy;": "о",
+ "Ofr;": "𝔒",
+ "ofr;": "𝔬",
+ "ogt;": "⧁",
+ "ohm;": "Ω",
+ "olt;": "⧀",
+ "ord;": "⩝",
+ ordf: "ª",
+ ordm: "º",
+ "orv;": "⩛",
+ Ouml: "Ö",
+ ouml: "ö",
+ "par;": "∥",
+ para: "¶",
+ "Pcy;": "П",
+ "pcy;": "п",
+ "Pfr;": "𝔓",
+ "pfr;": "𝔭",
+ "Phi;": "Φ",
+ "phi;": "φ",
+ "piv;": "ϖ",
+ "prE;": "⪳",
+ "pre;": "⪯",
+ "Psi;": "Ψ",
+ "psi;": "ψ",
+ "Qfr;": "𝔔",
+ "qfr;": "𝔮",
+ QUOT: "\"",
+ quot: "\"",
+ "Rcy;": "Р",
+ "rcy;": "р",
+ "REG;": "®",
+ "reg;": "®",
+ "Rfr;": "ℜ",
+ "rfr;": "𝔯",
+ "Rho;": "Ρ",
+ "rho;": "ρ",
+ "rlm;": "",
+ "Rsh;": "↱",
+ "rsh;": "↱",
+ "scE;": "⪴",
+ "sce;": "⪰",
+ "Scy;": "С",
+ "scy;": "с",
+ sect: "§",
+ "Sfr;": "𝔖",
+ "sfr;": "𝔰",
+ "shy;": "",
+ "sim;": "∼",
+ "smt;": "⪪",
+ "sol;": "/",
+ "squ;": "□",
+ "Sub;": "⋐",
+ "sub;": "⊂",
+ "Sum;": "∑",
+ "sum;": "∑",
+ "Sup;": "⋑",
+ "sup;": "⊃",
+ sup1: "¹",
+ sup2: "²",
+ sup3: "³",
+ "Tab;": "\t",
+ "Tau;": "Τ",
+ "tau;": "τ",
+ "Tcy;": "Т",
+ "tcy;": "т",
+ "Tfr;": "𝔗",
+ "tfr;": "𝔱",
+ "top;": "⊤",
+ "Ucy;": "У",
+ "ucy;": "у",
+ "Ufr;": "𝔘",
+ "ufr;": "𝔲",
+ "uml;": "¨",
+ Uuml: "Ü",
+ uuml: "ü",
+ "Vcy;": "В",
+ "vcy;": "в",
+ "Vee;": "⋁",
+ "vee;": "∨",
+ "Vfr;": "𝔙",
+ "vfr;": "𝔳",
+ "Wfr;": "𝔚",
+ "wfr;": "𝔴",
+ "Xfr;": "𝔛",
+ "xfr;": "𝔵",
+ "Ycy;": "Ы",
+ "ycy;": "ы",
+ "yen;": "¥",
+ "Yfr;": "𝔜",
+ "yfr;": "𝔶",
+ yuml: "ÿ",
+ "Zcy;": "З",
+ "zcy;": "з",
+ "Zfr;": "ℨ",
+ "zfr;": "𝔷",
+ "zwj;": "",
+ Acirc: "Â",
+ acirc: "â",
+ acute: "´",
+ AElig: "Æ",
+ aelig: "æ",
+ "andd;": "⩜",
+ "andv;": "⩚",
+ "ange;": "⦤",
+ "Aopf;": "𝔸",
+ "aopf;": "𝕒",
+ "apid;": "≋",
+ "apos;": "'",
+ Aring: "Å",
+ aring: "å",
+ "Ascr;": "𝒜",
+ "ascr;": "𝒶",
+ "Auml;": "Ä",
+ "auml;": "ä",
+ "Barv;": "⫧",
+ "bbrk;": "⎵",
+ "Beta;": "Β",
+ "beta;": "β",
+ "beth;": "ℶ",
+ "bNot;": "⫭",
+ "bnot;": "⌐",
+ "Bopf;": "𝔹",
+ "bopf;": "𝕓",
+ "boxH;": "═",
+ "boxh;": "─",
+ "boxV;": "║",
+ "boxv;": "│",
+ "Bscr;": "ℬ",
+ "bscr;": "𝒷",
+ "bsim;": "∽",
+ "bsol;": "\\",
+ "bull;": "•",
+ "bump;": "≎",
+ "caps;": "∩︀",
+ "Cdot;": "Ċ",
+ "cdot;": "ċ",
+ cedil: "¸",
+ "cent;": "¢",
+ "CHcy;": "Ч",
+ "chcy;": "ч",
+ "circ;": "ˆ",
+ "cirE;": "⧃",
+ "cire;": "≗",
+ "comp;": "∁",
+ "cong;": "≅",
+ "Copf;": "ℂ",
+ "copf;": "𝕔",
+ "COPY;": "©",
+ "copy;": "©",
+ "Cscr;": "𝒞",
+ "cscr;": "𝒸",
+ "csub;": "⫏",
+ "csup;": "⫐",
+ "cups;": "∪︀",
+ "Darr;": "↡",
+ "dArr;": "⇓",
+ "darr;": "↓",
+ "dash;": "‐",
+ "dHar;": "⥥",
+ "diam;": "⋄",
+ "DJcy;": "Ђ",
+ "djcy;": "ђ",
+ "Dopf;": "𝔻",
+ "dopf;": "𝕕",
+ "Dscr;": "𝒟",
+ "dscr;": "𝒹",
+ "DScy;": "Ѕ",
+ "dscy;": "ѕ",
+ "dsol;": "⧶",
+ "dtri;": "▿",
+ "DZcy;": "Џ",
+ "dzcy;": "џ",
+ "ecir;": "≖",
+ Ecirc: "Ê",
+ ecirc: "ê",
+ "Edot;": "Ė",
+ "eDot;": "≑",
+ "edot;": "ė",
+ "emsp;": " ",
+ "ensp;": " ",
+ "Eopf;": "𝔼",
+ "eopf;": "𝕖",
+ "epar;": "⋕",
+ "epsi;": "ε",
+ "Escr;": "ℰ",
+ "escr;": "ℯ",
+ "Esim;": "⩳",
+ "esim;": "≂",
+ "Euml;": "Ë",
+ "euml;": "ë",
+ "euro;": "€",
+ "excl;": "!",
+ "flat;": "♭",
+ "fnof;": "ƒ",
+ "Fopf;": "𝔽",
+ "fopf;": "𝕗",
+ "fork;": "⋔",
+ "Fscr;": "ℱ",
+ "fscr;": "𝒻",
+ "Gdot;": "Ġ",
+ "gdot;": "ġ",
+ "geqq;": "≧",
+ "gesl;": "⋛︀",
+ "GJcy;": "Ѓ",
+ "gjcy;": "ѓ",
+ "gnap;": "⪊",
+ "gneq;": "⪈",
+ "Gopf;": "𝔾",
+ "gopf;": "𝕘",
+ "Gscr;": "𝒢",
+ "gscr;": "ℊ",
+ "gsim;": "≳",
+ "gtcc;": "⪧",
+ "gvnE;": "≩︀",
+ "half;": "½",
+ "hArr;": "⇔",
+ "harr;": "↔",
+ "hbar;": "ℏ",
+ "Hopf;": "ℍ",
+ "hopf;": "𝕙",
+ "Hscr;": "ℋ",
+ "hscr;": "𝒽",
+ Icirc: "Î",
+ icirc: "î",
+ "Idot;": "İ",
+ "IEcy;": "Е",
+ "iecy;": "е",
+ iexcl: "¡",
+ "imof;": "⊷",
+ "IOcy;": "Ё",
+ "iocy;": "ё",
+ "Iopf;": "𝕀",
+ "iopf;": "𝕚",
+ "Iota;": "Ι",
+ "iota;": "ι",
+ "Iscr;": "ℐ",
+ "iscr;": "𝒾",
+ "isin;": "∈",
+ "Iuml;": "Ï",
+ "iuml;": "ï",
+ "Jopf;": "𝕁",
+ "jopf;": "𝕛",
+ "Jscr;": "𝒥",
+ "jscr;": "𝒿",
+ "KHcy;": "Х",
+ "khcy;": "х",
+ "KJcy;": "Ќ",
+ "kjcy;": "ќ",
+ "Kopf;": "𝕂",
+ "kopf;": "𝕜",
+ "Kscr;": "𝒦",
+ "kscr;": "𝓀",
+ "Lang;": "⟪",
+ "lang;": "⟨",
+ laquo: "«",
+ "Larr;": "↞",
+ "lArr;": "⇐",
+ "larr;": "←",
+ "late;": "⪭",
+ "lcub;": "{",
+ "ldca;": "⤶",
+ "ldsh;": "↲",
+ "leqq;": "≦",
+ "lesg;": "⋚︀",
+ "lHar;": "⥢",
+ "LJcy;": "Љ",
+ "ljcy;": "љ",
+ "lnap;": "⪉",
+ "lneq;": "⪇",
+ "Lopf;": "𝕃",
+ "lopf;": "𝕝",
+ "lozf;": "⧫",
+ "lpar;": "(",
+ "Lscr;": "ℒ",
+ "lscr;": "𝓁",
+ "lsim;": "≲",
+ "lsqb;": "[",
+ "ltcc;": "⪦",
+ "ltri;": "◃",
+ "lvnE;": "≨︀",
+ "macr;": "¯",
+ "male;": "♂",
+ "malt;": "✠",
+ micro: "µ",
+ "mlcp;": "⫛",
+ "mldr;": "…",
+ "Mopf;": "𝕄",
+ "mopf;": "𝕞",
+ "Mscr;": "ℳ",
+ "mscr;": "𝓂",
+ "nang;": "∠⃒",
+ "napE;": "⩰̸",
+ "nbsp;": " ",
+ "ncap;": "⩃",
+ "ncup;": "⩂",
+ "ngeq;": "≱",
+ "nges;": "⩾̸",
+ "ngtr;": "≯",
+ "nGtv;": "≫̸",
+ "nisd;": "⋺",
+ "NJcy;": "Њ",
+ "njcy;": "њ",
+ "nldr;": "‥",
+ "nleq;": "≰",
+ "nles;": "⩽̸",
+ "nLtv;": "≪̸",
+ "nmid;": "∤",
+ "Nopf;": "ℕ",
+ "nopf;": "𝕟",
+ "npar;": "∦",
+ "npre;": "⪯̸",
+ "nsce;": "⪰̸",
+ "Nscr;": "𝒩",
+ "nscr;": "𝓃",
+ "nsim;": "≁",
+ "nsub;": "⊄",
+ "nsup;": "⊅",
+ "ntgl;": "≹",
+ "ntlg;": "≸",
+ "nvap;": "≍⃒",
+ "nvge;": "≥⃒",
+ "nvgt;": ">⃒",
+ "nvle;": "≤⃒",
+ "nvlt;": "<⃒",
+ "oast;": "⊛",
+ "ocir;": "⊚",
+ Ocirc: "Ô",
+ ocirc: "ô",
+ "odiv;": "⨸",
+ "odot;": "⊙",
+ "ogon;": "˛",
+ "oint;": "∮",
+ "omid;": "⦶",
+ "Oopf;": "𝕆",
+ "oopf;": "𝕠",
+ "opar;": "⦷",
+ "ordf;": "ª",
+ "ordm;": "º",
+ "oror;": "⩖",
+ "Oscr;": "𝒪",
+ "oscr;": "ℴ",
+ "osol;": "⊘",
+ "Ouml;": "Ö",
+ "ouml;": "ö",
+ "para;": "¶",
+ "part;": "∂",
+ "perp;": "⊥",
+ "phiv;": "ϕ",
+ "plus;": "+",
+ "Popf;": "ℙ",
+ "popf;": "𝕡",
+ pound: "£",
+ "prap;": "⪷",
+ "prec;": "≺",
+ "prnE;": "⪵",
+ "prod;": "∏",
+ "prop;": "∝",
+ "Pscr;": "𝒫",
+ "pscr;": "𝓅",
+ "qint;": "⨌",
+ "Qopf;": "ℚ",
+ "qopf;": "𝕢",
+ "Qscr;": "𝒬",
+ "qscr;": "𝓆",
+ "QUOT;": "\"",
+ "quot;": "\"",
+ "race;": "∽̱",
+ "Rang;": "⟫",
+ "rang;": "⟩",
+ raquo: "»",
+ "Rarr;": "↠",
+ "rArr;": "⇒",
+ "rarr;": "→",
+ "rcub;": "}",
+ "rdca;": "⤷",
+ "rdsh;": "↳",
+ "real;": "ℜ",
+ "rect;": "▭",
+ "rHar;": "⥤",
+ "rhov;": "ϱ",
+ "ring;": "˚",
+ "Ropf;": "ℝ",
+ "ropf;": "𝕣",
+ "rpar;": ")",
+ "Rscr;": "ℛ",
+ "rscr;": "𝓇",
+ "rsqb;": "]",
+ "rtri;": "▹",
+ "scap;": "⪸",
+ "scnE;": "⪶",
+ "sdot;": "⋅",
+ "sect;": "§",
+ "semi;": ";",
+ "sext;": "✶",
+ "SHcy;": "Ш",
+ "shcy;": "ш",
+ "sime;": "≃",
+ "simg;": "⪞",
+ "siml;": "⪝",
+ "smid;": "∣",
+ "smte;": "⪬",
+ "solb;": "⧄",
+ "Sopf;": "𝕊",
+ "sopf;": "𝕤",
+ "spar;": "∥",
+ "Sqrt;": "√",
+ "squf;": "▪",
+ "Sscr;": "𝒮",
+ "sscr;": "𝓈",
+ "Star;": "⋆",
+ "star;": "☆",
+ "subE;": "⫅",
+ "sube;": "⊆",
+ "succ;": "≻",
+ "sung;": "♪",
+ "sup1;": "¹",
+ "sup2;": "²",
+ "sup3;": "³",
+ "supE;": "⫆",
+ "supe;": "⊇",
+ szlig: "ß",
+ "tbrk;": "⎴",
+ "tdot;": "⃛",
+ THORN: "Þ",
+ thorn: "þ",
+ times: "×",
+ "tint;": "∭",
+ "toea;": "⤨",
+ "Topf;": "𝕋",
+ "topf;": "𝕥",
+ "tosa;": "⤩",
+ "trie;": "≜",
+ "Tscr;": "𝒯",
+ "tscr;": "𝓉",
+ "TScy;": "Ц",
+ "tscy;": "ц",
+ "Uarr;": "↟",
+ "uArr;": "⇑",
+ "uarr;": "↑",
+ Ucirc: "Û",
+ ucirc: "û",
+ "uHar;": "⥣",
+ "Uopf;": "𝕌",
+ "uopf;": "𝕦",
+ "Upsi;": "ϒ",
+ "upsi;": "υ",
+ "Uscr;": "𝒰",
+ "uscr;": "𝓊",
+ "utri;": "▵",
+ "Uuml;": "Ü",
+ "uuml;": "ü",
+ "vArr;": "⇕",
+ "varr;": "↕",
+ "Vbar;": "⫫",
+ "vBar;": "⫨",
+ "Vert;": "‖",
+ "vert;": "|",
+ "Vopf;": "𝕍",
+ "vopf;": "𝕧",
+ "Vscr;": "𝒱",
+ "vscr;": "𝓋",
+ "Wopf;": "𝕎",
+ "wopf;": "𝕨",
+ "Wscr;": "𝒲",
+ "wscr;": "𝓌",
+ "xcap;": "⋂",
+ "xcup;": "⋃",
+ "xmap;": "⟼",
+ "xnis;": "⋻",
+ "Xopf;": "𝕏",
+ "xopf;": "𝕩",
+ "Xscr;": "𝒳",
+ "xscr;": "𝓍",
+ "xvee;": "⋁",
+ "YAcy;": "Я",
+ "yacy;": "я",
+ "YIcy;": "Ї",
+ "yicy;": "ї",
+ "Yopf;": "𝕐",
+ "yopf;": "𝕪",
+ "Yscr;": "𝒴",
+ "yscr;": "𝓎",
+ "YUcy;": "Ю",
+ "yucy;": "ю",
+ "Yuml;": "Ÿ",
+ "yuml;": "ÿ",
+ "Zdot;": "Ż",
+ "zdot;": "ż",
+ "Zeta;": "Ζ",
+ "zeta;": "ζ",
+ "ZHcy;": "Ж",
+ "zhcy;": "ж",
+ "Zopf;": "ℤ",
+ "zopf;": "𝕫",
+ "Zscr;": "𝒵",
+ "zscr;": "𝓏",
+ "zwnj;": "",
+ Aacute: "Á",
+ aacute: "á",
+ "Acirc;": "Â",
+ "acirc;": "â",
+ "acute;": "´",
+ "AElig;": "Æ",
+ "aelig;": "æ",
+ Agrave: "À",
+ agrave: "à",
+ "aleph;": "ℵ",
+ "Alpha;": "Α",
+ "alpha;": "α",
+ "Amacr;": "Ā",
+ "amacr;": "ā",
+ "amalg;": "⨿",
+ "angle;": "∠",
+ "angrt;": "∟",
+ "angst;": "Å",
+ "Aogon;": "Ą",
+ "aogon;": "ą",
+ "Aring;": "Å",
+ "aring;": "å",
+ "asymp;": "≈",
+ Atilde: "Ã",
+ atilde: "ã",
+ "awint;": "⨑",
+ "bcong;": "≌",
+ "bdquo;": "„",
+ "bepsi;": "϶",
+ "blank;": "␣",
+ "blk12;": "▒",
+ "blk14;": "░",
+ "blk34;": "▓",
+ "block;": "█",
+ "boxDL;": "╗",
+ "boxDl;": "╖",
+ "boxdL;": "╕",
+ "boxdl;": "┐",
+ "boxDR;": "╔",
+ "boxDr;": "╓",
+ "boxdR;": "╒",
+ "boxdr;": "┌",
+ "boxHD;": "╦",
+ "boxHd;": "╤",
+ "boxhD;": "╥",
+ "boxhd;": "┬",
+ "boxHU;": "╩",
+ "boxHu;": "╧",
+ "boxhU;": "╨",
+ "boxhu;": "┴",
+ "boxUL;": "╝",
+ "boxUl;": "╜",
+ "boxuL;": "╛",
+ "boxul;": "┘",
+ "boxUR;": "╚",
+ "boxUr;": "╙",
+ "boxuR;": "╘",
+ "boxur;": "└",
+ "boxVH;": "╬",
+ "boxVh;": "╫",
+ "boxvH;": "╪",
+ "boxvh;": "┼",
+ "boxVL;": "╣",
+ "boxVl;": "╢",
+ "boxvL;": "╡",
+ "boxvl;": "┤",
+ "boxVR;": "╠",
+ "boxVr;": "╟",
+ "boxvR;": "╞",
+ "boxvr;": "├",
+ "Breve;": "˘",
+ "breve;": "˘",
+ brvbar: "¦",
+ "bsemi;": "⁏",
+ "bsime;": "⋍",
+ "bsolb;": "⧅",
+ "bumpE;": "⪮",
+ "bumpe;": "≏",
+ "caret;": "⁁",
+ "caron;": "ˇ",
+ "ccaps;": "⩍",
+ Ccedil: "Ç",
+ ccedil: "ç",
+ "Ccirc;": "Ĉ",
+ "ccirc;": "ĉ",
+ "ccups;": "⩌",
+ "cedil;": "¸",
+ "check;": "✓",
+ "clubs;": "♣",
+ "Colon;": "∷",
+ "colon;": ":",
+ "comma;": ",",
+ "crarr;": "↵",
+ "Cross;": "⨯",
+ "cross;": "✗",
+ "csube;": "⫑",
+ "csupe;": "⫒",
+ "ctdot;": "⋯",
+ "cuepr;": "⋞",
+ "cuesc;": "⋟",
+ "cupor;": "⩅",
+ curren: "¤",
+ "cuvee;": "⋎",
+ "cuwed;": "⋏",
+ "cwint;": "∱",
+ "Dashv;": "⫤",
+ "dashv;": "⊣",
+ "dblac;": "˝",
+ "ddarr;": "⇊",
+ "Delta;": "Δ",
+ "delta;": "δ",
+ "dharl;": "⇃",
+ "dharr;": "⇂",
+ "diams;": "♦",
+ "disin;": "⋲",
+ divide: "÷",
+ "doteq;": "≐",
+ "dtdot;": "⋱",
+ "dtrif;": "▾",
+ "duarr;": "⇵",
+ "duhar;": "⥯",
+ Eacute: "É",
+ eacute: "é",
+ "Ecirc;": "Ê",
+ "ecirc;": "ê",
+ "eDDot;": "⩷",
+ "efDot;": "≒",
+ Egrave: "È",
+ egrave: "è",
+ "Emacr;": "Ē",
+ "emacr;": "ē",
+ "empty;": "∅",
+ "Eogon;": "Ę",
+ "eogon;": "ę",
+ "eplus;": "⩱",
+ "epsiv;": "ϵ",
+ "eqsim;": "≂",
+ "Equal;": "⩵",
+ "equiv;": "≡",
+ "erarr;": "⥱",
+ "erDot;": "≓",
+ "esdot;": "≐",
+ "exist;": "∃",
+ "fflig;": "ff",
+ "filig;": "fi",
+ "fjlig;": "fj",
+ "fllig;": "fl",
+ "fltns;": "▱",
+ "forkv;": "⫙",
+ frac12: "½",
+ frac14: "¼",
+ frac34: "¾",
+ "frasl;": "⁄",
+ "frown;": "⌢",
+ "Gamma;": "Γ",
+ "gamma;": "γ",
+ "Gcirc;": "Ĝ",
+ "gcirc;": "ĝ",
+ "gescc;": "⪩",
+ "gimel;": "ℷ",
+ "gneqq;": "≩",
+ "gnsim;": "⋧",
+ "grave;": "`",
+ "gsime;": "⪎",
+ "gsiml;": "⪐",
+ "gtcir;": "⩺",
+ "gtdot;": "⋗",
+ "Hacek;": "ˇ",
+ "harrw;": "↭",
+ "Hcirc;": "Ĥ",
+ "hcirc;": "ĥ",
+ "hoarr;": "⇿",
+ Iacute: "Í",
+ iacute: "í",
+ "Icirc;": "Î",
+ "icirc;": "î",
+ "iexcl;": "¡",
+ Igrave: "Ì",
+ igrave: "ì",
+ "iiint;": "∭",
+ "iiota;": "℩",
+ "IJlig;": "IJ",
+ "ijlig;": "ij",
+ "Imacr;": "Ī",
+ "imacr;": "ī",
+ "image;": "ℑ",
+ "imath;": "ı",
+ "imped;": "Ƶ",
+ "infin;": "∞",
+ "Iogon;": "Į",
+ "iogon;": "į",
+ "iprod;": "⨼",
+ iquest: "¿",
+ "isinE;": "⋹",
+ "isins;": "⋴",
+ "isinv;": "∈",
+ "Iukcy;": "І",
+ "iukcy;": "і",
+ "Jcirc;": "Ĵ",
+ "jcirc;": "ĵ",
+ "jmath;": "ȷ",
+ "Jukcy;": "Є",
+ "jukcy;": "є",
+ "Kappa;": "Κ",
+ "kappa;": "κ",
+ "lAarr;": "⇚",
+ "langd;": "⦑",
+ "laquo;": "«",
+ "larrb;": "⇤",
+ "lates;": "⪭︀",
+ "lBarr;": "⤎",
+ "lbarr;": "⤌",
+ "lbbrk;": "❲",
+ "lbrke;": "⦋",
+ "lceil;": "⌈",
+ "ldquo;": "“",
+ "lescc;": "⪨",
+ "lhard;": "↽",
+ "lharu;": "↼",
+ "lhblk;": "▄",
+ "llarr;": "⇇",
+ "lltri;": "◺",
+ "lneqq;": "≨",
+ "lnsim;": "⋦",
+ "loang;": "⟬",
+ "loarr;": "⇽",
+ "lobrk;": "⟦",
+ "lopar;": "⦅",
+ "lrarr;": "⇆",
+ "lrhar;": "⇋",
+ "lrtri;": "⊿",
+ "lsime;": "⪍",
+ "lsimg;": "⪏",
+ "lsquo;": "‘",
+ "ltcir;": "⩹",
+ "ltdot;": "⋖",
+ "ltrie;": "⊴",
+ "ltrif;": "◂",
+ "mdash;": "—",
+ "mDDot;": "∺",
+ "micro;": "µ",
+ middot: "·",
+ "minus;": "−",
+ "mumap;": "⊸",
+ "nabla;": "∇",
+ "napid;": "≋̸",
+ "napos;": "ʼn",
+ "natur;": "♮",
+ "nbump;": "≎̸",
+ "ncong;": "≇",
+ "ndash;": "–",
+ "neArr;": "⇗",
+ "nearr;": "↗",
+ "nedot;": "≐̸",
+ "nesim;": "≂̸",
+ "ngeqq;": "≧̸",
+ "ngsim;": "≵",
+ "nhArr;": "⇎",
+ "nharr;": "↮",
+ "nhpar;": "⫲",
+ "nlArr;": "⇍",
+ "nlarr;": "↚",
+ "nleqq;": "≦̸",
+ "nless;": "≮",
+ "nlsim;": "≴",
+ "nltri;": "⋪",
+ "notin;": "∉",
+ "notni;": "∌",
+ "npart;": "∂̸",
+ "nprec;": "⊀",
+ "nrArr;": "⇏",
+ "nrarr;": "↛",
+ "nrtri;": "⋫",
+ "nsime;": "≄",
+ "nsmid;": "∤",
+ "nspar;": "∦",
+ "nsubE;": "⫅̸",
+ "nsube;": "⊈",
+ "nsucc;": "⊁",
+ "nsupE;": "⫆̸",
+ "nsupe;": "⊉",
+ Ntilde: "Ñ",
+ ntilde: "ñ",
+ "numsp;": " ",
+ "nvsim;": "∼⃒",
+ "nwArr;": "⇖",
+ "nwarr;": "↖",
+ Oacute: "Ó",
+ oacute: "ó",
+ "Ocirc;": "Ô",
+ "ocirc;": "ô",
+ "odash;": "⊝",
+ "OElig;": "Œ",
+ "oelig;": "œ",
+ "ofcir;": "⦿",
+ Ograve: "Ò",
+ ograve: "ò",
+ "ohbar;": "⦵",
+ "olarr;": "↺",
+ "olcir;": "⦾",
+ "oline;": "‾",
+ "Omacr;": "Ō",
+ "omacr;": "ō",
+ "Omega;": "Ω",
+ "omega;": "ω",
+ "operp;": "⦹",
+ "oplus;": "⊕",
+ "orarr;": "↻",
+ "order;": "ℴ",
+ Oslash: "Ø",
+ oslash: "ø",
+ Otilde: "Õ",
+ otilde: "õ",
+ "ovbar;": "⌽",
+ "parsl;": "⫽",
+ "phone;": "☎",
+ "plusb;": "⊞",
+ "pluse;": "⩲",
+ plusmn: "±",
+ "pound;": "£",
+ "prcue;": "≼",
+ "Prime;": "″",
+ "prime;": "′",
+ "prnap;": "⪹",
+ "prsim;": "≾",
+ "quest;": "?",
+ "rAarr;": "⇛",
+ "radic;": "√",
+ "rangd;": "⦒",
+ "range;": "⦥",
+ "raquo;": "»",
+ "rarrb;": "⇥",
+ "rarrc;": "⤳",
+ "rarrw;": "↝",
+ "ratio;": "∶",
+ "RBarr;": "⤐",
+ "rBarr;": "⤏",
+ "rbarr;": "⤍",
+ "rbbrk;": "❳",
+ "rbrke;": "⦌",
+ "rceil;": "⌉",
+ "rdquo;": "”",
+ "reals;": "ℝ",
+ "rhard;": "⇁",
+ "rharu;": "⇀",
+ "rlarr;": "⇄",
+ "rlhar;": "⇌",
+ "rnmid;": "⫮",
+ "roang;": "⟭",
+ "roarr;": "⇾",
+ "robrk;": "⟧",
+ "ropar;": "⦆",
+ "rrarr;": "⇉",
+ "rsquo;": "’",
+ "rtrie;": "⊵",
+ "rtrif;": "▸",
+ "sbquo;": "‚",
+ "sccue;": "≽",
+ "Scirc;": "Ŝ",
+ "scirc;": "ŝ",
+ "scnap;": "⪺",
+ "scsim;": "≿",
+ "sdotb;": "⊡",
+ "sdote;": "⩦",
+ "seArr;": "⇘",
+ "searr;": "↘",
+ "setmn;": "∖",
+ "sharp;": "♯",
+ "Sigma;": "Σ",
+ "sigma;": "σ",
+ "simeq;": "≃",
+ "simgE;": "⪠",
+ "simlE;": "⪟",
+ "simne;": "≆",
+ "slarr;": "←",
+ "smile;": "⌣",
+ "smtes;": "⪬︀",
+ "sqcap;": "⊓",
+ "sqcup;": "⊔",
+ "sqsub;": "⊏",
+ "sqsup;": "⊐",
+ "srarr;": "→",
+ "starf;": "★",
+ "strns;": "¯",
+ "subnE;": "⫋",
+ "subne;": "⊊",
+ "supnE;": "⫌",
+ "supne;": "⊋",
+ "swArr;": "⇙",
+ "swarr;": "↙",
+ "szlig;": "ß",
+ "Theta;": "Θ",
+ "theta;": "θ",
+ "thkap;": "≈",
+ "THORN;": "Þ",
+ "thorn;": "þ",
+ "Tilde;": "∼",
+ "tilde;": "˜",
+ "times;": "×",
+ "TRADE;": "™",
+ "trade;": "™",
+ "trisb;": "⧍",
+ "TSHcy;": "Ћ",
+ "tshcy;": "ћ",
+ "twixt;": "≬",
+ Uacute: "Ú",
+ uacute: "ú",
+ "Ubrcy;": "Ў",
+ "ubrcy;": "ў",
+ "Ucirc;": "Û",
+ "ucirc;": "û",
+ "udarr;": "⇅",
+ "udhar;": "⥮",
+ Ugrave: "Ù",
+ ugrave: "ù",
+ "uharl;": "↿",
+ "uharr;": "↾",
+ "uhblk;": "▀",
+ "ultri;": "◸",
+ "Umacr;": "Ū",
+ "umacr;": "ū",
+ "Union;": "⋃",
+ "Uogon;": "Ų",
+ "uogon;": "ų",
+ "uplus;": "⊎",
+ "upsih;": "ϒ",
+ "UpTee;": "⊥",
+ "Uring;": "Ů",
+ "uring;": "ů",
+ "urtri;": "◹",
+ "utdot;": "⋰",
+ "utrif;": "▴",
+ "uuarr;": "⇈",
+ "varpi;": "ϖ",
+ "vBarv;": "⫩",
+ "VDash;": "⊫",
+ "Vdash;": "⊩",
+ "vDash;": "⊨",
+ "vdash;": "⊢",
+ "veeeq;": "≚",
+ "vltri;": "⊲",
+ "vnsub;": "⊂⃒",
+ "vnsup;": "⊃⃒",
+ "vprop;": "∝",
+ "vrtri;": "⊳",
+ "Wcirc;": "Ŵ",
+ "wcirc;": "ŵ",
+ "Wedge;": "⋀",
+ "wedge;": "∧",
+ "xcirc;": "◯",
+ "xdtri;": "▽",
+ "xhArr;": "⟺",
+ "xharr;": "⟷",
+ "xlArr;": "⟸",
+ "xlarr;": "⟵",
+ "xodot;": "⨀",
+ "xrArr;": "⟹",
+ "xrarr;": "⟶",
+ "xutri;": "△",
+ Yacute: "Ý",
+ yacute: "ý",
+ "Ycirc;": "Ŷ",
+ "ycirc;": "ŷ",
+ "Aacute;": "Á",
+ "aacute;": "á",
+ "Abreve;": "Ă",
+ "abreve;": "ă",
+ "Agrave;": "À",
+ "agrave;": "à",
+ "andand;": "⩕",
+ "angmsd;": "∡",
+ "angsph;": "∢",
+ "apacir;": "⩯",
+ "approx;": "≈",
+ "Assign;": "≔",
+ "Atilde;": "Ã",
+ "atilde;": "ã",
+ "barvee;": "⊽",
+ "Barwed;": "⌆",
+ "barwed;": "⌅",
+ "becaus;": "∵",
+ "bernou;": "ℬ",
+ "bigcap;": "⋂",
+ "bigcup;": "⋃",
+ "bigvee;": "⋁",
+ "bkarow;": "⤍",
+ "bottom;": "⊥",
+ "bowtie;": "⋈",
+ "boxbox;": "⧉",
+ "bprime;": "‵",
+ "brvbar;": "¦",
+ "bullet;": "•",
+ "Bumpeq;": "≎",
+ "bumpeq;": "≏",
+ "Cacute;": "Ć",
+ "cacute;": "ć",
+ "capand;": "⩄",
+ "capcap;": "⩋",
+ "capcup;": "⩇",
+ "capdot;": "⩀",
+ "Ccaron;": "Č",
+ "ccaron;": "č",
+ "Ccedil;": "Ç",
+ "ccedil;": "ç",
+ "circeq;": "≗",
+ "cirmid;": "⫯",
+ "Colone;": "⩴",
+ "colone;": "≔",
+ "commat;": "@",
+ "compfn;": "∘",
+ "Conint;": "∯",
+ "conint;": "∮",
+ "coprod;": "∐",
+ "copysr;": "℗",
+ "cularr;": "↶",
+ "CupCap;": "≍",
+ "cupcap;": "⩆",
+ "cupcup;": "⩊",
+ "cupdot;": "⊍",
+ "curarr;": "↷",
+ "curren;": "¤",
+ "cylcty;": "⌭",
+ "Dagger;": "‡",
+ "dagger;": "†",
+ "daleth;": "ℸ",
+ "Dcaron;": "Ď",
+ "dcaron;": "ď",
+ "dfisht;": "⥿",
+ "divide;": "÷",
+ "divonx;": "⋇",
+ "dlcorn;": "⌞",
+ "dlcrop;": "⌍",
+ "dollar;": "$",
+ "DotDot;": "⃜",
+ "drcorn;": "⌟",
+ "drcrop;": "⌌",
+ "Dstrok;": "Đ",
+ "dstrok;": "đ",
+ "Eacute;": "É",
+ "eacute;": "é",
+ "easter;": "⩮",
+ "Ecaron;": "Ě",
+ "ecaron;": "ě",
+ "ecolon;": "≕",
+ "Egrave;": "È",
+ "egrave;": "è",
+ "egsdot;": "⪘",
+ "elsdot;": "⪗",
+ "emptyv;": "∅",
+ "emsp13;": " ",
+ "emsp14;": " ",
+ "eparsl;": "⧣",
+ "eqcirc;": "≖",
+ "equals;": "=",
+ "equest;": "≟",
+ "Exists;": "∃",
+ "female;": "♀",
+ "ffilig;": "ffi",
+ "ffllig;": "ffl",
+ "ForAll;": "∀",
+ "forall;": "∀",
+ "frac12;": "½",
+ "frac13;": "⅓",
+ "frac14;": "¼",
+ "frac15;": "⅕",
+ "frac16;": "⅙",
+ "frac18;": "⅛",
+ "frac23;": "⅔",
+ "frac25;": "⅖",
+ "frac34;": "¾",
+ "frac35;": "⅗",
+ "frac38;": "⅜",
+ "frac45;": "⅘",
+ "frac56;": "⅚",
+ "frac58;": "⅝",
+ "frac78;": "⅞",
+ "gacute;": "ǵ",
+ "Gammad;": "Ϝ",
+ "gammad;": "ϝ",
+ "Gbreve;": "Ğ",
+ "gbreve;": "ğ",
+ "Gcedil;": "Ģ",
+ "gesdot;": "⪀",
+ "gesles;": "⪔",
+ "gtlPar;": "⦕",
+ "gtrarr;": "⥸",
+ "gtrdot;": "⋗",
+ "gtrsim;": "≳",
+ "hairsp;": " ",
+ "hamilt;": "ℋ",
+ "HARDcy;": "Ъ",
+ "hardcy;": "ъ",
+ "hearts;": "♥",
+ "hellip;": "…",
+ "hercon;": "⊹",
+ "homtht;": "∻",
+ "horbar;": "―",
+ "hslash;": "ℏ",
+ "Hstrok;": "Ħ",
+ "hstrok;": "ħ",
+ "hybull;": "⁃",
+ "hyphen;": "‐",
+ "Iacute;": "Í",
+ "iacute;": "í",
+ "Igrave;": "Ì",
+ "igrave;": "ì",
+ "iiiint;": "⨌",
+ "iinfin;": "⧜",
+ "incare;": "℅",
+ "inodot;": "ı",
+ "intcal;": "⊺",
+ "iquest;": "¿",
+ "isinsv;": "⋳",
+ "Itilde;": "Ĩ",
+ "itilde;": "ĩ",
+ "Jsercy;": "Ј",
+ "jsercy;": "ј",
+ "kappav;": "ϰ",
+ "Kcedil;": "Ķ",
+ "kcedil;": "ķ",
+ "kgreen;": "ĸ",
+ "Lacute;": "Ĺ",
+ "lacute;": "ĺ",
+ "lagran;": "ℒ",
+ "Lambda;": "Λ",
+ "lambda;": "λ",
+ "langle;": "⟨",
+ "larrfs;": "⤝",
+ "larrhk;": "↩",
+ "larrlp;": "↫",
+ "larrpl;": "⤹",
+ "larrtl;": "↢",
+ "lAtail;": "⤛",
+ "latail;": "⤙",
+ "lbrace;": "{",
+ "lbrack;": "[",
+ "Lcaron;": "Ľ",
+ "lcaron;": "ľ",
+ "Lcedil;": "Ļ",
+ "lcedil;": "ļ",
+ "ldquor;": "„",
+ "lesdot;": "⩿",
+ "lesges;": "⪓",
+ "lfisht;": "⥼",
+ "lfloor;": "⌊",
+ "lharul;": "⥪",
+ "llhard;": "⥫",
+ "Lmidot;": "Ŀ",
+ "lmidot;": "ŀ",
+ "lmoust;": "⎰",
+ "loplus;": "⨭",
+ "lowast;": "∗",
+ "lowbar;": "_",
+ "lparlt;": "⦓",
+ "lrhard;": "⥭",
+ "lsaquo;": "‹",
+ "lsquor;": "‚",
+ "Lstrok;": "Ł",
+ "lstrok;": "ł",
+ "lthree;": "⋋",
+ "ltimes;": "⋉",
+ "ltlarr;": "⥶",
+ "ltrPar;": "⦖",
+ "mapsto;": "↦",
+ "marker;": "▮",
+ "mcomma;": "⨩",
+ "midast;": "*",
+ "midcir;": "⫰",
+ "middot;": "·",
+ "minusb;": "⊟",
+ "minusd;": "∸",
+ "mnplus;": "∓",
+ "models;": "⊧",
+ "mstpos;": "∾",
+ "Nacute;": "Ń",
+ "nacute;": "ń",
+ "nbumpe;": "≏̸",
+ "Ncaron;": "Ň",
+ "ncaron;": "ň",
+ "Ncedil;": "Ņ",
+ "ncedil;": "ņ",
+ "nearhk;": "⤤",
+ "nequiv;": "≢",
+ "nesear;": "⤨",
+ "nexist;": "∄",
+ "nltrie;": "⋬",
+ "notinE;": "⋹̸",
+ "nparsl;": "⫽⃥",
+ "nprcue;": "⋠",
+ "nrarrc;": "⤳̸",
+ "nrarrw;": "↝̸",
+ "nrtrie;": "⋭",
+ "nsccue;": "⋡",
+ "nsimeq;": "≄",
+ "Ntilde;": "Ñ",
+ "ntilde;": "ñ",
+ "numero;": "№",
+ "nVDash;": "⊯",
+ "nVdash;": "⊮",
+ "nvDash;": "⊭",
+ "nvdash;": "⊬",
+ "nvHarr;": "⤄",
+ "nvlArr;": "⤂",
+ "nvrArr;": "⤃",
+ "nwarhk;": "⤣",
+ "nwnear;": "⤧",
+ "Oacute;": "Ó",
+ "oacute;": "ó",
+ "Odblac;": "Ő",
+ "odblac;": "ő",
+ "odsold;": "⦼",
+ "Ograve;": "Ò",
+ "ograve;": "ò",
+ "ominus;": "⊖",
+ "origof;": "⊶",
+ "Oslash;": "Ø",
+ "oslash;": "ø",
+ "Otilde;": "Õ",
+ "otilde;": "õ",
+ "Otimes;": "⨷",
+ "otimes;": "⊗",
+ "parsim;": "⫳",
+ "percnt;": "%",
+ "period;": ".",
+ "permil;": "‰",
+ "phmmat;": "ℳ",
+ "planck;": "ℏ",
+ "plankv;": "ℏ",
+ "plusdo;": "∔",
+ "plusdu;": "⨥",
+ "plusmn;": "±",
+ "preceq;": "⪯",
+ "primes;": "ℙ",
+ "prnsim;": "⋨",
+ "propto;": "∝",
+ "prurel;": "⊰",
+ "puncsp;": " ",
+ "qprime;": "⁗",
+ "Racute;": "Ŕ",
+ "racute;": "ŕ",
+ "rangle;": "⟩",
+ "rarrap;": "⥵",
+ "rarrfs;": "⤞",
+ "rarrhk;": "↪",
+ "rarrlp;": "↬",
+ "rarrpl;": "⥅",
+ "Rarrtl;": "⤖",
+ "rarrtl;": "↣",
+ "rAtail;": "⤜",
+ "ratail;": "⤚",
+ "rbrace;": "}",
+ "rbrack;": "]",
+ "Rcaron;": "Ř",
+ "rcaron;": "ř",
+ "Rcedil;": "Ŗ",
+ "rcedil;": "ŗ",
+ "rdquor;": "”",
+ "rfisht;": "⥽",
+ "rfloor;": "⌋",
+ "rharul;": "⥬",
+ "rmoust;": "⎱",
+ "roplus;": "⨮",
+ "rpargt;": "⦔",
+ "rsaquo;": "›",
+ "rsquor;": "’",
+ "rthree;": "⋌",
+ "rtimes;": "⋊",
+ "Sacute;": "Ś",
+ "sacute;": "ś",
+ "Scaron;": "Š",
+ "scaron;": "š",
+ "Scedil;": "Ş",
+ "scedil;": "ş",
+ "scnsim;": "⋩",
+ "searhk;": "⤥",
+ "seswar;": "⤩",
+ "sfrown;": "⌢",
+ "SHCHcy;": "Щ",
+ "shchcy;": "щ",
+ "sigmaf;": "ς",
+ "sigmav;": "ς",
+ "simdot;": "⩪",
+ "smashp;": "⨳",
+ "SOFTcy;": "Ь",
+ "softcy;": "ь",
+ "solbar;": "⌿",
+ "spades;": "♠",
+ "sqcaps;": "⊓︀",
+ "sqcups;": "⊔︀",
+ "sqsube;": "⊑",
+ "sqsupe;": "⊒",
+ "Square;": "□",
+ "square;": "□",
+ "squarf;": "▪",
+ "ssetmn;": "∖",
+ "ssmile;": "⌣",
+ "sstarf;": "⋆",
+ "subdot;": "⪽",
+ "Subset;": "⋐",
+ "subset;": "⊂",
+ "subsim;": "⫇",
+ "subsub;": "⫕",
+ "subsup;": "⫓",
+ "succeq;": "⪰",
+ "supdot;": "⪾",
+ "Supset;": "⋑",
+ "supset;": "⊃",
+ "supsim;": "⫈",
+ "supsub;": "⫔",
+ "supsup;": "⫖",
+ "swarhk;": "⤦",
+ "swnwar;": "⤪",
+ "target;": "⌖",
+ "Tcaron;": "Ť",
+ "tcaron;": "ť",
+ "Tcedil;": "Ţ",
+ "tcedil;": "ţ",
+ "telrec;": "⌕",
+ "there4;": "∴",
+ "thetav;": "ϑ",
+ "thinsp;": " ",
+ "thksim;": "∼",
+ "timesb;": "⊠",
+ "timesd;": "⨰",
+ "topbot;": "⌶",
+ "topcir;": "⫱",
+ "tprime;": "‴",
+ "tridot;": "◬",
+ "Tstrok;": "Ŧ",
+ "tstrok;": "ŧ",
+ "Uacute;": "Ú",
+ "uacute;": "ú",
+ "Ubreve;": "Ŭ",
+ "ubreve;": "ŭ",
+ "Udblac;": "Ű",
+ "udblac;": "ű",
+ "ufisht;": "⥾",
+ "Ugrave;": "Ù",
+ "ugrave;": "ù",
+ "ulcorn;": "⌜",
+ "ulcrop;": "⌏",
+ "urcorn;": "⌝",
+ "urcrop;": "⌎",
+ "Utilde;": "Ũ",
+ "utilde;": "ũ",
+ "vangrt;": "⦜",
+ "varphi;": "ϕ",
+ "varrho;": "ϱ",
+ "Vdashl;": "⫦",
+ "veebar;": "⊻",
+ "vellip;": "⋮",
+ "Verbar;": "‖",
+ "verbar;": "|",
+ "vsubnE;": "⫋︀",
+ "vsubne;": "⊊︀",
+ "vsupnE;": "⫌︀",
+ "vsupne;": "⊋︀",
+ "Vvdash;": "⊪",
+ "wedbar;": "⩟",
+ "wedgeq;": "≙",
+ "weierp;": "℘",
+ "wreath;": "≀",
+ "xoplus;": "⨁",
+ "xotime;": "⨂",
+ "xsqcup;": "⨆",
+ "xuplus;": "⨄",
+ "xwedge;": "⋀",
+ "Yacute;": "Ý",
+ "yacute;": "ý",
+ "Zacute;": "Ź",
+ "zacute;": "ź",
+ "Zcaron;": "Ž",
+ "zcaron;": "ž",
+ "zeetrf;": "ℨ",
+ "alefsym;": "ℵ",
+ "angrtvb;": "⊾",
+ "angzarr;": "⍼",
+ "asympeq;": "≍",
+ "backsim;": "∽",
+ "Because;": "∵",
+ "because;": "∵",
+ "bemptyv;": "⦰",
+ "between;": "≬",
+ "bigcirc;": "◯",
+ "bigodot;": "⨀",
+ "bigstar;": "★",
+ "bnequiv;": "≡⃥",
+ "boxplus;": "⊞",
+ "Cayleys;": "ℭ",
+ "Cconint;": "∰",
+ "ccupssm;": "⩐",
+ "Cedilla;": "¸",
+ "cemptyv;": "⦲",
+ "cirscir;": "⧂",
+ "coloneq;": "≔",
+ "congdot;": "⩭",
+ "cudarrl;": "⤸",
+ "cudarrr;": "⤵",
+ "cularrp;": "⤽",
+ "curarrm;": "⤼",
+ "dbkarow;": "⤏",
+ "ddagger;": "‡",
+ "ddotseq;": "⩷",
+ "demptyv;": "⦱",
+ "Diamond;": "⋄",
+ "diamond;": "⋄",
+ "digamma;": "ϝ",
+ "dotplus;": "∔",
+ "DownTee;": "⊤",
+ "dwangle;": "⦦",
+ "Element;": "∈",
+ "Epsilon;": "Ε",
+ "epsilon;": "ε",
+ "eqcolon;": "≕",
+ "equivDD;": "⩸",
+ "gesdoto;": "⪂",
+ "gtquest;": "⩼",
+ "gtrless;": "≷",
+ "harrcir;": "⥈",
+ "Implies;": "⇒",
+ "intprod;": "⨼",
+ "isindot;": "⋵",
+ "larrbfs;": "⤟",
+ "larrsim;": "⥳",
+ "lbrksld;": "⦏",
+ "lbrkslu;": "⦍",
+ "ldrdhar;": "⥧",
+ "LeftTee;": "⊣",
+ "lesdoto;": "⪁",
+ "lessdot;": "⋖",
+ "lessgtr;": "≶",
+ "lesssim;": "≲",
+ "lotimes;": "⨴",
+ "lozenge;": "◊",
+ "ltquest;": "⩻",
+ "luruhar;": "⥦",
+ "maltese;": "✠",
+ "minusdu;": "⨪",
+ "napprox;": "≉",
+ "natural;": "♮",
+ "nearrow;": "↗",
+ "NewLine;": "\n",
+ "nexists;": "∄",
+ "NoBreak;": "",
+ "notinva;": "∉",
+ "notinvb;": "⋷",
+ "notinvc;": "⋶",
+ "NotLess;": "≮",
+ "notniva;": "∌",
+ "notnivb;": "⋾",
+ "notnivc;": "⋽",
+ "npolint;": "⨔",
+ "npreceq;": "⪯̸",
+ "nsqsube;": "⋢",
+ "nsqsupe;": "⋣",
+ "nsubset;": "⊂⃒",
+ "nsucceq;": "⪰̸",
+ "nsupset;": "⊃⃒",
+ "nvinfin;": "⧞",
+ "nvltrie;": "⊴⃒",
+ "nvrtrie;": "⊵⃒",
+ "nwarrow;": "↖",
+ "olcross;": "⦻",
+ "Omicron;": "Ο",
+ "omicron;": "ο",
+ "orderof;": "ℴ",
+ "orslope;": "⩗",
+ "OverBar;": "‾",
+ "pertenk;": "‱",
+ "planckh;": "ℎ",
+ "pluscir;": "⨢",
+ "plussim;": "⨦",
+ "plustwo;": "⨧",
+ "precsim;": "≾",
+ "Product;": "∏",
+ "quatint;": "⨖",
+ "questeq;": "≟",
+ "rarrbfs;": "⤠",
+ "rarrsim;": "⥴",
+ "rbrksld;": "⦎",
+ "rbrkslu;": "⦐",
+ "rdldhar;": "⥩",
+ "realine;": "ℛ",
+ "rotimes;": "⨵",
+ "ruluhar;": "⥨",
+ "searrow;": "↘",
+ "simplus;": "⨤",
+ "simrarr;": "⥲",
+ "subedot;": "⫃",
+ "submult;": "⫁",
+ "subplus;": "⪿",
+ "subrarr;": "⥹",
+ "succsim;": "≿",
+ "supdsub;": "⫘",
+ "supedot;": "⫄",
+ "suphsol;": "⟉",
+ "suphsub;": "⫗",
+ "suplarr;": "⥻",
+ "supmult;": "⫂",
+ "supplus;": "⫀",
+ "swarrow;": "↙",
+ "topfork;": "⫚",
+ "triplus;": "⨹",
+ "tritime;": "⨻",
+ "UpArrow;": "↑",
+ "Uparrow;": "⇑",
+ "uparrow;": "↑",
+ "Upsilon;": "Υ",
+ "upsilon;": "υ",
+ "uwangle;": "⦧",
+ "vzigzag;": "⦚",
+ "zigrarr;": "⇝",
+ "andslope;": "⩘",
+ "angmsdaa;": "⦨",
+ "angmsdab;": "⦩",
+ "angmsdac;": "⦪",
+ "angmsdad;": "⦫",
+ "angmsdae;": "⦬",
+ "angmsdaf;": "⦭",
+ "angmsdag;": "⦮",
+ "angmsdah;": "⦯",
+ "angrtvbd;": "⦝",
+ "approxeq;": "≊",
+ "awconint;": "∳",
+ "backcong;": "≌",
+ "barwedge;": "⌅",
+ "bbrktbrk;": "⎶",
+ "bigoplus;": "⨁",
+ "bigsqcup;": "⨆",
+ "biguplus;": "⨄",
+ "bigwedge;": "⋀",
+ "boxminus;": "⊟",
+ "boxtimes;": "⊠",
+ "bsolhsub;": "⟈",
+ "capbrcup;": "⩉",
+ "circledR;": "®",
+ "circledS;": "Ⓢ",
+ "cirfnint;": "⨐",
+ "clubsuit;": "♣",
+ "cupbrcap;": "⩈",
+ "curlyvee;": "⋎",
+ "cwconint;": "∲",
+ "DDotrahd;": "⤑",
+ "doteqdot;": "≑",
+ "DotEqual;": "≐",
+ "dotminus;": "∸",
+ "drbkarow;": "⤐",
+ "dzigrarr;": "⟿",
+ "elinters;": "⏧",
+ "emptyset;": "∅",
+ "eqvparsl;": "⧥",
+ "fpartint;": "⨍",
+ "geqslant;": "⩾",
+ "gesdotol;": "⪄",
+ "gnapprox;": "⪊",
+ "hksearow;": "⤥",
+ "hkswarow;": "⤦",
+ "imagline;": "ℐ",
+ "imagpart;": "ℑ",
+ "infintie;": "⧝",
+ "integers;": "ℤ",
+ "Integral;": "∫",
+ "intercal;": "⊺",
+ "intlarhk;": "⨗",
+ "laemptyv;": "⦴",
+ "ldrushar;": "⥋",
+ "leqslant;": "⩽",
+ "lesdotor;": "⪃",
+ "LessLess;": "⪡",
+ "llcorner;": "⌞",
+ "lnapprox;": "⪉",
+ "lrcorner;": "⌟",
+ "lurdshar;": "⥊",
+ "mapstoup;": "↥",
+ "multimap;": "⊸",
+ "naturals;": "ℕ",
+ "ncongdot;": "⩭̸",
+ "NotEqual;": "≠",
+ "notindot;": "⋵̸",
+ "NotTilde;": "≁",
+ "otimesas;": "⨶",
+ "parallel;": "∥",
+ "PartialD;": "∂",
+ "plusacir;": "⨣",
+ "pointint;": "⨕",
+ "Precedes;": "≺",
+ "precneqq;": "⪵",
+ "precnsim;": "⋨",
+ "profalar;": "⌮",
+ "profline;": "⌒",
+ "profsurf;": "⌓",
+ "raemptyv;": "⦳",
+ "realpart;": "ℜ",
+ "RightTee;": "⊢",
+ "rppolint;": "⨒",
+ "rtriltri;": "⧎",
+ "scpolint;": "⨓",
+ "setminus;": "∖",
+ "shortmid;": "∣",
+ "smeparsl;": "⧤",
+ "sqsubset;": "⊏",
+ "sqsupset;": "⊐",
+ "subseteq;": "⊆",
+ "Succeeds;": "≻",
+ "succneqq;": "⪶",
+ "succnsim;": "⋩",
+ "SuchThat;": "∋",
+ "Superset;": "⊃",
+ "supseteq;": "⊇",
+ "thetasym;": "ϑ",
+ "thicksim;": "∼",
+ "timesbar;": "⨱",
+ "triangle;": "▵",
+ "triminus;": "⨺",
+ "trpezium;": "⏢",
+ "Uarrocir;": "⥉",
+ "ulcorner;": "⌜",
+ "UnderBar;": "_",
+ "urcorner;": "⌝",
+ "varkappa;": "ϰ",
+ "varsigma;": "ς",
+ "vartheta;": "ϑ",
+ "backprime;": "‵",
+ "backsimeq;": "⋍",
+ "Backslash;": "∖",
+ "bigotimes;": "⨂",
+ "CenterDot;": "·",
+ "centerdot;": "·",
+ "checkmark;": "✓",
+ "CircleDot;": "⊙",
+ "complexes;": "ℂ",
+ "Congruent;": "≡",
+ "Coproduct;": "∐",
+ "dotsquare;": "⊡",
+ "DoubleDot;": "¨",
+ "DownArrow;": "↓",
+ "Downarrow;": "⇓",
+ "downarrow;": "↓",
+ "DownBreve;": "̑",
+ "gtrapprox;": "⪆",
+ "gtreqless;": "⋛",
+ "gvertneqq;": "≩︀",
+ "heartsuit;": "♥",
+ "HumpEqual;": "≏",
+ "LeftArrow;": "←",
+ "Leftarrow;": "⇐",
+ "leftarrow;": "←",
+ "LeftFloor;": "⌊",
+ "lesseqgtr;": "⋚",
+ "LessTilde;": "≲",
+ "lvertneqq;": "≨︀",
+ "Mellintrf;": "ℳ",
+ "MinusPlus;": "∓",
+ "ngeqslant;": "⩾̸",
+ "nleqslant;": "⩽̸",
+ "NotCupCap;": "≭",
+ "NotExists;": "∄",
+ "NotSubset;": "⊂⃒",
+ "nparallel;": "∦",
+ "nshortmid;": "∤",
+ "nsubseteq;": "⊈",
+ "nsupseteq;": "⊉",
+ "OverBrace;": "⏞",
+ "pitchfork;": "⋔",
+ "PlusMinus;": "±",
+ "rationals;": "ℚ",
+ "spadesuit;": "♠",
+ "subseteqq;": "⫅",
+ "subsetneq;": "⊊",
+ "supseteqq;": "⫆",
+ "supsetneq;": "⊋",
+ "Therefore;": "∴",
+ "therefore;": "∴",
+ "ThinSpace;": " ",
+ "triangleq;": "≜",
+ "TripleDot;": "⃛",
+ "UnionPlus;": "⊎",
+ "varpropto;": "∝",
+ "Bernoullis;": "ℬ",
+ "circledast;": "⊛",
+ "CirclePlus;": "⊕",
+ "complement;": "∁",
+ "curlywedge;": "⋏",
+ "eqslantgtr;": "⪖",
+ "EqualTilde;": "≂",
+ "Fouriertrf;": "ℱ",
+ "gtreqqless;": "⪌",
+ "ImaginaryI;": "ⅈ",
+ "Laplacetrf;": "ℒ",
+ "LeftVector;": "↼",
+ "lessapprox;": "⪅",
+ "lesseqqgtr;": "⪋",
+ "Lleftarrow;": "⇚",
+ "lmoustache;": "⎰",
+ "longmapsto;": "⟼",
+ "mapstodown;": "↧",
+ "mapstoleft;": "↤",
+ "nLeftarrow;": "⇍",
+ "nleftarrow;": "↚",
+ "NotElement;": "∉",
+ "NotGreater;": "≯",
+ "nsubseteqq;": "⫅̸",
+ "nsupseteqq;": "⫆̸",
+ "precapprox;": "⪷",
+ "Proportion;": "∷",
+ "RightArrow;": "→",
+ "Rightarrow;": "⇒",
+ "rightarrow;": "→",
+ "RightFloor;": "⌋",
+ "rmoustache;": "⎱",
+ "sqsubseteq;": "⊑",
+ "sqsupseteq;": "⊒",
+ "subsetneqq;": "⫋",
+ "succapprox;": "⪸",
+ "supsetneqq;": "⫌",
+ "ThickSpace;": " ",
+ "TildeEqual;": "≃",
+ "TildeTilde;": "≈",
+ "UnderBrace;": "⏟",
+ "UpArrowBar;": "⤒",
+ "UpTeeArrow;": "↥",
+ "upuparrows;": "⇈",
+ "varepsilon;": "ϵ",
+ "varnothing;": "∅",
+ "backepsilon;": "϶",
+ "blacksquare;": "▪",
+ "circledcirc;": "⊚",
+ "circleddash;": "⊝",
+ "CircleMinus;": "⊖",
+ "CircleTimes;": "⊗",
+ "curlyeqprec;": "⋞",
+ "curlyeqsucc;": "⋟",
+ "diamondsuit;": "♦",
+ "eqslantless;": "⪕",
+ "Equilibrium;": "⇌",
+ "expectation;": "ℰ",
+ "GreaterLess;": "≷",
+ "LeftCeiling;": "⌈",
+ "LessGreater;": "≶",
+ "MediumSpace;": " ",
+ "NotLessLess;": "≪̸",
+ "NotPrecedes;": "⊀",
+ "NotSucceeds;": "⊁",
+ "NotSuperset;": "⊃⃒",
+ "nRightarrow;": "⇏",
+ "nrightarrow;": "↛",
+ "OverBracket;": "⎴",
+ "preccurlyeq;": "≼",
+ "precnapprox;": "⪹",
+ "quaternions;": "ℍ",
+ "RightVector;": "⇀",
+ "Rrightarrow;": "⇛",
+ "RuleDelayed;": "⧴",
+ "SmallCircle;": "∘",
+ "SquareUnion;": "⊔",
+ "straightphi;": "ϕ",
+ "SubsetEqual;": "⊆",
+ "succcurlyeq;": "≽",
+ "succnapprox;": "⪺",
+ "thickapprox;": "≈",
+ "UpDownArrow;": "↕",
+ "Updownarrow;": "⇕",
+ "updownarrow;": "↕",
+ "VerticalBar;": "∣",
+ "blacklozenge;": "⧫",
+ "DownArrowBar;": "⤓",
+ "DownTeeArrow;": "↧",
+ "ExponentialE;": "ⅇ",
+ "exponentiale;": "ⅇ",
+ "GreaterEqual;": "≥",
+ "GreaterTilde;": "≳",
+ "HilbertSpace;": "ℋ",
+ "HumpDownHump;": "≎",
+ "Intersection;": "⋂",
+ "LeftArrowBar;": "⇤",
+ "LeftTeeArrow;": "↤",
+ "LeftTriangle;": "⊲",
+ "LeftUpVector;": "↿",
+ "NotCongruent;": "≢",
+ "NotHumpEqual;": "≏̸",
+ "NotLessEqual;": "≰",
+ "NotLessTilde;": "≴",
+ "Proportional;": "∝",
+ "RightCeiling;": "⌉",
+ "risingdotseq;": "≓",
+ "RoundImplies;": "⥰",
+ "ShortUpArrow;": "↑",
+ "SquareSubset;": "⊏",
+ "triangledown;": "▿",
+ "triangleleft;": "◃",
+ "UnderBracket;": "⎵",
+ "varsubsetneq;": "⊊︀",
+ "varsupsetneq;": "⊋︀",
+ "VerticalLine;": "|",
+ "ApplyFunction;": "",
+ "bigtriangleup;": "△",
+ "blacktriangle;": "▴",
+ "DifferentialD;": "ⅆ",
+ "divideontimes;": "⋇",
+ "DoubleLeftTee;": "⫤",
+ "DoubleUpArrow;": "⇑",
+ "fallingdotseq;": "≒",
+ "hookleftarrow;": "↩",
+ "leftarrowtail;": "↢",
+ "leftharpoonup;": "↼",
+ "LeftTeeVector;": "⥚",
+ "LeftVectorBar;": "⥒",
+ "LessFullEqual;": "≦",
+ "LongLeftArrow;": "⟵",
+ "Longleftarrow;": "⟸",
+ "longleftarrow;": "⟵",
+ "looparrowleft;": "↫",
+ "measuredangle;": "∡",
+ "NotEqualTilde;": "≂̸",
+ "NotTildeEqual;": "≄",
+ "NotTildeTilde;": "≉",
+ "ntriangleleft;": "⋪",
+ "Poincareplane;": "ℌ",
+ "PrecedesEqual;": "⪯",
+ "PrecedesTilde;": "≾",
+ "RightArrowBar;": "⇥",
+ "RightTeeArrow;": "↦",
+ "RightTriangle;": "⊳",
+ "RightUpVector;": "↾",
+ "shortparallel;": "∥",
+ "smallsetminus;": "∖",
+ "SucceedsEqual;": "⪰",
+ "SucceedsTilde;": "≿",
+ "SupersetEqual;": "⊇",
+ "triangleright;": "▹",
+ "UpEquilibrium;": "⥮",
+ "upharpoonleft;": "↿",
+ "varsubsetneqq;": "⫋︀",
+ "varsupsetneqq;": "⫌︀",
+ "VerticalTilde;": "≀",
+ "VeryThinSpace;": " ",
+ "curvearrowleft;": "↶",
+ "DiacriticalDot;": "˙",
+ "doublebarwedge;": "⌆",
+ "DoubleRightTee;": "⊨",
+ "downdownarrows;": "⇊",
+ "DownLeftVector;": "↽",
+ "GreaterGreater;": "⪢",
+ "hookrightarrow;": "↪",
+ "HorizontalLine;": "─",
+ "InvisibleComma;": "",
+ "InvisibleTimes;": "",
+ "LeftDownVector;": "⇃",
+ "leftleftarrows;": "⇇",
+ "LeftRightArrow;": "↔",
+ "Leftrightarrow;": "⇔",
+ "leftrightarrow;": "↔",
+ "leftthreetimes;": "⋋",
+ "LessSlantEqual;": "⩽",
+ "LongRightArrow;": "⟶",
+ "Longrightarrow;": "⟹",
+ "longrightarrow;": "⟶",
+ "looparrowright;": "↬",
+ "LowerLeftArrow;": "↙",
+ "NestedLessLess;": "≪",
+ "NotGreaterLess;": "≹",
+ "NotLessGreater;": "≸",
+ "NotSubsetEqual;": "⊈",
+ "NotVerticalBar;": "∤",
+ "nshortparallel;": "∦",
+ "ntriangleright;": "⋫",
+ "OpenCurlyQuote;": "‘",
+ "ReverseElement;": "∋",
+ "rightarrowtail;": "↣",
+ "rightharpoonup;": "⇀",
+ "RightTeeVector;": "⥛",
+ "RightVectorBar;": "⥓",
+ "ShortDownArrow;": "↓",
+ "ShortLeftArrow;": "←",
+ "SquareSuperset;": "⊐",
+ "TildeFullEqual;": "≅",
+ "trianglelefteq;": "⊴",
+ "upharpoonright;": "↾",
+ "UpperLeftArrow;": "↖",
+ "ZeroWidthSpace;": "",
+ "bigtriangledown;": "▽",
+ "circlearrowleft;": "↺",
+ "CloseCurlyQuote;": "’",
+ "ContourIntegral;": "∮",
+ "curvearrowright;": "↷",
+ "DoubleDownArrow;": "⇓",
+ "DoubleLeftArrow;": "⇐",
+ "downharpoonleft;": "⇃",
+ "DownRightVector;": "⇁",
+ "leftharpoondown;": "↽",
+ "leftrightarrows;": "⇆",
+ "LeftRightVector;": "⥎",
+ "LeftTriangleBar;": "⧏",
+ "LeftUpTeeVector;": "⥠",
+ "LeftUpVectorBar;": "⥘",
+ "LowerRightArrow;": "↘",
+ "nLeftrightarrow;": "⇎",
+ "nleftrightarrow;": "↮",
+ "NotGreaterEqual;": "≱",
+ "NotGreaterTilde;": "≵",
+ "NotHumpDownHump;": "≎̸",
+ "NotLeftTriangle;": "⋪",
+ "NotSquareSubset;": "⊏̸",
+ "ntrianglelefteq;": "⋬",
+ "OverParenthesis;": "⏜",
+ "RightDownVector;": "⇂",
+ "rightleftarrows;": "⇄",
+ "rightsquigarrow;": "↝",
+ "rightthreetimes;": "⋌",
+ "ShortRightArrow;": "→",
+ "straightepsilon;": "ϵ",
+ "trianglerighteq;": "⊵",
+ "UpperRightArrow;": "↗",
+ "vartriangleleft;": "⊲",
+ "circlearrowright;": "↻",
+ "DiacriticalAcute;": "´",
+ "DiacriticalGrave;": "`",
+ "DiacriticalTilde;": "˜",
+ "DoubleRightArrow;": "⇒",
+ "DownArrowUpArrow;": "⇵",
+ "downharpoonright;": "⇂",
+ "EmptySmallSquare;": "◻",
+ "GreaterEqualLess;": "⋛",
+ "GreaterFullEqual;": "≧",
+ "LeftAngleBracket;": "⟨",
+ "LeftUpDownVector;": "⥑",
+ "LessEqualGreater;": "⋚",
+ "NonBreakingSpace;": " ",
+ "NotPrecedesEqual;": "⪯̸",
+ "NotRightTriangle;": "⋫",
+ "NotSucceedsEqual;": "⪰̸",
+ "NotSucceedsTilde;": "≿̸",
+ "NotSupersetEqual;": "⊉",
+ "ntrianglerighteq;": "⋭",
+ "rightharpoondown;": "⇁",
+ "rightrightarrows;": "⇉",
+ "RightTriangleBar;": "⧐",
+ "RightUpTeeVector;": "⥜",
+ "RightUpVectorBar;": "⥔",
+ "twoheadleftarrow;": "↞",
+ "UnderParenthesis;": "⏝",
+ "UpArrowDownArrow;": "⇅",
+ "vartriangleright;": "⊳",
+ "blacktriangledown;": "▾",
+ "blacktriangleleft;": "◂",
+ "DoubleUpDownArrow;": "⇕",
+ "DoubleVerticalBar;": "∥",
+ "DownLeftTeeVector;": "⥞",
+ "DownLeftVectorBar;": "⥖",
+ "FilledSmallSquare;": "◼",
+ "GreaterSlantEqual;": "⩾",
+ "LeftDoubleBracket;": "⟦",
+ "LeftDownTeeVector;": "⥡",
+ "LeftDownVectorBar;": "⥙",
+ "leftrightharpoons;": "⇋",
+ "LeftTriangleEqual;": "⊴",
+ "NegativeThinSpace;": "",
+ "NotGreaterGreater;": "≫̸",
+ "NotLessSlantEqual;": "⩽̸",
+ "NotNestedLessLess;": "⪡̸",
+ "NotReverseElement;": "∌",
+ "NotSquareSuperset;": "⊐̸",
+ "NotTildeFullEqual;": "≇",
+ "RightAngleBracket;": "⟩",
+ "rightleftharpoons;": "⇌",
+ "RightUpDownVector;": "⥏",
+ "SquareSubsetEqual;": "⊑",
+ "twoheadrightarrow;": "↠",
+ "VerticalSeparator;": "❘",
+ "blacktriangleright;": "▸",
+ "DownRightTeeVector;": "⥟",
+ "DownRightVectorBar;": "⥗",
+ "LongLeftRightArrow;": "⟷",
+ "Longleftrightarrow;": "⟺",
+ "longleftrightarrow;": "⟷",
+ "NegativeThickSpace;": "",
+ "NotLeftTriangleBar;": "⧏̸",
+ "PrecedesSlantEqual;": "≼",
+ "ReverseEquilibrium;": "⇋",
+ "RightDoubleBracket;": "⟧",
+ "RightDownTeeVector;": "⥝",
+ "RightDownVectorBar;": "⥕",
+ "RightTriangleEqual;": "⊵",
+ "SquareIntersection;": "⊓",
+ "SucceedsSlantEqual;": "≽",
+ "DoubleLongLeftArrow;": "⟸",
+ "DownLeftRightVector;": "⥐",
+ "LeftArrowRightArrow;": "⇆",
+ "leftrightsquigarrow;": "↭",
+ "NegativeMediumSpace;": "",
+ "NotGreaterFullEqual;": "≧̸",
+ "NotRightTriangleBar;": "⧐̸",
+ "RightArrowLeftArrow;": "⇄",
+ "SquareSupersetEqual;": "⊒",
+ "CapitalDifferentialD;": "ⅅ",
+ "DoubleLeftRightArrow;": "⇔",
+ "DoubleLongRightArrow;": "⟹",
+ "EmptyVerySmallSquare;": "▫",
+ "NestedGreaterGreater;": "≫",
+ "NotDoubleVerticalBar;": "∦",
+ "NotGreaterSlantEqual;": "⩾̸",
+ "NotLeftTriangleEqual;": "⋬",
+ "NotSquareSubsetEqual;": "⋢",
+ "OpenCurlyDoubleQuote;": "“",
+ "ReverseUpEquilibrium;": "⥯",
+ "CloseCurlyDoubleQuote;": "”",
+ "DoubleContourIntegral;": "∯",
+ "FilledVerySmallSquare;": "▪",
+ "NegativeVeryThinSpace;": "",
+ "NotPrecedesSlantEqual;": "⋠",
+ "NotRightTriangleEqual;": "⋭",
+ "NotSucceedsSlantEqual;": "⋡",
+ "DiacriticalDoubleAcute;": "˝",
+ "NotSquareSupersetEqual;": "⋣",
+ "NotNestedGreaterGreater;": "⪢̸",
+ "ClockwiseContourIntegral;": "∲",
+ "DoubleLongLeftRightArrow;": "⟺",
+ "CounterClockwiseContourIntegral;": "∳"
+};
+
+let maxCRNameLength;
+const decodeHtml = (rawText, asAttr) => {
+ let offset = 0;
+ const end = rawText.length;
+ let decodedText = "";
+ function advance(length) {
+ offset += length;
+ rawText = rawText.slice(length);
+ }
+ while (offset < end) {
+ const head = /&(?:#x?)?/i.exec(rawText);
+ if (!head || offset + head.index >= end) {
+ const remaining = end - offset;
+ decodedText += rawText.slice(0, remaining);
+ advance(remaining);
+ break;
+ }
+ decodedText += rawText.slice(0, head.index);
+ advance(head.index);
+ if (head[0] === "&") {
+ let name = "";
+ let value = void 0;
+ if (/[0-9a-z]/i.test(rawText[1])) {
+ if (!maxCRNameLength) {
+ maxCRNameLength = Object.keys(namedCharacterReferences).reduce(
+ (max, name2) => Math.max(max, name2.length),
+ 0
+ );
+ }
+ for (let length = maxCRNameLength; !value && length > 0; --length) {
+ name = rawText.slice(1, 1 + length);
+ value = namedCharacterReferences[name];
+ }
+ if (value) {
+ const semi = name.endsWith(";");
+ if (asAttr && !semi && /[=a-z0-9]/i.test(rawText[name.length + 1] || "")) {
+ decodedText += "&" + name;
+ advance(1 + name.length);
+ } else {
+ decodedText += value;
+ advance(1 + name.length);
+ }
+ } else {
+ decodedText += "&" + name;
+ advance(1 + name.length);
+ }
+ } else {
+ decodedText += "&";
+ advance(1);
+ }
+ } else {
+ const hex = head[0] === "&#x";
+ const pattern = hex ? /^&#x([0-9a-f]+);?/i : /^&#([0-9]+);?/;
+ const body = pattern.exec(rawText);
+ if (!body) {
+ decodedText += head[0];
+ advance(head[0].length);
+ } else {
+ let cp = Number.parseInt(body[1], hex ? 16 : 10);
+ if (cp === 0) {
+ cp = 65533;
+ } else if (cp > 1114111) {
+ cp = 65533;
+ } else if (cp >= 55296 && cp <= 57343) {
+ cp = 65533;
+ } else if (cp >= 64976 && cp <= 65007 || (cp & 65534) === 65534) ; else if (cp >= 1 && cp <= 8 || cp === 11 || cp >= 13 && cp <= 31 || cp >= 127 && cp <= 159) {
+ cp = CCR_REPLACEMENTS[cp] || cp;
+ }
+ decodedText += String.fromCodePoint(cp);
+ advance(body[0].length);
+ }
+ }
+ }
+ return decodedText;
+};
+const CCR_REPLACEMENTS = {
+ 128: 8364,
+ 130: 8218,
+ 131: 402,
+ 132: 8222,
+ 133: 8230,
+ 134: 8224,
+ 135: 8225,
+ 136: 710,
+ 137: 8240,
+ 138: 352,
+ 139: 8249,
+ 140: 338,
+ 142: 381,
+ 145: 8216,
+ 146: 8217,
+ 147: 8220,
+ 148: 8221,
+ 149: 8226,
+ 150: 8211,
+ 151: 8212,
+ 152: 732,
+ 153: 8482,
+ 154: 353,
+ 155: 8250,
+ 156: 339,
+ 158: 382,
+ 159: 376
+};
+
+const isRawTextContainer = /* @__PURE__ */ shared.makeMap(
+ "style,iframe,script,noscript",
+ true
+);
+const parserOptions = {
+ isVoidTag: shared.isVoidTag,
+ isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag),
+ isPreTag: (tag) => tag === "pre",
+ decodeEntities: decodeHtml,
+ isBuiltInComponent: (tag) => {
+ if (compilerCore.isBuiltInType(tag, `Transition`)) {
+ return TRANSITION;
+ } else if (compilerCore.isBuiltInType(tag, `TransitionGroup`)) {
+ return TRANSITION_GROUP;
+ }
+ },
+ // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+ getNamespace(tag, parent) {
+ let ns = parent ? parent.ns : 0;
+ if (parent && ns === 2) {
+ if (parent.tag === "annotation-xml") {
+ if (tag === "svg") {
+ return 1;
+ }
+ if (parent.props.some(
+ (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
+ )) {
+ ns = 0;
+ }
+ } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
+ ns = 0;
+ }
+ } else if (parent && ns === 1) {
+ if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
+ ns = 0;
+ }
+ }
+ if (ns === 0) {
+ if (tag === "svg") {
+ return 1;
+ }
+ if (tag === "math") {
+ return 2;
+ }
+ }
+ return ns;
+ },
+ // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
+ getTextMode({ tag, ns }) {
+ if (ns === 0) {
+ if (tag === "textarea" || tag === "title") {
+ return 1;
+ }
+ if (isRawTextContainer(tag)) {
+ return 2;
+ }
+ }
+ return 0;
+ }
+};
+
+const transformStyle = (node) => {
+ if (node.type === 1) {
+ node.props.forEach((p, i) => {
+ if (p.type === 6 && p.name === "style" && p.value) {
+ node.props[i] = {
+ type: 7,
+ name: `bind`,
+ arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
+ exp: parseInlineCSS(p.value.content, p.loc),
+ modifiers: [],
+ loc: p.loc
+ };
+ }
+ });
+ }
+};
+const parseInlineCSS = (cssText, loc) => {
+ const normalized = shared.parseStringStyle(cssText);
+ return compilerCore.createSimpleExpression(
+ JSON.stringify(normalized),
+ false,
+ loc,
+ 3
+ );
+};
+
+function createDOMCompilerError(code, loc) {
+ return compilerCore.createCompilerError(
+ code,
+ loc,
+ DOMErrorMessages
+ );
+}
+const DOMErrorMessages = {
+ [53]: `v-html is missing expression.`,
+ [54]: `v-html will override element children.`,
+ [55]: `v-text is missing expression.`,
+ [56]: `v-text will override element children.`,
+ [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+ [58]: `v-model argument is not supported on plain elements.`,
+ [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+ [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+ [61]: `v-show is missing expression.`,
+ [62]: `<Transition> expects exactly one child element or component.`,
+ [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+ const { exp, loc } = dir;
+ if (!exp) {
+ context.onError(
+ createDOMCompilerError(53, loc)
+ );
+ }
+ if (node.children.length) {
+ context.onError(
+ createDOMCompilerError(54, loc)
+ );
+ node.children.length = 0;
+ }
+ return {
+ props: [
+ compilerCore.createObjectProperty(
+ compilerCore.createSimpleExpression(`innerHTML`, true, loc),
+ exp || compilerCore.createSimpleExpression("", true)
+ )
+ ]
+ };
+};
+
+const transformVText = (dir, node, context) => {
+ const { exp, loc } = dir;
+ if (!exp) {
+ context.onError(
+ createDOMCompilerError(55, loc)
+ );
+ }
+ if (node.children.length) {
+ context.onError(
+ createDOMCompilerError(56, loc)
+ );
+ node.children.length = 0;
+ }
+ return {
+ props: [
+ compilerCore.createObjectProperty(
+ compilerCore.createSimpleExpression(`textContent`, true),
+ exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
+ context.helperString(compilerCore.TO_DISPLAY_STRING),
+ [exp],
+ loc
+ ) : compilerCore.createSimpleExpression("", true)
+ )
+ ]
+ };
+};
+
+const transformModel = (dir, node, context) => {
+ const baseResult = compilerCore.transformModel(dir, node, context);
+ if (!baseResult.props.length || node.tagType === 1) {
+ return baseResult;
+ }
+ if (dir.arg) {
+ context.onError(
+ createDOMCompilerError(
+ 58,
+ dir.arg.loc
+ )
+ );
+ }
+ function checkDuplicatedValue() {
+ const value = compilerCore.findDir(node, "bind");
+ if (value && compilerCore.isStaticArgOf(value.arg, "value")) {
+ context.onError(
+ createDOMCompilerError(
+ 60,
+ value.loc
+ )
+ );
+ }
+ }
+ const { tag } = node;
+ const isCustomElement = context.isCustomElement(tag);
+ if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+ let directiveToUse = V_MODEL_TEXT;
+ let isInvalidType = false;
+ if (tag === "input" || isCustomElement) {
+ const type = compilerCore.findProp(node, `type`);
+ if (type) {
+ if (type.type === 7) {
+ directiveToUse = V_MODEL_DYNAMIC;
+ } else if (type.value) {
+ switch (type.value.content) {
+ case "radio":
+ directiveToUse = V_MODEL_RADIO;
+ break;
+ case "checkbox":
+ directiveToUse = V_MODEL_CHECKBOX;
+ break;
+ case "file":
+ isInvalidType = true;
+ context.onError(
+ createDOMCompilerError(
+ 59,
+ dir.loc
+ )
+ );
+ break;
+ default:
+ checkDuplicatedValue();
+ break;
+ }
+ }
+ } else if (compilerCore.hasDynamicKeyVBind(node)) {
+ directiveToUse = V_MODEL_DYNAMIC;
+ } else {
+ checkDuplicatedValue();
+ }
+ } else if (tag === "select") {
+ directiveToUse = V_MODEL_SELECT;
+ } else {
+ checkDuplicatedValue();
+ }
+ if (!isInvalidType) {
+ baseResult.needRuntime = context.helper(directiveToUse);
+ }
+ } else {
+ context.onError(
+ createDOMCompilerError(
+ 57,
+ dir.loc
+ )
+ );
+ }
+ baseResult.props = baseResult.props.filter(
+ (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+ );
+ return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
+ // event propagation management
+ `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(
+ `onkeyup,onkeydown,onkeypress`,
+ true
+);
+const resolveModifiers = (key, modifiers, context, loc) => {
+ const keyModifiers = [];
+ const nonKeyModifiers = [];
+ const eventOptionModifiers = [];
+ for (let i = 0; i < modifiers.length; i++) {
+ const modifier = modifiers[i];
+ if (modifier === "native" && compilerCore.checkCompatEnabled(
+ "COMPILER_V_ON_NATIVE",
+ context,
+ loc
+ )) {
+ eventOptionModifiers.push(modifier);
+ } else if (isEventOptionModifier(modifier)) {
+ eventOptionModifiers.push(modifier);
+ } else {
+ if (maybeKeyModifier(modifier)) {
+ if (compilerCore.isStaticExp(key)) {
+ if (isKeyboardEvent(key.content)) {
+ keyModifiers.push(modifier);
+ } else {
+ nonKeyModifiers.push(modifier);
+ }
+ } else {
+ keyModifiers.push(modifier);
+ nonKeyModifiers.push(modifier);
+ }
+ } else {
+ if (isNonKeyModifier(modifier)) {
+ nonKeyModifiers.push(modifier);
+ } else {
+ keyModifiers.push(modifier);
+ }
+ }
+ }
+ }
+ return {
+ keyModifiers,
+ nonKeyModifiers,
+ eventOptionModifiers
+ };
+};
+const transformClick = (key, event) => {
+ const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
+ return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
+ `(`,
+ key,
+ `) === "onClick" ? "${event}" : (`,
+ key,
+ `)`
+ ]) : key;
+};
+const transformOn = (dir, node, context) => {
+ return compilerCore.transformOn(dir, node, context, (baseResult) => {
+ const { modifiers } = dir;
+ if (!modifiers.length)
+ return baseResult;
+ let { key, value: handlerExp } = baseResult.props[0];
+ const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+ if (nonKeyModifiers.includes("right")) {
+ key = transformClick(key, `onContextmenu`);
+ }
+ if (nonKeyModifiers.includes("middle")) {
+ key = transformClick(key, `onMouseup`);
+ }
+ if (nonKeyModifiers.length) {
+ handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+ handlerExp,
+ JSON.stringify(nonKeyModifiers)
+ ]);
+ }
+ if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+ (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content))) {
+ handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
+ handlerExp,
+ JSON.stringify(keyModifiers)
+ ]);
+ }
+ if (eventOptionModifiers.length) {
+ const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
+ key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+ }
+ return {
+ props: [compilerCore.createObjectProperty(key, handlerExp)]
+ };
+ });
+};
+
+const transformShow = (dir, node, context) => {
+ const { exp, loc } = dir;
+ if (!exp) {
+ context.onError(
+ createDOMCompilerError(61, loc)
+ );
+ }
+ return {
+ props: [],
+ needRuntime: context.helper(V_SHOW)
+ };
+};
+
+const transformTransition = (node, context) => {
+ if (node.type === 1 && node.tagType === 1) {
+ const component = context.isBuiltInComponent(node.tag);
+ if (component === TRANSITION) {
+ return () => {
+ if (!node.children.length) {
+ return;
+ }
+ if (hasMultipleChildren(node)) {
+ context.onError(
+ createDOMCompilerError(
+ 62,
+ {
+ start: node.children[0].loc.start,
+ end: node.children[node.children.length - 1].loc.end,
+ source: ""
+ }
+ )
+ );
+ }
+ const child = node.children[0];
+ if (child.type === 1) {
+ for (const p of child.props) {
+ if (p.type === 7 && p.name === "show") {
+ node.props.push({
+ type: 6,
+ name: "persisted",
+ value: void 0,
+ loc: node.loc
+ });
+ }
+ }
+ }
+ };
+ }
+ }
+};
+function hasMultipleChildren(node) {
+ const children = node.children = node.children.filter(
+ (c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
+ );
+ const child = children[0];
+ return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
+}
+
+const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
+const stringifyStatic = (children, context, parent) => {
+ if (context.scopes.vSlot > 0) {
+ return;
+ }
+ let nc = 0;
+ let ec = 0;
+ const currentChunk = [];
+ const stringifyCurrentChunk = (currentIndex) => {
+ if (nc >= 20 || ec >= 5) {
+ const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
+ JSON.stringify(
+ currentChunk.map((node) => stringifyNode(node, context)).join("")
+ ).replace(expReplaceRE, `" + $1 + "`),
+ // the 2nd argument indicates the number of DOM nodes this static vnode
+ // will insert / hydrate
+ String(currentChunk.length)
+ ]);
+ replaceHoist(currentChunk[0], staticCall, context);
+ if (currentChunk.length > 1) {
+ for (let i2 = 1; i2 < currentChunk.length; i2++) {
+ replaceHoist(currentChunk[i2], null, context);
+ }
+ const deleteCount = currentChunk.length - 1;
+ children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+ return deleteCount;
+ }
+ }
+ return 0;
+ };
+ let i = 0;
+ for (; i < children.length; i++) {
+ const child = children[i];
+ const hoisted = getHoistedNode(child);
+ if (hoisted) {
+ const node = child;
+ const result = analyzeNode(node);
+ if (result) {
+ nc += result[0];
+ ec += result[1];
+ currentChunk.push(node);
+ continue;
+ }
+ }
+ i -= stringifyCurrentChunk(i);
+ nc = 0;
+ ec = 0;
+ currentChunk.length = 0;
+ }
+ stringifyCurrentChunk(i);
+};
+const getHoistedNode = (node) => (node.type === 1 && node.tagType === 0 || node.type == 12) && node.codegenNode && node.codegenNode.type === 4 && node.codegenNode.hoisted;
+const dataAriaRE = /^(data|aria)-/;
+const isStringifiableAttr = (name, ns) => {
+ return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : false) || dataAriaRE.test(name);
+};
+const replaceHoist = (node, replacement, context) => {
+ const hoistToReplace = node.codegenNode.hoisted;
+ context.hoists[context.hoists.indexOf(hoistToReplace)] = replacement;
+};
+const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
+ `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
+);
+function analyzeNode(node) {
+ if (node.type === 1 && isNonStringifiable(node.tag)) {
+ return false;
+ }
+ if (node.type === 12) {
+ return [1, 0];
+ }
+ let nc = 1;
+ let ec = node.props.length > 0 ? 1 : 0;
+ let bailed = false;
+ const bail = () => {
+ bailed = true;
+ return false;
+ };
+ function walk(node2) {
+ for (let i = 0; i < node2.props.length; i++) {
+ const p = node2.props[i];
+ if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
+ return bail();
+ }
+ if (p.type === 7 && p.name === "bind") {
+ if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
+ return bail();
+ }
+ if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
+ return bail();
+ }
+ }
+ }
+ for (let i = 0; i < node2.children.length; i++) {
+ nc++;
+ const child = node2.children[i];
+ if (child.type === 1) {
+ if (child.props.length > 0) {
+ ec++;
+ }
+ walk(child);
+ if (bailed) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ return walk(node) ? [nc, ec] : false;
+}
+function stringifyNode(node, context) {
+ if (shared.isString(node)) {
+ return node;
+ }
+ if (shared.isSymbol(node)) {
+ return ``;
+ }
+ switch (node.type) {
+ case 1:
+ return stringifyElement(node, context);
+ case 2:
+ return shared.escapeHtml(node.content);
+ case 3:
+ return `<!--${shared.escapeHtml(node.content)}-->`;
+ case 5:
+ return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
+ case 8:
+ return shared.escapeHtml(evaluateConstant(node));
+ case 12:
+ return stringifyNode(node.content, context);
+ default:
+ return "";
+ }
+}
+function stringifyElement(node, context) {
+ let res = `<${node.tag}`;
+ let innerHTML = "";
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 6) {
+ res += ` ${p.name}`;
+ if (p.value) {
+ res += `="${shared.escapeHtml(p.value.content)}"`;
+ }
+ } else if (p.type === 7) {
+ if (p.name === "bind") {
+ const exp = p.exp;
+ if (exp.content[0] === "_") {
+ res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+ continue;
+ }
+ if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
+ continue;
+ }
+ let evaluated = evaluateConstant(exp);
+ if (evaluated != null) {
+ const arg = p.arg && p.arg.content;
+ if (arg === "class") {
+ evaluated = shared.normalizeClass(evaluated);
+ } else if (arg === "style") {
+ evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+ }
+ res += ` ${p.arg.content}="${shared.escapeHtml(
+ evaluated
+ )}"`;
+ }
+ } else if (p.name === "html") {
+ innerHTML = evaluateConstant(p.exp);
+ } else if (p.name === "text") {
+ innerHTML = shared.escapeHtml(
+ shared.toDisplayString(evaluateConstant(p.exp))
+ );
+ }
+ }
+ }
+ if (context.scopeId) {
+ res += ` ${context.scopeId}`;
+ }
+ res += `>`;
+ if (innerHTML) {
+ res += innerHTML;
+ } else {
+ for (let i = 0; i < node.children.length; i++) {
+ res += stringifyNode(node.children[i], context);
+ }
+ }
+ if (!shared.isVoidTag(node.tag)) {
+ res += `</${node.tag}>`;
+ }
+ return res;
+}
+function evaluateConstant(exp) {
+ if (exp.type === 4) {
+ return new Function(`return (${exp.content})`)();
+ } else {
+ let res = ``;
+ exp.children.forEach((c) => {
+ if (shared.isString(c) || shared.isSymbol(c)) {
+ return;
+ }
+ if (c.type === 2) {
+ res += c.content;
+ } else if (c.type === 5) {
+ res += shared.toDisplayString(evaluateConstant(c.content));
+ } else {
+ res += evaluateConstant(c);
+ }
+ });
+ return res;
+ }
+}
+
+const ignoreSideEffectTags = (node, context) => {
+ if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+ context.onError(
+ createDOMCompilerError(
+ 63,
+ node.loc
+ )
+ );
+ context.removeNode();
+ }
+};
+
+const DOMNodeTransforms = [
+ transformStyle,
+ ...[transformTransition]
+];
+const DOMDirectiveTransforms = {
+ cloak: compilerCore.noopDirectiveTransform,
+ html: transformVHtml,
+ text: transformVText,
+ model: transformModel,
+ // override compiler-core
+ on: transformOn,
+ // override compiler-core
+ show: transformShow
+};
+function compile(template, options = {}) {
+ return compilerCore.baseCompile(
+ template,
+ shared.extend({}, parserOptions, options, {
+ nodeTransforms: [
+ // ignore <script> and <tag>
+ // this is not put inside DOMNodeTransforms because that list is used
+ // by compiler-ssr to generate vnode fallback branches
+ ignoreSideEffectTags,
+ ...DOMNodeTransforms,
+ ...options.nodeTransforms || []
+ ],
+ directiveTransforms: shared.extend(
+ {},
+ DOMDirectiveTransforms,
+ options.directiveTransforms || {}
+ ),
+ transformHoist: stringifyStatic
+ })
+ );
+}
+function parse(template, options = {}) {
+ return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
+}
+
+exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
+exports.DOMNodeTransforms = DOMNodeTransforms;
+exports.TRANSITION = TRANSITION;
+exports.TRANSITION_GROUP = TRANSITION_GROUP;
+exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
+exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
+exports.V_MODEL_RADIO = V_MODEL_RADIO;
+exports.V_MODEL_SELECT = V_MODEL_SELECT;
+exports.V_MODEL_TEXT = V_MODEL_TEXT;
+exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
+exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
+exports.V_SHOW = V_SHOW;
+exports.compile = compile;
+exports.createDOMCompilerError = createDOMCompilerError;
+exports.parse = parse;
+exports.parserOptions = parserOptions;
+exports.transformStyle = transformStyle;
+Object.keys(compilerCore).forEach(function (k) {
+ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
+});
diff --git a/.output/server/node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.prod.js b/.output/server/node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.prod.js
new file mode 100644
index 0000000..967cf26
--- /dev/null
+++ b/.output/server/node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.prod.js
@@ -0,0 +1,2978 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerCore = require('@vue/compiler-core');
+var shared = require('@vue/shared');
+
+const V_MODEL_RADIO = Symbol(``);
+const V_MODEL_CHECKBOX = Symbol(``);
+const V_MODEL_TEXT = Symbol(``);
+const V_MODEL_SELECT = Symbol(``);
+const V_MODEL_DYNAMIC = Symbol(``);
+const V_ON_WITH_MODIFIERS = Symbol(``);
+const V_ON_WITH_KEYS = Symbol(``);
+const V_SHOW = Symbol(``);
+const TRANSITION = Symbol(``);
+const TRANSITION_GROUP = Symbol(``);
+compilerCore.registerRuntimeHelpers({
+ [V_MODEL_RADIO]: `vModelRadio`,
+ [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+ [V_MODEL_TEXT]: `vModelText`,
+ [V_MODEL_SELECT]: `vModelSelect`,
+ [V_MODEL_DYNAMIC]: `vModelDynamic`,
+ [V_ON_WITH_MODIFIERS]: `withModifiers`,
+ [V_ON_WITH_KEYS]: `withKeys`,
+ [V_SHOW]: `vShow`,
+ [TRANSITION]: `Transition`,
+ [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+var namedCharacterReferences = {
+ GT: ">",
+ gt: ">",
+ LT: "<",
+ lt: "<",
+ "ac;": "∾",
+ "af;": "",
+ AMP: "&",
+ amp: "&",
+ "ap;": "≈",
+ "DD;": "ⅅ",
+ "dd;": "ⅆ",
+ deg: "°",
+ "ee;": "ⅇ",
+ "eg;": "⪚",
+ "el;": "⪙",
+ ETH: "Ð",
+ eth: "ð",
+ "gE;": "≧",
+ "ge;": "≥",
+ "Gg;": "⋙",
+ "gg;": "≫",
+ "gl;": "≷",
+ "GT;": ">",
+ "Gt;": "≫",
+ "gt;": ">",
+ "ic;": "",
+ "ii;": "ⅈ",
+ "Im;": "ℑ",
+ "in;": "∈",
+ "it;": "",
+ "lE;": "≦",
+ "le;": "≤",
+ "lg;": "≶",
+ "Ll;": "⋘",
+ "ll;": "≪",
+ "LT;": "<",
+ "Lt;": "≪",
+ "lt;": "<",
+ "mp;": "∓",
+ "Mu;": "Μ",
+ "mu;": "μ",
+ "ne;": "≠",
+ "ni;": "∋",
+ not: "¬",
+ "Nu;": "Ν",
+ "nu;": "ν",
+ "Or;": "⩔",
+ "or;": "∨",
+ "oS;": "Ⓢ",
+ "Pi;": "Π",
+ "pi;": "π",
+ "pm;": "±",
+ "Pr;": "⪻",
+ "pr;": "≺",
+ "Re;": "ℜ",
+ REG: "®",
+ reg: "®",
+ "rx;": "℞",
+ "Sc;": "⪼",
+ "sc;": "≻",
+ shy: "",
+ uml: "¨",
+ "wp;": "℘",
+ "wr;": "≀",
+ "Xi;": "Ξ",
+ "xi;": "ξ",
+ yen: "¥",
+ "acd;": "∿",
+ "acE;": "∾̳",
+ "Acy;": "А",
+ "acy;": "а",
+ "Afr;": "𝔄",
+ "afr;": "𝔞",
+ "AMP;": "&",
+ "amp;": "&",
+ "And;": "⩓",
+ "and;": "∧",
+ "ang;": "∠",
+ "apE;": "⩰",
+ "ape;": "≊",
+ "ast;": "*",
+ Auml: "Ä",
+ auml: "ä",
+ "Bcy;": "Б",
+ "bcy;": "б",
+ "Bfr;": "𝔅",
+ "bfr;": "𝔟",
+ "bne;": "=⃥",
+ "bot;": "⊥",
+ "Cap;": "⋒",
+ "cap;": "∩",
+ cent: "¢",
+ "Cfr;": "ℭ",
+ "cfr;": "𝔠",
+ "Chi;": "Χ",
+ "chi;": "χ",
+ "cir;": "○",
+ COPY: "©",
+ copy: "©",
+ "Cup;": "⋓",
+ "cup;": "∪",
+ "Dcy;": "Д",
+ "dcy;": "д",
+ "deg;": "°",
+ "Del;": "∇",
+ "Dfr;": "𝔇",
+ "dfr;": "𝔡",
+ "die;": "¨",
+ "div;": "÷",
+ "Dot;": "¨",
+ "dot;": "˙",
+ "Ecy;": "Э",
+ "ecy;": "э",
+ "Efr;": "𝔈",
+ "efr;": "𝔢",
+ "egs;": "⪖",
+ "ell;": "ℓ",
+ "els;": "⪕",
+ "ENG;": "Ŋ",
+ "eng;": "ŋ",
+ "Eta;": "Η",
+ "eta;": "η",
+ "ETH;": "Ð",
+ "eth;": "ð",
+ Euml: "Ë",
+ euml: "ë",
+ "Fcy;": "Ф",
+ "fcy;": "ф",
+ "Ffr;": "𝔉",
+ "ffr;": "𝔣",
+ "gap;": "⪆",
+ "Gcy;": "Г",
+ "gcy;": "г",
+ "gEl;": "⪌",
+ "gel;": "⋛",
+ "geq;": "≥",
+ "ges;": "⩾",
+ "Gfr;": "𝔊",
+ "gfr;": "𝔤",
+ "ggg;": "⋙",
+ "gla;": "⪥",
+ "glE;": "⪒",
+ "glj;": "⪤",
+ "gnE;": "≩",
+ "gne;": "⪈",
+ "Hat;": "^",
+ "Hfr;": "ℌ",
+ "hfr;": "𝔥",
+ "Icy;": "И",
+ "icy;": "и",
+ "iff;": "⇔",
+ "Ifr;": "ℑ",
+ "ifr;": "𝔦",
+ "Int;": "∬",
+ "int;": "∫",
+ Iuml: "Ï",
+ iuml: "ï",
+ "Jcy;": "Й",
+ "jcy;": "й",
+ "Jfr;": "𝔍",
+ "jfr;": "𝔧",
+ "Kcy;": "К",
+ "kcy;": "к",
+ "Kfr;": "𝔎",
+ "kfr;": "𝔨",
+ "lap;": "⪅",
+ "lat;": "⪫",
+ "Lcy;": "Л",
+ "lcy;": "л",
+ "lEg;": "⪋",
+ "leg;": "⋚",
+ "leq;": "≤",
+ "les;": "⩽",
+ "Lfr;": "𝔏",
+ "lfr;": "𝔩",
+ "lgE;": "⪑",
+ "lnE;": "≨",
+ "lne;": "⪇",
+ "loz;": "◊",
+ "lrm;": "",
+ "Lsh;": "↰",
+ "lsh;": "↰",
+ macr: "¯",
+ "Map;": "⤅",
+ "map;": "↦",
+ "Mcy;": "М",
+ "mcy;": "м",
+ "Mfr;": "𝔐",
+ "mfr;": "𝔪",
+ "mho;": "℧",
+ "mid;": "∣",
+ "nap;": "≉",
+ nbsp: " ",
+ "Ncy;": "Н",
+ "ncy;": "н",
+ "Nfr;": "𝔑",
+ "nfr;": "𝔫",
+ "ngE;": "≧̸",
+ "nge;": "≱",
+ "nGg;": "⋙̸",
+ "nGt;": "≫⃒",
+ "ngt;": "≯",
+ "nis;": "⋼",
+ "niv;": "∋",
+ "nlE;": "≦̸",
+ "nle;": "≰",
+ "nLl;": "⋘̸",
+ "nLt;": "≪⃒",
+ "nlt;": "≮",
+ "Not;": "⫬",
+ "not;": "¬",
+ "npr;": "⊀",
+ "nsc;": "⊁",
+ "num;": "#",
+ "Ocy;": "О",
+ "ocy;": "о",
+ "Ofr;": "𝔒",
+ "ofr;": "𝔬",
+ "ogt;": "⧁",
+ "ohm;": "Ω",
+ "olt;": "⧀",
+ "ord;": "⩝",
+ ordf: "ª",
+ ordm: "º",
+ "orv;": "⩛",
+ Ouml: "Ö",
+ ouml: "ö",
+ "par;": "∥",
+ para: "¶",
+ "Pcy;": "П",
+ "pcy;": "п",
+ "Pfr;": "𝔓",
+ "pfr;": "𝔭",
+ "Phi;": "Φ",
+ "phi;": "φ",
+ "piv;": "ϖ",
+ "prE;": "⪳",
+ "pre;": "⪯",
+ "Psi;": "Ψ",
+ "psi;": "ψ",
+ "Qfr;": "𝔔",
+ "qfr;": "𝔮",
+ QUOT: "\"",
+ quot: "\"",
+ "Rcy;": "Р",
+ "rcy;": "р",
+ "REG;": "®",
+ "reg;": "®",
+ "Rfr;": "ℜ",
+ "rfr;": "𝔯",
+ "Rho;": "Ρ",
+ "rho;": "ρ",
+ "rlm;": "",
+ "Rsh;": "↱",
+ "rsh;": "↱",
+ "scE;": "⪴",
+ "sce;": "⪰",
+ "Scy;": "С",
+ "scy;": "с",
+ sect: "§",
+ "Sfr;": "𝔖",
+ "sfr;": "𝔰",
+ "shy;": "",
+ "sim;": "∼",
+ "smt;": "⪪",
+ "sol;": "/",
+ "squ;": "□",
+ "Sub;": "⋐",
+ "sub;": "⊂",
+ "Sum;": "∑",
+ "sum;": "∑",
+ "Sup;": "⋑",
+ "sup;": "⊃",
+ sup1: "¹",
+ sup2: "²",
+ sup3: "³",
+ "Tab;": "\t",
+ "Tau;": "Τ",
+ "tau;": "τ",
+ "Tcy;": "Т",
+ "tcy;": "т",
+ "Tfr;": "𝔗",
+ "tfr;": "𝔱",
+ "top;": "⊤",
+ "Ucy;": "У",
+ "ucy;": "у",
+ "Ufr;": "𝔘",
+ "ufr;": "𝔲",
+ "uml;": "¨",
+ Uuml: "Ü",
+ uuml: "ü",
+ "Vcy;": "В",
+ "vcy;": "в",
+ "Vee;": "⋁",
+ "vee;": "∨",
+ "Vfr;": "𝔙",
+ "vfr;": "𝔳",
+ "Wfr;": "𝔚",
+ "wfr;": "𝔴",
+ "Xfr;": "𝔛",
+ "xfr;": "𝔵",
+ "Ycy;": "Ы",
+ "ycy;": "ы",
+ "yen;": "¥",
+ "Yfr;": "𝔜",
+ "yfr;": "𝔶",
+ yuml: "ÿ",
+ "Zcy;": "З",
+ "zcy;": "з",
+ "Zfr;": "ℨ",
+ "zfr;": "𝔷",
+ "zwj;": "",
+ Acirc: "Â",
+ acirc: "â",
+ acute: "´",
+ AElig: "Æ",
+ aelig: "æ",
+ "andd;": "⩜",
+ "andv;": "⩚",
+ "ange;": "⦤",
+ "Aopf;": "𝔸",
+ "aopf;": "𝕒",
+ "apid;": "≋",
+ "apos;": "'",
+ Aring: "Å",
+ aring: "å",
+ "Ascr;": "𝒜",
+ "ascr;": "𝒶",
+ "Auml;": "Ä",
+ "auml;": "ä",
+ "Barv;": "⫧",
+ "bbrk;": "⎵",
+ "Beta;": "Β",
+ "beta;": "β",
+ "beth;": "ℶ",
+ "bNot;": "⫭",
+ "bnot;": "⌐",
+ "Bopf;": "𝔹",
+ "bopf;": "𝕓",
+ "boxH;": "═",
+ "boxh;": "─",
+ "boxV;": "║",
+ "boxv;": "│",
+ "Bscr;": "ℬ",
+ "bscr;": "𝒷",
+ "bsim;": "∽",
+ "bsol;": "\\",
+ "bull;": "•",
+ "bump;": "≎",
+ "caps;": "∩︀",
+ "Cdot;": "Ċ",
+ "cdot;": "ċ",
+ cedil: "¸",
+ "cent;": "¢",
+ "CHcy;": "Ч",
+ "chcy;": "ч",
+ "circ;": "ˆ",
+ "cirE;": "⧃",
+ "cire;": "≗",
+ "comp;": "∁",
+ "cong;": "≅",
+ "Copf;": "ℂ",
+ "copf;": "𝕔",
+ "COPY;": "©",
+ "copy;": "©",
+ "Cscr;": "𝒞",
+ "cscr;": "𝒸",
+ "csub;": "⫏",
+ "csup;": "⫐",
+ "cups;": "∪︀",
+ "Darr;": "↡",
+ "dArr;": "⇓",
+ "darr;": "↓",
+ "dash;": "‐",
+ "dHar;": "⥥",
+ "diam;": "⋄",
+ "DJcy;": "Ђ",
+ "djcy;": "ђ",
+ "Dopf;": "𝔻",
+ "dopf;": "𝕕",
+ "Dscr;": "𝒟",
+ "dscr;": "𝒹",
+ "DScy;": "Ѕ",
+ "dscy;": "ѕ",
+ "dsol;": "⧶",
+ "dtri;": "▿",
+ "DZcy;": "Џ",
+ "dzcy;": "џ",
+ "ecir;": "≖",
+ Ecirc: "Ê",
+ ecirc: "ê",
+ "Edot;": "Ė",
+ "eDot;": "≑",
+ "edot;": "ė",
+ "emsp;": " ",
+ "ensp;": " ",
+ "Eopf;": "𝔼",
+ "eopf;": "𝕖",
+ "epar;": "⋕",
+ "epsi;": "ε",
+ "Escr;": "ℰ",
+ "escr;": "ℯ",
+ "Esim;": "⩳",
+ "esim;": "≂",
+ "Euml;": "Ë",
+ "euml;": "ë",
+ "euro;": "€",
+ "excl;": "!",
+ "flat;": "♭",
+ "fnof;": "ƒ",
+ "Fopf;": "𝔽",
+ "fopf;": "𝕗",
+ "fork;": "⋔",
+ "Fscr;": "ℱ",
+ "fscr;": "𝒻",
+ "Gdot;": "Ġ",
+ "gdot;": "ġ",
+ "geqq;": "≧",
+ "gesl;": "⋛︀",
+ "GJcy;": "Ѓ",
+ "gjcy;": "ѓ",
+ "gnap;": "⪊",
+ "gneq;": "⪈",
+ "Gopf;": "𝔾",
+ "gopf;": "𝕘",
+ "Gscr;": "𝒢",
+ "gscr;": "ℊ",
+ "gsim;": "≳",
+ "gtcc;": "⪧",
+ "gvnE;": "≩︀",
+ "half;": "½",
+ "hArr;": "⇔",
+ "harr;": "↔",
+ "hbar;": "ℏ",
+ "Hopf;": "ℍ",
+ "hopf;": "𝕙",
+ "Hscr;": "ℋ",
+ "hscr;": "𝒽",
+ Icirc: "Î",
+ icirc: "î",
+ "Idot;": "İ",
+ "IEcy;": "Е",
+ "iecy;": "е",
+ iexcl: "¡",
+ "imof;": "⊷",
+ "IOcy;": "Ё",
+ "iocy;": "ё",
+ "Iopf;": "𝕀",
+ "iopf;": "𝕚",
+ "Iota;": "Ι",
+ "iota;": "ι",
+ "Iscr;": "ℐ",
+ "iscr;": "𝒾",
+ "isin;": "∈",
+ "Iuml;": "Ï",
+ "iuml;": "ï",
+ "Jopf;": "𝕁",
+ "jopf;": "𝕛",
+ "Jscr;": "𝒥",
+ "jscr;": "𝒿",
+ "KHcy;": "Х",
+ "khcy;": "х",
+ "KJcy;": "Ќ",
+ "kjcy;": "ќ",
+ "Kopf;": "𝕂",
+ "kopf;": "𝕜",
+ "Kscr;": "𝒦",
+ "kscr;": "𝓀",
+ "Lang;": "⟪",
+ "lang;": "⟨",
+ laquo: "«",
+ "Larr;": "↞",
+ "lArr;": "⇐",
+ "larr;": "←",
+ "late;": "⪭",
+ "lcub;": "{",
+ "ldca;": "⤶",
+ "ldsh;": "↲",
+ "leqq;": "≦",
+ "lesg;": "⋚︀",
+ "lHar;": "⥢",
+ "LJcy;": "Љ",
+ "ljcy;": "љ",
+ "lnap;": "⪉",
+ "lneq;": "⪇",
+ "Lopf;": "𝕃",
+ "lopf;": "𝕝",
+ "lozf;": "⧫",
+ "lpar;": "(",
+ "Lscr;": "ℒ",
+ "lscr;": "𝓁",
+ "lsim;": "≲",
+ "lsqb;": "[",
+ "ltcc;": "⪦",
+ "ltri;": "◃",
+ "lvnE;": "≨︀",
+ "macr;": "¯",
+ "male;": "♂",
+ "malt;": "✠",
+ micro: "µ",
+ "mlcp;": "⫛",
+ "mldr;": "…",
+ "Mopf;": "𝕄",
+ "mopf;": "𝕞",
+ "Mscr;": "ℳ",
+ "mscr;": "𝓂",
+ "nang;": "∠⃒",
+ "napE;": "⩰̸",
+ "nbsp;": " ",
+ "ncap;": "⩃",
+ "ncup;": "⩂",
+ "ngeq;": "≱",
+ "nges;": "⩾̸",
+ "ngtr;": "≯",
+ "nGtv;": "≫̸",
+ "nisd;": "⋺",
+ "NJcy;": "Њ",
+ "njcy;": "њ",
+ "nldr;": "‥",
+ "nleq;": "≰",
+ "nles;": "⩽̸",
+ "nLtv;": "≪̸",
+ "nmid;": "∤",
+ "Nopf;": "ℕ",
+ "nopf;": "𝕟",
+ "npar;": "∦",
+ "npre;": "⪯̸",
+ "nsce;": "⪰̸",
+ "Nscr;": "𝒩",
+ "nscr;": "𝓃",
+ "nsim;": "≁",
+ "nsub;": "⊄",
+ "nsup;": "⊅",
+ "ntgl;": "≹",
+ "ntlg;": "≸",
+ "nvap;": "≍⃒",
+ "nvge;": "≥⃒",
+ "nvgt;": ">⃒",
+ "nvle;": "≤⃒",
+ "nvlt;": "<⃒",
+ "oast;": "⊛",
+ "ocir;": "⊚",
+ Ocirc: "Ô",
+ ocirc: "ô",
+ "odiv;": "⨸",
+ "odot;": "⊙",
+ "ogon;": "˛",
+ "oint;": "∮",
+ "omid;": "⦶",
+ "Oopf;": "𝕆",
+ "oopf;": "𝕠",
+ "opar;": "⦷",
+ "ordf;": "ª",
+ "ordm;": "º",
+ "oror;": "⩖",
+ "Oscr;": "𝒪",
+ "oscr;": "ℴ",
+ "osol;": "⊘",
+ "Ouml;": "Ö",
+ "ouml;": "ö",
+ "para;": "¶",
+ "part;": "∂",
+ "perp;": "⊥",
+ "phiv;": "ϕ",
+ "plus;": "+",
+ "Popf;": "ℙ",
+ "popf;": "𝕡",
+ pound: "£",
+ "prap;": "⪷",
+ "prec;": "≺",
+ "prnE;": "⪵",
+ "prod;": "∏",
+ "prop;": "∝",
+ "Pscr;": "𝒫",
+ "pscr;": "𝓅",
+ "qint;": "⨌",
+ "Qopf;": "ℚ",
+ "qopf;": "𝕢",
+ "Qscr;": "𝒬",
+ "qscr;": "𝓆",
+ "QUOT;": "\"",
+ "quot;": "\"",
+ "race;": "∽̱",
+ "Rang;": "⟫",
+ "rang;": "⟩",
+ raquo: "»",
+ "Rarr;": "↠",
+ "rArr;": "⇒",
+ "rarr;": "→",
+ "rcub;": "}",
+ "rdca;": "⤷",
+ "rdsh;": "↳",
+ "real;": "ℜ",
+ "rect;": "▭",
+ "rHar;": "⥤",
+ "rhov;": "ϱ",
+ "ring;": "˚",
+ "Ropf;": "ℝ",
+ "ropf;": "𝕣",
+ "rpar;": ")",
+ "Rscr;": "ℛ",
+ "rscr;": "𝓇",
+ "rsqb;": "]",
+ "rtri;": "▹",
+ "scap;": "⪸",
+ "scnE;": "⪶",
+ "sdot;": "⋅",
+ "sect;": "§",
+ "semi;": ";",
+ "sext;": "✶",
+ "SHcy;": "Ш",
+ "shcy;": "ш",
+ "sime;": "≃",
+ "simg;": "⪞",
+ "siml;": "⪝",
+ "smid;": "∣",
+ "smte;": "⪬",
+ "solb;": "⧄",
+ "Sopf;": "𝕊",
+ "sopf;": "𝕤",
+ "spar;": "∥",
+ "Sqrt;": "√",
+ "squf;": "▪",
+ "Sscr;": "𝒮",
+ "sscr;": "𝓈",
+ "Star;": "⋆",
+ "star;": "☆",
+ "subE;": "⫅",
+ "sube;": "⊆",
+ "succ;": "≻",
+ "sung;": "♪",
+ "sup1;": "¹",
+ "sup2;": "²",
+ "sup3;": "³",
+ "supE;": "⫆",
+ "supe;": "⊇",
+ szlig: "ß",
+ "tbrk;": "⎴",
+ "tdot;": "⃛",
+ THORN: "Þ",
+ thorn: "þ",
+ times: "×",
+ "tint;": "∭",
+ "toea;": "⤨",
+ "Topf;": "𝕋",
+ "topf;": "𝕥",
+ "tosa;": "⤩",
+ "trie;": "≜",
+ "Tscr;": "𝒯",
+ "tscr;": "𝓉",
+ "TScy;": "Ц",
+ "tscy;": "ц",
+ "Uarr;": "↟",
+ "uArr;": "⇑",
+ "uarr;": "↑",
+ Ucirc: "Û",
+ ucirc: "û",
+ "uHar;": "⥣",
+ "Uopf;": "𝕌",
+ "uopf;": "𝕦",
+ "Upsi;": "ϒ",
+ "upsi;": "υ",
+ "Uscr;": "𝒰",
+ "uscr;": "𝓊",
+ "utri;": "▵",
+ "Uuml;": "Ü",
+ "uuml;": "ü",
+ "vArr;": "⇕",
+ "varr;": "↕",
+ "Vbar;": "⫫",
+ "vBar;": "⫨",
+ "Vert;": "‖",
+ "vert;": "|",
+ "Vopf;": "𝕍",
+ "vopf;": "𝕧",
+ "Vscr;": "𝒱",
+ "vscr;": "𝓋",
+ "Wopf;": "𝕎",
+ "wopf;": "𝕨",
+ "Wscr;": "𝒲",
+ "wscr;": "𝓌",
+ "xcap;": "⋂",
+ "xcup;": "⋃",
+ "xmap;": "⟼",
+ "xnis;": "⋻",
+ "Xopf;": "𝕏",
+ "xopf;": "𝕩",
+ "Xscr;": "𝒳",
+ "xscr;": "𝓍",
+ "xvee;": "⋁",
+ "YAcy;": "Я",
+ "yacy;": "я",
+ "YIcy;": "Ї",
+ "yicy;": "ї",
+ "Yopf;": "𝕐",
+ "yopf;": "𝕪",
+ "Yscr;": "𝒴",
+ "yscr;": "𝓎",
+ "YUcy;": "Ю",
+ "yucy;": "ю",
+ "Yuml;": "Ÿ",
+ "yuml;": "ÿ",
+ "Zdot;": "Ż",
+ "zdot;": "ż",
+ "Zeta;": "Ζ",
+ "zeta;": "ζ",
+ "ZHcy;": "Ж",
+ "zhcy;": "ж",
+ "Zopf;": "ℤ",
+ "zopf;": "𝕫",
+ "Zscr;": "𝒵",
+ "zscr;": "𝓏",
+ "zwnj;": "",
+ Aacute: "Á",
+ aacute: "á",
+ "Acirc;": "Â",
+ "acirc;": "â",
+ "acute;": "´",
+ "AElig;": "Æ",
+ "aelig;": "æ",
+ Agrave: "À",
+ agrave: "à",
+ "aleph;": "ℵ",
+ "Alpha;": "Α",
+ "alpha;": "α",
+ "Amacr;": "Ā",
+ "amacr;": "ā",
+ "amalg;": "⨿",
+ "angle;": "∠",
+ "angrt;": "∟",
+ "angst;": "Å",
+ "Aogon;": "Ą",
+ "aogon;": "ą",
+ "Aring;": "Å",
+ "aring;": "å",
+ "asymp;": "≈",
+ Atilde: "Ã",
+ atilde: "ã",
+ "awint;": "⨑",
+ "bcong;": "≌",
+ "bdquo;": "„",
+ "bepsi;": "϶",
+ "blank;": "␣",
+ "blk12;": "▒",
+ "blk14;": "░",
+ "blk34;": "▓",
+ "block;": "█",
+ "boxDL;": "╗",
+ "boxDl;": "╖",
+ "boxdL;": "╕",
+ "boxdl;": "┐",
+ "boxDR;": "╔",
+ "boxDr;": "╓",
+ "boxdR;": "╒",
+ "boxdr;": "┌",
+ "boxHD;": "╦",
+ "boxHd;": "╤",
+ "boxhD;": "╥",
+ "boxhd;": "┬",
+ "boxHU;": "╩",
+ "boxHu;": "╧",
+ "boxhU;": "╨",
+ "boxhu;": "┴",
+ "boxUL;": "╝",
+ "boxUl;": "╜",
+ "boxuL;": "╛",
+ "boxul;": "┘",
+ "boxUR;": "╚",
+ "boxUr;": "╙",
+ "boxuR;": "╘",
+ "boxur;": "└",
+ "boxVH;": "╬",
+ "boxVh;": "╫",
+ "boxvH;": "╪",
+ "boxvh;": "┼",
+ "boxVL;": "╣",
+ "boxVl;": "╢",
+ "boxvL;": "╡",
+ "boxvl;": "┤",
+ "boxVR;": "╠",
+ "boxVr;": "╟",
+ "boxvR;": "╞",
+ "boxvr;": "├",
+ "Breve;": "˘",
+ "breve;": "˘",
+ brvbar: "¦",
+ "bsemi;": "⁏",
+ "bsime;": "⋍",
+ "bsolb;": "⧅",
+ "bumpE;": "⪮",
+ "bumpe;": "≏",
+ "caret;": "⁁",
+ "caron;": "ˇ",
+ "ccaps;": "⩍",
+ Ccedil: "Ç",
+ ccedil: "ç",
+ "Ccirc;": "Ĉ",
+ "ccirc;": "ĉ",
+ "ccups;": "⩌",
+ "cedil;": "¸",
+ "check;": "✓",
+ "clubs;": "♣",
+ "Colon;": "∷",
+ "colon;": ":",
+ "comma;": ",",
+ "crarr;": "↵",
+ "Cross;": "⨯",
+ "cross;": "✗",
+ "csube;": "⫑",
+ "csupe;": "⫒",
+ "ctdot;": "⋯",
+ "cuepr;": "⋞",
+ "cuesc;": "⋟",
+ "cupor;": "⩅",
+ curren: "¤",
+ "cuvee;": "⋎",
+ "cuwed;": "⋏",
+ "cwint;": "∱",
+ "Dashv;": "⫤",
+ "dashv;": "⊣",
+ "dblac;": "˝",
+ "ddarr;": "⇊",
+ "Delta;": "Δ",
+ "delta;": "δ",
+ "dharl;": "⇃",
+ "dharr;": "⇂",
+ "diams;": "♦",
+ "disin;": "⋲",
+ divide: "÷",
+ "doteq;": "≐",
+ "dtdot;": "⋱",
+ "dtrif;": "▾",
+ "duarr;": "⇵",
+ "duhar;": "⥯",
+ Eacute: "É",
+ eacute: "é",
+ "Ecirc;": "Ê",
+ "ecirc;": "ê",
+ "eDDot;": "⩷",
+ "efDot;": "≒",
+ Egrave: "È",
+ egrave: "è",
+ "Emacr;": "Ē",
+ "emacr;": "ē",
+ "empty;": "∅",
+ "Eogon;": "Ę",
+ "eogon;": "ę",
+ "eplus;": "⩱",
+ "epsiv;": "ϵ",
+ "eqsim;": "≂",
+ "Equal;": "⩵",
+ "equiv;": "≡",
+ "erarr;": "⥱",
+ "erDot;": "≓",
+ "esdot;": "≐",
+ "exist;": "∃",
+ "fflig;": "ff",
+ "filig;": "fi",
+ "fjlig;": "fj",
+ "fllig;": "fl",
+ "fltns;": "▱",
+ "forkv;": "⫙",
+ frac12: "½",
+ frac14: "¼",
+ frac34: "¾",
+ "frasl;": "⁄",
+ "frown;": "⌢",
+ "Gamma;": "Γ",
+ "gamma;": "γ",
+ "Gcirc;": "Ĝ",
+ "gcirc;": "ĝ",
+ "gescc;": "⪩",
+ "gimel;": "ℷ",
+ "gneqq;": "≩",
+ "gnsim;": "⋧",
+ "grave;": "`",
+ "gsime;": "⪎",
+ "gsiml;": "⪐",
+ "gtcir;": "⩺",
+ "gtdot;": "⋗",
+ "Hacek;": "ˇ",
+ "harrw;": "↭",
+ "Hcirc;": "Ĥ",
+ "hcirc;": "ĥ",
+ "hoarr;": "⇿",
+ Iacute: "Í",
+ iacute: "í",
+ "Icirc;": "Î",
+ "icirc;": "î",
+ "iexcl;": "¡",
+ Igrave: "Ì",
+ igrave: "ì",
+ "iiint;": "∭",
+ "iiota;": "℩",
+ "IJlig;": "IJ",
+ "ijlig;": "ij",
+ "Imacr;": "Ī",
+ "imacr;": "ī",
+ "image;": "ℑ",
+ "imath;": "ı",
+ "imped;": "Ƶ",
+ "infin;": "∞",
+ "Iogon;": "Į",
+ "iogon;": "į",
+ "iprod;": "⨼",
+ iquest: "¿",
+ "isinE;": "⋹",
+ "isins;": "⋴",
+ "isinv;": "∈",
+ "Iukcy;": "І",
+ "iukcy;": "і",
+ "Jcirc;": "Ĵ",
+ "jcirc;": "ĵ",
+ "jmath;": "ȷ",
+ "Jukcy;": "Є",
+ "jukcy;": "є",
+ "Kappa;": "Κ",
+ "kappa;": "κ",
+ "lAarr;": "⇚",
+ "langd;": "⦑",
+ "laquo;": "«",
+ "larrb;": "⇤",
+ "lates;": "⪭︀",
+ "lBarr;": "⤎",
+ "lbarr;": "⤌",
+ "lbbrk;": "❲",
+ "lbrke;": "⦋",
+ "lceil;": "⌈",
+ "ldquo;": "“",
+ "lescc;": "⪨",
+ "lhard;": "↽",
+ "lharu;": "↼",
+ "lhblk;": "▄",
+ "llarr;": "⇇",
+ "lltri;": "◺",
+ "lneqq;": "≨",
+ "lnsim;": "⋦",
+ "loang;": "⟬",
+ "loarr;": "⇽",
+ "lobrk;": "⟦",
+ "lopar;": "⦅",
+ "lrarr;": "⇆",
+ "lrhar;": "⇋",
+ "lrtri;": "⊿",
+ "lsime;": "⪍",
+ "lsimg;": "⪏",
+ "lsquo;": "‘",
+ "ltcir;": "⩹",
+ "ltdot;": "⋖",
+ "ltrie;": "⊴",
+ "ltrif;": "◂",
+ "mdash;": "—",
+ "mDDot;": "∺",
+ "micro;": "µ",
+ middot: "·",
+ "minus;": "−",
+ "mumap;": "⊸",
+ "nabla;": "∇",
+ "napid;": "≋̸",
+ "napos;": "ʼn",
+ "natur;": "♮",
+ "nbump;": "≎̸",
+ "ncong;": "≇",
+ "ndash;": "–",
+ "neArr;": "⇗",
+ "nearr;": "↗",
+ "nedot;": "≐̸",
+ "nesim;": "≂̸",
+ "ngeqq;": "≧̸",
+ "ngsim;": "≵",
+ "nhArr;": "⇎",
+ "nharr;": "↮",
+ "nhpar;": "⫲",
+ "nlArr;": "⇍",
+ "nlarr;": "↚",
+ "nleqq;": "≦̸",
+ "nless;": "≮",
+ "nlsim;": "≴",
+ "nltri;": "⋪",
+ "notin;": "∉",
+ "notni;": "∌",
+ "npart;": "∂̸",
+ "nprec;": "⊀",
+ "nrArr;": "⇏",
+ "nrarr;": "↛",
+ "nrtri;": "⋫",
+ "nsime;": "≄",
+ "nsmid;": "∤",
+ "nspar;": "∦",
+ "nsubE;": "⫅̸",
+ "nsube;": "⊈",
+ "nsucc;": "⊁",
+ "nsupE;": "⫆̸",
+ "nsupe;": "⊉",
+ Ntilde: "Ñ",
+ ntilde: "ñ",
+ "numsp;": " ",
+ "nvsim;": "∼⃒",
+ "nwArr;": "⇖",
+ "nwarr;": "↖",
+ Oacute: "Ó",
+ oacute: "ó",
+ "Ocirc;": "Ô",
+ "ocirc;": "ô",
+ "odash;": "⊝",
+ "OElig;": "Œ",
+ "oelig;": "œ",
+ "ofcir;": "⦿",
+ Ograve: "Ò",
+ ograve: "ò",
+ "ohbar;": "⦵",
+ "olarr;": "↺",
+ "olcir;": "⦾",
+ "oline;": "‾",
+ "Omacr;": "Ō",
+ "omacr;": "ō",
+ "Omega;": "Ω",
+ "omega;": "ω",
+ "operp;": "⦹",
+ "oplus;": "⊕",
+ "orarr;": "↻",
+ "order;": "ℴ",
+ Oslash: "Ø",
+ oslash: "ø",
+ Otilde: "Õ",
+ otilde: "õ",
+ "ovbar;": "⌽",
+ "parsl;": "⫽",
+ "phone;": "☎",
+ "plusb;": "⊞",
+ "pluse;": "⩲",
+ plusmn: "±",
+ "pound;": "£",
+ "prcue;": "≼",
+ "Prime;": "″",
+ "prime;": "′",
+ "prnap;": "⪹",
+ "prsim;": "≾",
+ "quest;": "?",
+ "rAarr;": "⇛",
+ "radic;": "√",
+ "rangd;": "⦒",
+ "range;": "⦥",
+ "raquo;": "»",
+ "rarrb;": "⇥",
+ "rarrc;": "⤳",
+ "rarrw;": "↝",
+ "ratio;": "∶",
+ "RBarr;": "⤐",
+ "rBarr;": "⤏",
+ "rbarr;": "⤍",
+ "rbbrk;": "❳",
+ "rbrke;": "⦌",
+ "rceil;": "⌉",
+ "rdquo;": "”",
+ "reals;": "ℝ",
+ "rhard;": "⇁",
+ "rharu;": "⇀",
+ "rlarr;": "⇄",
+ "rlhar;": "⇌",
+ "rnmid;": "⫮",
+ "roang;": "⟭",
+ "roarr;": "⇾",
+ "robrk;": "⟧",
+ "ropar;": "⦆",
+ "rrarr;": "⇉",
+ "rsquo;": "’",
+ "rtrie;": "⊵",
+ "rtrif;": "▸",
+ "sbquo;": "‚",
+ "sccue;": "≽",
+ "Scirc;": "Ŝ",
+ "scirc;": "ŝ",
+ "scnap;": "⪺",
+ "scsim;": "≿",
+ "sdotb;": "⊡",
+ "sdote;": "⩦",
+ "seArr;": "⇘",
+ "searr;": "↘",
+ "setmn;": "∖",
+ "sharp;": "♯",
+ "Sigma;": "Σ",
+ "sigma;": "σ",
+ "simeq;": "≃",
+ "simgE;": "⪠",
+ "simlE;": "⪟",
+ "simne;": "≆",
+ "slarr;": "←",
+ "smile;": "⌣",
+ "smtes;": "⪬︀",
+ "sqcap;": "⊓",
+ "sqcup;": "⊔",
+ "sqsub;": "⊏",
+ "sqsup;": "⊐",
+ "srarr;": "→",
+ "starf;": "★",
+ "strns;": "¯",
+ "subnE;": "⫋",
+ "subne;": "⊊",
+ "supnE;": "⫌",
+ "supne;": "⊋",
+ "swArr;": "⇙",
+ "swarr;": "↙",
+ "szlig;": "ß",
+ "Theta;": "Θ",
+ "theta;": "θ",
+ "thkap;": "≈",
+ "THORN;": "Þ",
+ "thorn;": "þ",
+ "Tilde;": "∼",
+ "tilde;": "˜",
+ "times;": "×",
+ "TRADE;": "™",
+ "trade;": "™",
+ "trisb;": "⧍",
+ "TSHcy;": "Ћ",
+ "tshcy;": "ћ",
+ "twixt;": "≬",
+ Uacute: "Ú",
+ uacute: "ú",
+ "Ubrcy;": "Ў",
+ "ubrcy;": "ў",
+ "Ucirc;": "Û",
+ "ucirc;": "û",
+ "udarr;": "⇅",
+ "udhar;": "⥮",
+ Ugrave: "Ù",
+ ugrave: "ù",
+ "uharl;": "↿",
+ "uharr;": "↾",
+ "uhblk;": "▀",
+ "ultri;": "◸",
+ "Umacr;": "Ū",
+ "umacr;": "ū",
+ "Union;": "⋃",
+ "Uogon;": "Ų",
+ "uogon;": "ų",
+ "uplus;": "⊎",
+ "upsih;": "ϒ",
+ "UpTee;": "⊥",
+ "Uring;": "Ů",
+ "uring;": "ů",
+ "urtri;": "◹",
+ "utdot;": "⋰",
+ "utrif;": "▴",
+ "uuarr;": "⇈",
+ "varpi;": "ϖ",
+ "vBarv;": "⫩",
+ "VDash;": "⊫",
+ "Vdash;": "⊩",
+ "vDash;": "⊨",
+ "vdash;": "⊢",
+ "veeeq;": "≚",
+ "vltri;": "⊲",
+ "vnsub;": "⊂⃒",
+ "vnsup;": "⊃⃒",
+ "vprop;": "∝",
+ "vrtri;": "⊳",
+ "Wcirc;": "Ŵ",
+ "wcirc;": "ŵ",
+ "Wedge;": "⋀",
+ "wedge;": "∧",
+ "xcirc;": "◯",
+ "xdtri;": "▽",
+ "xhArr;": "⟺",
+ "xharr;": "⟷",
+ "xlArr;": "⟸",
+ "xlarr;": "⟵",
+ "xodot;": "⨀",
+ "xrArr;": "⟹",
+ "xrarr;": "⟶",
+ "xutri;": "△",
+ Yacute: "Ý",
+ yacute: "ý",
+ "Ycirc;": "Ŷ",
+ "ycirc;": "ŷ",
+ "Aacute;": "Á",
+ "aacute;": "á",
+ "Abreve;": "Ă",
+ "abreve;": "ă",
+ "Agrave;": "À",
+ "agrave;": "à",
+ "andand;": "⩕",
+ "angmsd;": "∡",
+ "angsph;": "∢",
+ "apacir;": "⩯",
+ "approx;": "≈",
+ "Assign;": "≔",
+ "Atilde;": "Ã",
+ "atilde;": "ã",
+ "barvee;": "⊽",
+ "Barwed;": "⌆",
+ "barwed;": "⌅",
+ "becaus;": "∵",
+ "bernou;": "ℬ",
+ "bigcap;": "⋂",
+ "bigcup;": "⋃",
+ "bigvee;": "⋁",
+ "bkarow;": "⤍",
+ "bottom;": "⊥",
+ "bowtie;": "⋈",
+ "boxbox;": "⧉",
+ "bprime;": "‵",
+ "brvbar;": "¦",
+ "bullet;": "•",
+ "Bumpeq;": "≎",
+ "bumpeq;": "≏",
+ "Cacute;": "Ć",
+ "cacute;": "ć",
+ "capand;": "⩄",
+ "capcap;": "⩋",
+ "capcup;": "⩇",
+ "capdot;": "⩀",
+ "Ccaron;": "Č",
+ "ccaron;": "č",
+ "Ccedil;": "Ç",
+ "ccedil;": "ç",
+ "circeq;": "≗",
+ "cirmid;": "⫯",
+ "Colone;": "⩴",
+ "colone;": "≔",
+ "commat;": "@",
+ "compfn;": "∘",
+ "Conint;": "∯",
+ "conint;": "∮",
+ "coprod;": "∐",
+ "copysr;": "℗",
+ "cularr;": "↶",
+ "CupCap;": "≍",
+ "cupcap;": "⩆",
+ "cupcup;": "⩊",
+ "cupdot;": "⊍",
+ "curarr;": "↷",
+ "curren;": "¤",
+ "cylcty;": "⌭",
+ "Dagger;": "‡",
+ "dagger;": "†",
+ "daleth;": "ℸ",
+ "Dcaron;": "Ď",
+ "dcaron;": "ď",
+ "dfisht;": "⥿",
+ "divide;": "÷",
+ "divonx;": "⋇",
+ "dlcorn;": "⌞",
+ "dlcrop;": "⌍",
+ "dollar;": "$",
+ "DotDot;": "⃜",
+ "drcorn;": "⌟",
+ "drcrop;": "⌌",
+ "Dstrok;": "Đ",
+ "dstrok;": "đ",
+ "Eacute;": "É",
+ "eacute;": "é",
+ "easter;": "⩮",
+ "Ecaron;": "Ě",
+ "ecaron;": "ě",
+ "ecolon;": "≕",
+ "Egrave;": "È",
+ "egrave;": "è",
+ "egsdot;": "⪘",
+ "elsdot;": "⪗",
+ "emptyv;": "∅",
+ "emsp13;": " ",
+ "emsp14;": " ",
+ "eparsl;": "⧣",
+ "eqcirc;": "≖",
+ "equals;": "=",
+ "equest;": "≟",
+ "Exists;": "∃",
+ "female;": "♀",
+ "ffilig;": "ffi",
+ "ffllig;": "ffl",
+ "ForAll;": "∀",
+ "forall;": "∀",
+ "frac12;": "½",
+ "frac13;": "⅓",
+ "frac14;": "¼",
+ "frac15;": "⅕",
+ "frac16;": "⅙",
+ "frac18;": "⅛",
+ "frac23;": "⅔",
+ "frac25;": "⅖",
+ "frac34;": "¾",
+ "frac35;": "⅗",
+ "frac38;": "⅜",
+ "frac45;": "⅘",
+ "frac56;": "⅚",
+ "frac58;": "⅝",
+ "frac78;": "⅞",
+ "gacute;": "ǵ",
+ "Gammad;": "Ϝ",
+ "gammad;": "ϝ",
+ "Gbreve;": "Ğ",
+ "gbreve;": "ğ",
+ "Gcedil;": "Ģ",
+ "gesdot;": "⪀",
+ "gesles;": "⪔",
+ "gtlPar;": "⦕",
+ "gtrarr;": "⥸",
+ "gtrdot;": "⋗",
+ "gtrsim;": "≳",
+ "hairsp;": " ",
+ "hamilt;": "ℋ",
+ "HARDcy;": "Ъ",
+ "hardcy;": "ъ",
+ "hearts;": "♥",
+ "hellip;": "…",
+ "hercon;": "⊹",
+ "homtht;": "∻",
+ "horbar;": "―",
+ "hslash;": "ℏ",
+ "Hstrok;": "Ħ",
+ "hstrok;": "ħ",
+ "hybull;": "⁃",
+ "hyphen;": "‐",
+ "Iacute;": "Í",
+ "iacute;": "í",
+ "Igrave;": "Ì",
+ "igrave;": "ì",
+ "iiiint;": "⨌",
+ "iinfin;": "⧜",
+ "incare;": "℅",
+ "inodot;": "ı",
+ "intcal;": "⊺",
+ "iquest;": "¿",
+ "isinsv;": "⋳",
+ "Itilde;": "Ĩ",
+ "itilde;": "ĩ",
+ "Jsercy;": "Ј",
+ "jsercy;": "ј",
+ "kappav;": "ϰ",
+ "Kcedil;": "Ķ",
+ "kcedil;": "ķ",
+ "kgreen;": "ĸ",
+ "Lacute;": "Ĺ",
+ "lacute;": "ĺ",
+ "lagran;": "ℒ",
+ "Lambda;": "Λ",
+ "lambda;": "λ",
+ "langle;": "⟨",
+ "larrfs;": "⤝",
+ "larrhk;": "↩",
+ "larrlp;": "↫",
+ "larrpl;": "⤹",
+ "larrtl;": "↢",
+ "lAtail;": "⤛",
+ "latail;": "⤙",
+ "lbrace;": "{",
+ "lbrack;": "[",
+ "Lcaron;": "Ľ",
+ "lcaron;": "ľ",
+ "Lcedil;": "Ļ",
+ "lcedil;": "ļ",
+ "ldquor;": "„",
+ "lesdot;": "⩿",
+ "lesges;": "⪓",
+ "lfisht;": "⥼",
+ "lfloor;": "⌊",
+ "lharul;": "⥪",
+ "llhard;": "⥫",
+ "Lmidot;": "Ŀ",
+ "lmidot;": "ŀ",
+ "lmoust;": "⎰",
+ "loplus;": "⨭",
+ "lowast;": "∗",
+ "lowbar;": "_",
+ "lparlt;": "⦓",
+ "lrhard;": "⥭",
+ "lsaquo;": "‹",
+ "lsquor;": "‚",
+ "Lstrok;": "Ł",
+ "lstrok;": "ł",
+ "lthree;": "⋋",
+ "ltimes;": "⋉",
+ "ltlarr;": "⥶",
+ "ltrPar;": "⦖",
+ "mapsto;": "↦",
+ "marker;": "▮",
+ "mcomma;": "⨩",
+ "midast;": "*",
+ "midcir;": "⫰",
+ "middot;": "·",
+ "minusb;": "⊟",
+ "minusd;": "∸",
+ "mnplus;": "∓",
+ "models;": "⊧",
+ "mstpos;": "∾",
+ "Nacute;": "Ń",
+ "nacute;": "ń",
+ "nbumpe;": "≏̸",
+ "Ncaron;": "Ň",
+ "ncaron;": "ň",
+ "Ncedil;": "Ņ",
+ "ncedil;": "ņ",
+ "nearhk;": "⤤",
+ "nequiv;": "≢",
+ "nesear;": "⤨",
+ "nexist;": "∄",
+ "nltrie;": "⋬",
+ "notinE;": "⋹̸",
+ "nparsl;": "⫽⃥",
+ "nprcue;": "⋠",
+ "nrarrc;": "⤳̸",
+ "nrarrw;": "↝̸",
+ "nrtrie;": "⋭",
+ "nsccue;": "⋡",
+ "nsimeq;": "≄",
+ "Ntilde;": "Ñ",
+ "ntilde;": "ñ",
+ "numero;": "№",
+ "nVDash;": "⊯",
+ "nVdash;": "⊮",
+ "nvDash;": "⊭",
+ "nvdash;": "⊬",
+ "nvHarr;": "⤄",
+ "nvlArr;": "⤂",
+ "nvrArr;": "⤃",
+ "nwarhk;": "⤣",
+ "nwnear;": "⤧",
+ "Oacute;": "Ó",
+ "oacute;": "ó",
+ "Odblac;": "Ő",
+ "odblac;": "ő",
+ "odsold;": "⦼",
+ "Ograve;": "Ò",
+ "ograve;": "ò",
+ "ominus;": "⊖",
+ "origof;": "⊶",
+ "Oslash;": "Ø",
+ "oslash;": "ø",
+ "Otilde;": "Õ",
+ "otilde;": "õ",
+ "Otimes;": "⨷",
+ "otimes;": "⊗",
+ "parsim;": "⫳",
+ "percnt;": "%",
+ "period;": ".",
+ "permil;": "‰",
+ "phmmat;": "ℳ",
+ "planck;": "ℏ",
+ "plankv;": "ℏ",
+ "plusdo;": "∔",
+ "plusdu;": "⨥",
+ "plusmn;": "±",
+ "preceq;": "⪯",
+ "primes;": "ℙ",
+ "prnsim;": "⋨",
+ "propto;": "∝",
+ "prurel;": "⊰",
+ "puncsp;": " ",
+ "qprime;": "⁗",
+ "Racute;": "Ŕ",
+ "racute;": "ŕ",
+ "rangle;": "⟩",
+ "rarrap;": "⥵",
+ "rarrfs;": "⤞",
+ "rarrhk;": "↪",
+ "rarrlp;": "↬",
+ "rarrpl;": "⥅",
+ "Rarrtl;": "⤖",
+ "rarrtl;": "↣",
+ "rAtail;": "⤜",
+ "ratail;": "⤚",
+ "rbrace;": "}",
+ "rbrack;": "]",
+ "Rcaron;": "Ř",
+ "rcaron;": "ř",
+ "Rcedil;": "Ŗ",
+ "rcedil;": "ŗ",
+ "rdquor;": "”",
+ "rfisht;": "⥽",
+ "rfloor;": "⌋",
+ "rharul;": "⥬",
+ "rmoust;": "⎱",
+ "roplus;": "⨮",
+ "rpargt;": "⦔",
+ "rsaquo;": "›",
+ "rsquor;": "’",
+ "rthree;": "⋌",
+ "rtimes;": "⋊",
+ "Sacute;": "Ś",
+ "sacute;": "ś",
+ "Scaron;": "Š",
+ "scaron;": "š",
+ "Scedil;": "Ş",
+ "scedil;": "ş",
+ "scnsim;": "⋩",
+ "searhk;": "⤥",
+ "seswar;": "⤩",
+ "sfrown;": "⌢",
+ "SHCHcy;": "Щ",
+ "shchcy;": "щ",
+ "sigmaf;": "ς",
+ "sigmav;": "ς",
+ "simdot;": "⩪",
+ "smashp;": "⨳",
+ "SOFTcy;": "Ь",
+ "softcy;": "ь",
+ "solbar;": "⌿",
+ "spades;": "♠",
+ "sqcaps;": "⊓︀",
+ "sqcups;": "⊔︀",
+ "sqsube;": "⊑",
+ "sqsupe;": "⊒",
+ "Square;": "□",
+ "square;": "□",
+ "squarf;": "▪",
+ "ssetmn;": "∖",
+ "ssmile;": "⌣",
+ "sstarf;": "⋆",
+ "subdot;": "⪽",
+ "Subset;": "⋐",
+ "subset;": "⊂",
+ "subsim;": "⫇",
+ "subsub;": "⫕",
+ "subsup;": "⫓",
+ "succeq;": "⪰",
+ "supdot;": "⪾",
+ "Supset;": "⋑",
+ "supset;": "⊃",
+ "supsim;": "⫈",
+ "supsub;": "⫔",
+ "supsup;": "⫖",
+ "swarhk;": "⤦",
+ "swnwar;": "⤪",
+ "target;": "⌖",
+ "Tcaron;": "Ť",
+ "tcaron;": "ť",
+ "Tcedil;": "Ţ",
+ "tcedil;": "ţ",
+ "telrec;": "⌕",
+ "there4;": "∴",
+ "thetav;": "ϑ",
+ "thinsp;": " ",
+ "thksim;": "∼",
+ "timesb;": "⊠",
+ "timesd;": "⨰",
+ "topbot;": "⌶",
+ "topcir;": "⫱",
+ "tprime;": "‴",
+ "tridot;": "◬",
+ "Tstrok;": "Ŧ",
+ "tstrok;": "ŧ",
+ "Uacute;": "Ú",
+ "uacute;": "ú",
+ "Ubreve;": "Ŭ",
+ "ubreve;": "ŭ",
+ "Udblac;": "Ű",
+ "udblac;": "ű",
+ "ufisht;": "⥾",
+ "Ugrave;": "Ù",
+ "ugrave;": "ù",
+ "ulcorn;": "⌜",
+ "ulcrop;": "⌏",
+ "urcorn;": "⌝",
+ "urcrop;": "⌎",
+ "Utilde;": "Ũ",
+ "utilde;": "ũ",
+ "vangrt;": "⦜",
+ "varphi;": "ϕ",
+ "varrho;": "ϱ",
+ "Vdashl;": "⫦",
+ "veebar;": "⊻",
+ "vellip;": "⋮",
+ "Verbar;": "‖",
+ "verbar;": "|",
+ "vsubnE;": "⫋︀",
+ "vsubne;": "⊊︀",
+ "vsupnE;": "⫌︀",
+ "vsupne;": "⊋︀",
+ "Vvdash;": "⊪",
+ "wedbar;": "⩟",
+ "wedgeq;": "≙",
+ "weierp;": "℘",
+ "wreath;": "≀",
+ "xoplus;": "⨁",
+ "xotime;": "⨂",
+ "xsqcup;": "⨆",
+ "xuplus;": "⨄",
+ "xwedge;": "⋀",
+ "Yacute;": "Ý",
+ "yacute;": "ý",
+ "Zacute;": "Ź",
+ "zacute;": "ź",
+ "Zcaron;": "Ž",
+ "zcaron;": "ž",
+ "zeetrf;": "ℨ",
+ "alefsym;": "ℵ",
+ "angrtvb;": "⊾",
+ "angzarr;": "⍼",
+ "asympeq;": "≍",
+ "backsim;": "∽",
+ "Because;": "∵",
+ "because;": "∵",
+ "bemptyv;": "⦰",
+ "between;": "≬",
+ "bigcirc;": "◯",
+ "bigodot;": "⨀",
+ "bigstar;": "★",
+ "bnequiv;": "≡⃥",
+ "boxplus;": "⊞",
+ "Cayleys;": "ℭ",
+ "Cconint;": "∰",
+ "ccupssm;": "⩐",
+ "Cedilla;": "¸",
+ "cemptyv;": "⦲",
+ "cirscir;": "⧂",
+ "coloneq;": "≔",
+ "congdot;": "⩭",
+ "cudarrl;": "⤸",
+ "cudarrr;": "⤵",
+ "cularrp;": "⤽",
+ "curarrm;": "⤼",
+ "dbkarow;": "⤏",
+ "ddagger;": "‡",
+ "ddotseq;": "⩷",
+ "demptyv;": "⦱",
+ "Diamond;": "⋄",
+ "diamond;": "⋄",
+ "digamma;": "ϝ",
+ "dotplus;": "∔",
+ "DownTee;": "⊤",
+ "dwangle;": "⦦",
+ "Element;": "∈",
+ "Epsilon;": "Ε",
+ "epsilon;": "ε",
+ "eqcolon;": "≕",
+ "equivDD;": "⩸",
+ "gesdoto;": "⪂",
+ "gtquest;": "⩼",
+ "gtrless;": "≷",
+ "harrcir;": "⥈",
+ "Implies;": "⇒",
+ "intprod;": "⨼",
+ "isindot;": "⋵",
+ "larrbfs;": "⤟",
+ "larrsim;": "⥳",
+ "lbrksld;": "⦏",
+ "lbrkslu;": "⦍",
+ "ldrdhar;": "⥧",
+ "LeftTee;": "⊣",
+ "lesdoto;": "⪁",
+ "lessdot;": "⋖",
+ "lessgtr;": "≶",
+ "lesssim;": "≲",
+ "lotimes;": "⨴",
+ "lozenge;": "◊",
+ "ltquest;": "⩻",
+ "luruhar;": "⥦",
+ "maltese;": "✠",
+ "minusdu;": "⨪",
+ "napprox;": "≉",
+ "natural;": "♮",
+ "nearrow;": "↗",
+ "NewLine;": "\n",
+ "nexists;": "∄",
+ "NoBreak;": "",
+ "notinva;": "∉",
+ "notinvb;": "⋷",
+ "notinvc;": "⋶",
+ "NotLess;": "≮",
+ "notniva;": "∌",
+ "notnivb;": "⋾",
+ "notnivc;": "⋽",
+ "npolint;": "⨔",
+ "npreceq;": "⪯̸",
+ "nsqsube;": "⋢",
+ "nsqsupe;": "⋣",
+ "nsubset;": "⊂⃒",
+ "nsucceq;": "⪰̸",
+ "nsupset;": "⊃⃒",
+ "nvinfin;": "⧞",
+ "nvltrie;": "⊴⃒",
+ "nvrtrie;": "⊵⃒",
+ "nwarrow;": "↖",
+ "olcross;": "⦻",
+ "Omicron;": "Ο",
+ "omicron;": "ο",
+ "orderof;": "ℴ",
+ "orslope;": "⩗",
+ "OverBar;": "‾",
+ "pertenk;": "‱",
+ "planckh;": "ℎ",
+ "pluscir;": "⨢",
+ "plussim;": "⨦",
+ "plustwo;": "⨧",
+ "precsim;": "≾",
+ "Product;": "∏",
+ "quatint;": "⨖",
+ "questeq;": "≟",
+ "rarrbfs;": "⤠",
+ "rarrsim;": "⥴",
+ "rbrksld;": "⦎",
+ "rbrkslu;": "⦐",
+ "rdldhar;": "⥩",
+ "realine;": "ℛ",
+ "rotimes;": "⨵",
+ "ruluhar;": "⥨",
+ "searrow;": "↘",
+ "simplus;": "⨤",
+ "simrarr;": "⥲",
+ "subedot;": "⫃",
+ "submult;": "⫁",
+ "subplus;": "⪿",
+ "subrarr;": "⥹",
+ "succsim;": "≿",
+ "supdsub;": "⫘",
+ "supedot;": "⫄",
+ "suphsol;": "⟉",
+ "suphsub;": "⫗",
+ "suplarr;": "⥻",
+ "supmult;": "⫂",
+ "supplus;": "⫀",
+ "swarrow;": "↙",
+ "topfork;": "⫚",
+ "triplus;": "⨹",
+ "tritime;": "⨻",
+ "UpArrow;": "↑",
+ "Uparrow;": "⇑",
+ "uparrow;": "↑",
+ "Upsilon;": "Υ",
+ "upsilon;": "υ",
+ "uwangle;": "⦧",
+ "vzigzag;": "⦚",
+ "zigrarr;": "⇝",
+ "andslope;": "⩘",
+ "angmsdaa;": "⦨",
+ "angmsdab;": "⦩",
+ "angmsdac;": "⦪",
+ "angmsdad;": "⦫",
+ "angmsdae;": "⦬",
+ "angmsdaf;": "⦭",
+ "angmsdag;": "⦮",
+ "angmsdah;": "⦯",
+ "angrtvbd;": "⦝",
+ "approxeq;": "≊",
+ "awconint;": "∳",
+ "backcong;": "≌",
+ "barwedge;": "⌅",
+ "bbrktbrk;": "⎶",
+ "bigoplus;": "⨁",
+ "bigsqcup;": "⨆",
+ "biguplus;": "⨄",
+ "bigwedge;": "⋀",
+ "boxminus;": "⊟",
+ "boxtimes;": "⊠",
+ "bsolhsub;": "⟈",
+ "capbrcup;": "⩉",
+ "circledR;": "®",
+ "circledS;": "Ⓢ",
+ "cirfnint;": "⨐",
+ "clubsuit;": "♣",
+ "cupbrcap;": "⩈",
+ "curlyvee;": "⋎",
+ "cwconint;": "∲",
+ "DDotrahd;": "⤑",
+ "doteqdot;": "≑",
+ "DotEqual;": "≐",
+ "dotminus;": "∸",
+ "drbkarow;": "⤐",
+ "dzigrarr;": "⟿",
+ "elinters;": "⏧",
+ "emptyset;": "∅",
+ "eqvparsl;": "⧥",
+ "fpartint;": "⨍",
+ "geqslant;": "⩾",
+ "gesdotol;": "⪄",
+ "gnapprox;": "⪊",
+ "hksearow;": "⤥",
+ "hkswarow;": "⤦",
+ "imagline;": "ℐ",
+ "imagpart;": "ℑ",
+ "infintie;": "⧝",
+ "integers;": "ℤ",
+ "Integral;": "∫",
+ "intercal;": "⊺",
+ "intlarhk;": "⨗",
+ "laemptyv;": "⦴",
+ "ldrushar;": "⥋",
+ "leqslant;": "⩽",
+ "lesdotor;": "⪃",
+ "LessLess;": "⪡",
+ "llcorner;": "⌞",
+ "lnapprox;": "⪉",
+ "lrcorner;": "⌟",
+ "lurdshar;": "⥊",
+ "mapstoup;": "↥",
+ "multimap;": "⊸",
+ "naturals;": "ℕ",
+ "ncongdot;": "⩭̸",
+ "NotEqual;": "≠",
+ "notindot;": "⋵̸",
+ "NotTilde;": "≁",
+ "otimesas;": "⨶",
+ "parallel;": "∥",
+ "PartialD;": "∂",
+ "plusacir;": "⨣",
+ "pointint;": "⨕",
+ "Precedes;": "≺",
+ "precneqq;": "⪵",
+ "precnsim;": "⋨",
+ "profalar;": "⌮",
+ "profline;": "⌒",
+ "profsurf;": "⌓",
+ "raemptyv;": "⦳",
+ "realpart;": "ℜ",
+ "RightTee;": "⊢",
+ "rppolint;": "⨒",
+ "rtriltri;": "⧎",
+ "scpolint;": "⨓",
+ "setminus;": "∖",
+ "shortmid;": "∣",
+ "smeparsl;": "⧤",
+ "sqsubset;": "⊏",
+ "sqsupset;": "⊐",
+ "subseteq;": "⊆",
+ "Succeeds;": "≻",
+ "succneqq;": "⪶",
+ "succnsim;": "⋩",
+ "SuchThat;": "∋",
+ "Superset;": "⊃",
+ "supseteq;": "⊇",
+ "thetasym;": "ϑ",
+ "thicksim;": "∼",
+ "timesbar;": "⨱",
+ "triangle;": "▵",
+ "triminus;": "⨺",
+ "trpezium;": "⏢",
+ "Uarrocir;": "⥉",
+ "ulcorner;": "⌜",
+ "UnderBar;": "_",
+ "urcorner;": "⌝",
+ "varkappa;": "ϰ",
+ "varsigma;": "ς",
+ "vartheta;": "ϑ",
+ "backprime;": "‵",
+ "backsimeq;": "⋍",
+ "Backslash;": "∖",
+ "bigotimes;": "⨂",
+ "CenterDot;": "·",
+ "centerdot;": "·",
+ "checkmark;": "✓",
+ "CircleDot;": "⊙",
+ "complexes;": "ℂ",
+ "Congruent;": "≡",
+ "Coproduct;": "∐",
+ "dotsquare;": "⊡",
+ "DoubleDot;": "¨",
+ "DownArrow;": "↓",
+ "Downarrow;": "⇓",
+ "downarrow;": "↓",
+ "DownBreve;": "̑",
+ "gtrapprox;": "⪆",
+ "gtreqless;": "⋛",
+ "gvertneqq;": "≩︀",
+ "heartsuit;": "♥",
+ "HumpEqual;": "≏",
+ "LeftArrow;": "←",
+ "Leftarrow;": "⇐",
+ "leftarrow;": "←",
+ "LeftFloor;": "⌊",
+ "lesseqgtr;": "⋚",
+ "LessTilde;": "≲",
+ "lvertneqq;": "≨︀",
+ "Mellintrf;": "ℳ",
+ "MinusPlus;": "∓",
+ "ngeqslant;": "⩾̸",
+ "nleqslant;": "⩽̸",
+ "NotCupCap;": "≭",
+ "NotExists;": "∄",
+ "NotSubset;": "⊂⃒",
+ "nparallel;": "∦",
+ "nshortmid;": "∤",
+ "nsubseteq;": "⊈",
+ "nsupseteq;": "⊉",
+ "OverBrace;": "⏞",
+ "pitchfork;": "⋔",
+ "PlusMinus;": "±",
+ "rationals;": "ℚ",
+ "spadesuit;": "♠",
+ "subseteqq;": "⫅",
+ "subsetneq;": "⊊",
+ "supseteqq;": "⫆",
+ "supsetneq;": "⊋",
+ "Therefore;": "∴",
+ "therefore;": "∴",
+ "ThinSpace;": " ",
+ "triangleq;": "≜",
+ "TripleDot;": "⃛",
+ "UnionPlus;": "⊎",
+ "varpropto;": "∝",
+ "Bernoullis;": "ℬ",
+ "circledast;": "⊛",
+ "CirclePlus;": "⊕",
+ "complement;": "∁",
+ "curlywedge;": "⋏",
+ "eqslantgtr;": "⪖",
+ "EqualTilde;": "≂",
+ "Fouriertrf;": "ℱ",
+ "gtreqqless;": "⪌",
+ "ImaginaryI;": "ⅈ",
+ "Laplacetrf;": "ℒ",
+ "LeftVector;": "↼",
+ "lessapprox;": "⪅",
+ "lesseqqgtr;": "⪋",
+ "Lleftarrow;": "⇚",
+ "lmoustache;": "⎰",
+ "longmapsto;": "⟼",
+ "mapstodown;": "↧",
+ "mapstoleft;": "↤",
+ "nLeftarrow;": "⇍",
+ "nleftarrow;": "↚",
+ "NotElement;": "∉",
+ "NotGreater;": "≯",
+ "nsubseteqq;": "⫅̸",
+ "nsupseteqq;": "⫆̸",
+ "precapprox;": "⪷",
+ "Proportion;": "∷",
+ "RightArrow;": "→",
+ "Rightarrow;": "⇒",
+ "rightarrow;": "→",
+ "RightFloor;": "⌋",
+ "rmoustache;": "⎱",
+ "sqsubseteq;": "⊑",
+ "sqsupseteq;": "⊒",
+ "subsetneqq;": "⫋",
+ "succapprox;": "⪸",
+ "supsetneqq;": "⫌",
+ "ThickSpace;": " ",
+ "TildeEqual;": "≃",
+ "TildeTilde;": "≈",
+ "UnderBrace;": "⏟",
+ "UpArrowBar;": "⤒",
+ "UpTeeArrow;": "↥",
+ "upuparrows;": "⇈",
+ "varepsilon;": "ϵ",
+ "varnothing;": "∅",
+ "backepsilon;": "϶",
+ "blacksquare;": "▪",
+ "circledcirc;": "⊚",
+ "circleddash;": "⊝",
+ "CircleMinus;": "⊖",
+ "CircleTimes;": "⊗",
+ "curlyeqprec;": "⋞",
+ "curlyeqsucc;": "⋟",
+ "diamondsuit;": "♦",
+ "eqslantless;": "⪕",
+ "Equilibrium;": "⇌",
+ "expectation;": "ℰ",
+ "GreaterLess;": "≷",
+ "LeftCeiling;": "⌈",
+ "LessGreater;": "≶",
+ "MediumSpace;": " ",
+ "NotLessLess;": "≪̸",
+ "NotPrecedes;": "⊀",
+ "NotSucceeds;": "⊁",
+ "NotSuperset;": "⊃⃒",
+ "nRightarrow;": "⇏",
+ "nrightarrow;": "↛",
+ "OverBracket;": "⎴",
+ "preccurlyeq;": "≼",
+ "precnapprox;": "⪹",
+ "quaternions;": "ℍ",
+ "RightVector;": "⇀",
+ "Rrightarrow;": "⇛",
+ "RuleDelayed;": "⧴",
+ "SmallCircle;": "∘",
+ "SquareUnion;": "⊔",
+ "straightphi;": "ϕ",
+ "SubsetEqual;": "⊆",
+ "succcurlyeq;": "≽",
+ "succnapprox;": "⪺",
+ "thickapprox;": "≈",
+ "UpDownArrow;": "↕",
+ "Updownarrow;": "⇕",
+ "updownarrow;": "↕",
+ "VerticalBar;": "∣",
+ "blacklozenge;": "⧫",
+ "DownArrowBar;": "⤓",
+ "DownTeeArrow;": "↧",
+ "ExponentialE;": "ⅇ",
+ "exponentiale;": "ⅇ",
+ "GreaterEqual;": "≥",
+ "GreaterTilde;": "≳",
+ "HilbertSpace;": "ℋ",
+ "HumpDownHump;": "≎",
+ "Intersection;": "⋂",
+ "LeftArrowBar;": "⇤",
+ "LeftTeeArrow;": "↤",
+ "LeftTriangle;": "⊲",
+ "LeftUpVector;": "↿",
+ "NotCongruent;": "≢",
+ "NotHumpEqual;": "≏̸",
+ "NotLessEqual;": "≰",
+ "NotLessTilde;": "≴",
+ "Proportional;": "∝",
+ "RightCeiling;": "⌉",
+ "risingdotseq;": "≓",
+ "RoundImplies;": "⥰",
+ "ShortUpArrow;": "↑",
+ "SquareSubset;": "⊏",
+ "triangledown;": "▿",
+ "triangleleft;": "◃",
+ "UnderBracket;": "⎵",
+ "varsubsetneq;": "⊊︀",
+ "varsupsetneq;": "⊋︀",
+ "VerticalLine;": "|",
+ "ApplyFunction;": "",
+ "bigtriangleup;": "△",
+ "blacktriangle;": "▴",
+ "DifferentialD;": "ⅆ",
+ "divideontimes;": "⋇",
+ "DoubleLeftTee;": "⫤",
+ "DoubleUpArrow;": "⇑",
+ "fallingdotseq;": "≒",
+ "hookleftarrow;": "↩",
+ "leftarrowtail;": "↢",
+ "leftharpoonup;": "↼",
+ "LeftTeeVector;": "⥚",
+ "LeftVectorBar;": "⥒",
+ "LessFullEqual;": "≦",
+ "LongLeftArrow;": "⟵",
+ "Longleftarrow;": "⟸",
+ "longleftarrow;": "⟵",
+ "looparrowleft;": "↫",
+ "measuredangle;": "∡",
+ "NotEqualTilde;": "≂̸",
+ "NotTildeEqual;": "≄",
+ "NotTildeTilde;": "≉",
+ "ntriangleleft;": "⋪",
+ "Poincareplane;": "ℌ",
+ "PrecedesEqual;": "⪯",
+ "PrecedesTilde;": "≾",
+ "RightArrowBar;": "⇥",
+ "RightTeeArrow;": "↦",
+ "RightTriangle;": "⊳",
+ "RightUpVector;": "↾",
+ "shortparallel;": "∥",
+ "smallsetminus;": "∖",
+ "SucceedsEqual;": "⪰",
+ "SucceedsTilde;": "≿",
+ "SupersetEqual;": "⊇",
+ "triangleright;": "▹",
+ "UpEquilibrium;": "⥮",
+ "upharpoonleft;": "↿",
+ "varsubsetneqq;": "⫋︀",
+ "varsupsetneqq;": "⫌︀",
+ "VerticalTilde;": "≀",
+ "VeryThinSpace;": " ",
+ "curvearrowleft;": "↶",
+ "DiacriticalDot;": "˙",
+ "doublebarwedge;": "⌆",
+ "DoubleRightTee;": "⊨",
+ "downdownarrows;": "⇊",
+ "DownLeftVector;": "↽",
+ "GreaterGreater;": "⪢",
+ "hookrightarrow;": "↪",
+ "HorizontalLine;": "─",
+ "InvisibleComma;": "",
+ "InvisibleTimes;": "",
+ "LeftDownVector;": "⇃",
+ "leftleftarrows;": "⇇",
+ "LeftRightArrow;": "↔",
+ "Leftrightarrow;": "⇔",
+ "leftrightarrow;": "↔",
+ "leftthreetimes;": "⋋",
+ "LessSlantEqual;": "⩽",
+ "LongRightArrow;": "⟶",
+ "Longrightarrow;": "⟹",
+ "longrightarrow;": "⟶",
+ "looparrowright;": "↬",
+ "LowerLeftArrow;": "↙",
+ "NestedLessLess;": "≪",
+ "NotGreaterLess;": "≹",
+ "NotLessGreater;": "≸",
+ "NotSubsetEqual;": "⊈",
+ "NotVerticalBar;": "∤",
+ "nshortparallel;": "∦",
+ "ntriangleright;": "⋫",
+ "OpenCurlyQuote;": "‘",
+ "ReverseElement;": "∋",
+ "rightarrowtail;": "↣",
+ "rightharpoonup;": "⇀",
+ "RightTeeVector;": "⥛",
+ "RightVectorBar;": "⥓",
+ "ShortDownArrow;": "↓",
+ "ShortLeftArrow;": "←",
+ "SquareSuperset;": "⊐",
+ "TildeFullEqual;": "≅",
+ "trianglelefteq;": "⊴",
+ "upharpoonright;": "↾",
+ "UpperLeftArrow;": "↖",
+ "ZeroWidthSpace;": "",
+ "bigtriangledown;": "▽",
+ "circlearrowleft;": "↺",
+ "CloseCurlyQuote;": "’",
+ "ContourIntegral;": "∮",
+ "curvearrowright;": "↷",
+ "DoubleDownArrow;": "⇓",
+ "DoubleLeftArrow;": "⇐",
+ "downharpoonleft;": "⇃",
+ "DownRightVector;": "⇁",
+ "leftharpoondown;": "↽",
+ "leftrightarrows;": "⇆",
+ "LeftRightVector;": "⥎",
+ "LeftTriangleBar;": "⧏",
+ "LeftUpTeeVector;": "⥠",
+ "LeftUpVectorBar;": "⥘",
+ "LowerRightArrow;": "↘",
+ "nLeftrightarrow;": "⇎",
+ "nleftrightarrow;": "↮",
+ "NotGreaterEqual;": "≱",
+ "NotGreaterTilde;": "≵",
+ "NotHumpDownHump;": "≎̸",
+ "NotLeftTriangle;": "⋪",
+ "NotSquareSubset;": "⊏̸",
+ "ntrianglelefteq;": "⋬",
+ "OverParenthesis;": "⏜",
+ "RightDownVector;": "⇂",
+ "rightleftarrows;": "⇄",
+ "rightsquigarrow;": "↝",
+ "rightthreetimes;": "⋌",
+ "ShortRightArrow;": "→",
+ "straightepsilon;": "ϵ",
+ "trianglerighteq;": "⊵",
+ "UpperRightArrow;": "↗",
+ "vartriangleleft;": "⊲",
+ "circlearrowright;": "↻",
+ "DiacriticalAcute;": "´",
+ "DiacriticalGrave;": "`",
+ "DiacriticalTilde;": "˜",
+ "DoubleRightArrow;": "⇒",
+ "DownArrowUpArrow;": "⇵",
+ "downharpoonright;": "⇂",
+ "EmptySmallSquare;": "◻",
+ "GreaterEqualLess;": "⋛",
+ "GreaterFullEqual;": "≧",
+ "LeftAngleBracket;": "⟨",
+ "LeftUpDownVector;": "⥑",
+ "LessEqualGreater;": "⋚",
+ "NonBreakingSpace;": " ",
+ "NotPrecedesEqual;": "⪯̸",
+ "NotRightTriangle;": "⋫",
+ "NotSucceedsEqual;": "⪰̸",
+ "NotSucceedsTilde;": "≿̸",
+ "NotSupersetEqual;": "⊉",
+ "ntrianglerighteq;": "⋭",
+ "rightharpoondown;": "⇁",
+ "rightrightarrows;": "⇉",
+ "RightTriangleBar;": "⧐",
+ "RightUpTeeVector;": "⥜",
+ "RightUpVectorBar;": "⥔",
+ "twoheadleftarrow;": "↞",
+ "UnderParenthesis;": "⏝",
+ "UpArrowDownArrow;": "⇅",
+ "vartriangleright;": "⊳",
+ "blacktriangledown;": "▾",
+ "blacktriangleleft;": "◂",
+ "DoubleUpDownArrow;": "⇕",
+ "DoubleVerticalBar;": "∥",
+ "DownLeftTeeVector;": "⥞",
+ "DownLeftVectorBar;": "⥖",
+ "FilledSmallSquare;": "◼",
+ "GreaterSlantEqual;": "⩾",
+ "LeftDoubleBracket;": "⟦",
+ "LeftDownTeeVector;": "⥡",
+ "LeftDownVectorBar;": "⥙",
+ "leftrightharpoons;": "⇋",
+ "LeftTriangleEqual;": "⊴",
+ "NegativeThinSpace;": "",
+ "NotGreaterGreater;": "≫̸",
+ "NotLessSlantEqual;": "⩽̸",
+ "NotNestedLessLess;": "⪡̸",
+ "NotReverseElement;": "∌",
+ "NotSquareSuperset;": "⊐̸",
+ "NotTildeFullEqual;": "≇",
+ "RightAngleBracket;": "⟩",
+ "rightleftharpoons;": "⇌",
+ "RightUpDownVector;": "⥏",
+ "SquareSubsetEqual;": "⊑",
+ "twoheadrightarrow;": "↠",
+ "VerticalSeparator;": "❘",
+ "blacktriangleright;": "▸",
+ "DownRightTeeVector;": "⥟",
+ "DownRightVectorBar;": "⥗",
+ "LongLeftRightArrow;": "⟷",
+ "Longleftrightarrow;": "⟺",
+ "longleftrightarrow;": "⟷",
+ "NegativeThickSpace;": "",
+ "NotLeftTriangleBar;": "⧏̸",
+ "PrecedesSlantEqual;": "≼",
+ "ReverseEquilibrium;": "⇋",
+ "RightDoubleBracket;": "⟧",
+ "RightDownTeeVector;": "⥝",
+ "RightDownVectorBar;": "⥕",
+ "RightTriangleEqual;": "⊵",
+ "SquareIntersection;": "⊓",
+ "SucceedsSlantEqual;": "≽",
+ "DoubleLongLeftArrow;": "⟸",
+ "DownLeftRightVector;": "⥐",
+ "LeftArrowRightArrow;": "⇆",
+ "leftrightsquigarrow;": "↭",
+ "NegativeMediumSpace;": "",
+ "NotGreaterFullEqual;": "≧̸",
+ "NotRightTriangleBar;": "⧐̸",
+ "RightArrowLeftArrow;": "⇄",
+ "SquareSupersetEqual;": "⊒",
+ "CapitalDifferentialD;": "ⅅ",
+ "DoubleLeftRightArrow;": "⇔",
+ "DoubleLongRightArrow;": "⟹",
+ "EmptyVerySmallSquare;": "▫",
+ "NestedGreaterGreater;": "≫",
+ "NotDoubleVerticalBar;": "∦",
+ "NotGreaterSlantEqual;": "⩾̸",
+ "NotLeftTriangleEqual;": "⋬",
+ "NotSquareSubsetEqual;": "⋢",
+ "OpenCurlyDoubleQuote;": "“",
+ "ReverseUpEquilibrium;": "⥯",
+ "CloseCurlyDoubleQuote;": "”",
+ "DoubleContourIntegral;": "∯",
+ "FilledVerySmallSquare;": "▪",
+ "NegativeVeryThinSpace;": "",
+ "NotPrecedesSlantEqual;": "⋠",
+ "NotRightTriangleEqual;": "⋭",
+ "NotSucceedsSlantEqual;": "⋡",
+ "DiacriticalDoubleAcute;": "˝",
+ "NotSquareSupersetEqual;": "⋣",
+ "NotNestedGreaterGreater;": "⪢̸",
+ "ClockwiseContourIntegral;": "∲",
+ "DoubleLongLeftRightArrow;": "⟺",
+ "CounterClockwiseContourIntegral;": "∳"
+};
+
+let maxCRNameLength;
+const decodeHtml = (rawText, asAttr) => {
+ let offset = 0;
+ const end = rawText.length;
+ let decodedText = "";
+ function advance(length) {
+ offset += length;
+ rawText = rawText.slice(length);
+ }
+ while (offset < end) {
+ const head = /&(?:#x?)?/i.exec(rawText);
+ if (!head || offset + head.index >= end) {
+ const remaining = end - offset;
+ decodedText += rawText.slice(0, remaining);
+ advance(remaining);
+ break;
+ }
+ decodedText += rawText.slice(0, head.index);
+ advance(head.index);
+ if (head[0] === "&") {
+ let name = "";
+ let value = void 0;
+ if (/[0-9a-z]/i.test(rawText[1])) {
+ if (!maxCRNameLength) {
+ maxCRNameLength = Object.keys(namedCharacterReferences).reduce(
+ (max, name2) => Math.max(max, name2.length),
+ 0
+ );
+ }
+ for (let length = maxCRNameLength; !value && length > 0; --length) {
+ name = rawText.slice(1, 1 + length);
+ value = namedCharacterReferences[name];
+ }
+ if (value) {
+ const semi = name.endsWith(";");
+ if (asAttr && !semi && /[=a-z0-9]/i.test(rawText[name.length + 1] || "")) {
+ decodedText += "&" + name;
+ advance(1 + name.length);
+ } else {
+ decodedText += value;
+ advance(1 + name.length);
+ }
+ } else {
+ decodedText += "&" + name;
+ advance(1 + name.length);
+ }
+ } else {
+ decodedText += "&";
+ advance(1);
+ }
+ } else {
+ const hex = head[0] === "&#x";
+ const pattern = hex ? /^&#x([0-9a-f]+);?/i : /^&#([0-9]+);?/;
+ const body = pattern.exec(rawText);
+ if (!body) {
+ decodedText += head[0];
+ advance(head[0].length);
+ } else {
+ let cp = Number.parseInt(body[1], hex ? 16 : 10);
+ if (cp === 0) {
+ cp = 65533;
+ } else if (cp > 1114111) {
+ cp = 65533;
+ } else if (cp >= 55296 && cp <= 57343) {
+ cp = 65533;
+ } else if (cp >= 64976 && cp <= 65007 || (cp & 65534) === 65534) ; else if (cp >= 1 && cp <= 8 || cp === 11 || cp >= 13 && cp <= 31 || cp >= 127 && cp <= 159) {
+ cp = CCR_REPLACEMENTS[cp] || cp;
+ }
+ decodedText += String.fromCodePoint(cp);
+ advance(body[0].length);
+ }
+ }
+ }
+ return decodedText;
+};
+const CCR_REPLACEMENTS = {
+ 128: 8364,
+ 130: 8218,
+ 131: 402,
+ 132: 8222,
+ 133: 8230,
+ 134: 8224,
+ 135: 8225,
+ 136: 710,
+ 137: 8240,
+ 138: 352,
+ 139: 8249,
+ 140: 338,
+ 142: 381,
+ 145: 8216,
+ 146: 8217,
+ 147: 8220,
+ 148: 8221,
+ 149: 8226,
+ 150: 8211,
+ 151: 8212,
+ 152: 732,
+ 153: 8482,
+ 154: 353,
+ 155: 8250,
+ 156: 339,
+ 158: 382,
+ 159: 376
+};
+
+const isRawTextContainer = /* @__PURE__ */ shared.makeMap(
+ "style,iframe,script,noscript",
+ true
+);
+const parserOptions = {
+ isVoidTag: shared.isVoidTag,
+ isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag),
+ isPreTag: (tag) => tag === "pre",
+ decodeEntities: decodeHtml,
+ isBuiltInComponent: (tag) => {
+ if (compilerCore.isBuiltInType(tag, `Transition`)) {
+ return TRANSITION;
+ } else if (compilerCore.isBuiltInType(tag, `TransitionGroup`)) {
+ return TRANSITION_GROUP;
+ }
+ },
+ // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+ getNamespace(tag, parent) {
+ let ns = parent ? parent.ns : 0;
+ if (parent && ns === 2) {
+ if (parent.tag === "annotation-xml") {
+ if (tag === "svg") {
+ return 1;
+ }
+ if (parent.props.some(
+ (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
+ )) {
+ ns = 0;
+ }
+ } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
+ ns = 0;
+ }
+ } else if (parent && ns === 1) {
+ if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
+ ns = 0;
+ }
+ }
+ if (ns === 0) {
+ if (tag === "svg") {
+ return 1;
+ }
+ if (tag === "math") {
+ return 2;
+ }
+ }
+ return ns;
+ },
+ // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
+ getTextMode({ tag, ns }) {
+ if (ns === 0) {
+ if (tag === "textarea" || tag === "title") {
+ return 1;
+ }
+ if (isRawTextContainer(tag)) {
+ return 2;
+ }
+ }
+ return 0;
+ }
+};
+
+const transformStyle = (node) => {
+ if (node.type === 1) {
+ node.props.forEach((p, i) => {
+ if (p.type === 6 && p.name === "style" && p.value) {
+ node.props[i] = {
+ type: 7,
+ name: `bind`,
+ arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
+ exp: parseInlineCSS(p.value.content, p.loc),
+ modifiers: [],
+ loc: p.loc
+ };
+ }
+ });
+ }
+};
+const parseInlineCSS = (cssText, loc) => {
+ const normalized = shared.parseStringStyle(cssText);
+ return compilerCore.createSimpleExpression(
+ JSON.stringify(normalized),
+ false,
+ loc,
+ 3
+ );
+};
+
+function createDOMCompilerError(code, loc) {
+ return compilerCore.createCompilerError(
+ code,
+ loc,
+ DOMErrorMessages
+ );
+}
+const DOMErrorMessages = {
+ [53]: `v-html is missing expression.`,
+ [54]: `v-html will override element children.`,
+ [55]: `v-text is missing expression.`,
+ [56]: `v-text will override element children.`,
+ [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+ [58]: `v-model argument is not supported on plain elements.`,
+ [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+ [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+ [61]: `v-show is missing expression.`,
+ [62]: `<Transition> expects exactly one child element or component.`,
+ [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+ const { exp, loc } = dir;
+ if (!exp) {
+ context.onError(
+ createDOMCompilerError(53, loc)
+ );
+ }
+ if (node.children.length) {
+ context.onError(
+ createDOMCompilerError(54, loc)
+ );
+ node.children.length = 0;
+ }
+ return {
+ props: [
+ compilerCore.createObjectProperty(
+ compilerCore.createSimpleExpression(`innerHTML`, true, loc),
+ exp || compilerCore.createSimpleExpression("", true)
+ )
+ ]
+ };
+};
+
+const transformVText = (dir, node, context) => {
+ const { exp, loc } = dir;
+ if (!exp) {
+ context.onError(
+ createDOMCompilerError(55, loc)
+ );
+ }
+ if (node.children.length) {
+ context.onError(
+ createDOMCompilerError(56, loc)
+ );
+ node.children.length = 0;
+ }
+ return {
+ props: [
+ compilerCore.createObjectProperty(
+ compilerCore.createSimpleExpression(`textContent`, true),
+ exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
+ context.helperString(compilerCore.TO_DISPLAY_STRING),
+ [exp],
+ loc
+ ) : compilerCore.createSimpleExpression("", true)
+ )
+ ]
+ };
+};
+
+const transformModel = (dir, node, context) => {
+ const baseResult = compilerCore.transformModel(dir, node, context);
+ if (!baseResult.props.length || node.tagType === 1) {
+ return baseResult;
+ }
+ if (dir.arg) {
+ context.onError(
+ createDOMCompilerError(
+ 58,
+ dir.arg.loc
+ )
+ );
+ }
+ const { tag } = node;
+ const isCustomElement = context.isCustomElement(tag);
+ if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+ let directiveToUse = V_MODEL_TEXT;
+ let isInvalidType = false;
+ if (tag === "input" || isCustomElement) {
+ const type = compilerCore.findProp(node, `type`);
+ if (type) {
+ if (type.type === 7) {
+ directiveToUse = V_MODEL_DYNAMIC;
+ } else if (type.value) {
+ switch (type.value.content) {
+ case "radio":
+ directiveToUse = V_MODEL_RADIO;
+ break;
+ case "checkbox":
+ directiveToUse = V_MODEL_CHECKBOX;
+ break;
+ case "file":
+ isInvalidType = true;
+ context.onError(
+ createDOMCompilerError(
+ 59,
+ dir.loc
+ )
+ );
+ break;
+ }
+ }
+ } else if (compilerCore.hasDynamicKeyVBind(node)) {
+ directiveToUse = V_MODEL_DYNAMIC;
+ } else ;
+ } else if (tag === "select") {
+ directiveToUse = V_MODEL_SELECT;
+ } else ;
+ if (!isInvalidType) {
+ baseResult.needRuntime = context.helper(directiveToUse);
+ }
+ } else {
+ context.onError(
+ createDOMCompilerError(
+ 57,
+ dir.loc
+ )
+ );
+ }
+ baseResult.props = baseResult.props.filter(
+ (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+ );
+ return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
+ // event propagation management
+ `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(
+ `onkeyup,onkeydown,onkeypress`,
+ true
+);
+const resolveModifiers = (key, modifiers, context, loc) => {
+ const keyModifiers = [];
+ const nonKeyModifiers = [];
+ const eventOptionModifiers = [];
+ for (let i = 0; i < modifiers.length; i++) {
+ const modifier = modifiers[i];
+ if (modifier === "native" && compilerCore.checkCompatEnabled(
+ "COMPILER_V_ON_NATIVE",
+ context,
+ loc
+ )) {
+ eventOptionModifiers.push(modifier);
+ } else if (isEventOptionModifier(modifier)) {
+ eventOptionModifiers.push(modifier);
+ } else {
+ if (maybeKeyModifier(modifier)) {
+ if (compilerCore.isStaticExp(key)) {
+ if (isKeyboardEvent(key.content)) {
+ keyModifiers.push(modifier);
+ } else {
+ nonKeyModifiers.push(modifier);
+ }
+ } else {
+ keyModifiers.push(modifier);
+ nonKeyModifiers.push(modifier);
+ }
+ } else {
+ if (isNonKeyModifier(modifier)) {
+ nonKeyModifiers.push(modifier);
+ } else {
+ keyModifiers.push(modifier);
+ }
+ }
+ }
+ }
+ return {
+ keyModifiers,
+ nonKeyModifiers,
+ eventOptionModifiers
+ };
+};
+const transformClick = (key, event) => {
+ const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
+ return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
+ `(`,
+ key,
+ `) === "onClick" ? "${event}" : (`,
+ key,
+ `)`
+ ]) : key;
+};
+const transformOn = (dir, node, context) => {
+ return compilerCore.transformOn(dir, node, context, (baseResult) => {
+ const { modifiers } = dir;
+ if (!modifiers.length)
+ return baseResult;
+ let { key, value: handlerExp } = baseResult.props[0];
+ const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+ if (nonKeyModifiers.includes("right")) {
+ key = transformClick(key, `onContextmenu`);
+ }
+ if (nonKeyModifiers.includes("middle")) {
+ key = transformClick(key, `onMouseup`);
+ }
+ if (nonKeyModifiers.length) {
+ handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+ handlerExp,
+ JSON.stringify(nonKeyModifiers)
+ ]);
+ }
+ if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+ (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content))) {
+ handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
+ handlerExp,
+ JSON.stringify(keyModifiers)
+ ]);
+ }
+ if (eventOptionModifiers.length) {
+ const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
+ key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+ }
+ return {
+ props: [compilerCore.createObjectProperty(key, handlerExp)]
+ };
+ });
+};
+
+const transformShow = (dir, node, context) => {
+ const { exp, loc } = dir;
+ if (!exp) {
+ context.onError(
+ createDOMCompilerError(61, loc)
+ );
+ }
+ return {
+ props: [],
+ needRuntime: context.helper(V_SHOW)
+ };
+};
+
+const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
+const stringifyStatic = (children, context, parent) => {
+ if (context.scopes.vSlot > 0) {
+ return;
+ }
+ let nc = 0;
+ let ec = 0;
+ const currentChunk = [];
+ const stringifyCurrentChunk = (currentIndex) => {
+ if (nc >= 20 || ec >= 5) {
+ const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
+ JSON.stringify(
+ currentChunk.map((node) => stringifyNode(node, context)).join("")
+ ).replace(expReplaceRE, `" + $1 + "`),
+ // the 2nd argument indicates the number of DOM nodes this static vnode
+ // will insert / hydrate
+ String(currentChunk.length)
+ ]);
+ replaceHoist(currentChunk[0], staticCall, context);
+ if (currentChunk.length > 1) {
+ for (let i2 = 1; i2 < currentChunk.length; i2++) {
+ replaceHoist(currentChunk[i2], null, context);
+ }
+ const deleteCount = currentChunk.length - 1;
+ children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+ return deleteCount;
+ }
+ }
+ return 0;
+ };
+ let i = 0;
+ for (; i < children.length; i++) {
+ const child = children[i];
+ const hoisted = getHoistedNode(child);
+ if (hoisted) {
+ const node = child;
+ const result = analyzeNode(node);
+ if (result) {
+ nc += result[0];
+ ec += result[1];
+ currentChunk.push(node);
+ continue;
+ }
+ }
+ i -= stringifyCurrentChunk(i);
+ nc = 0;
+ ec = 0;
+ currentChunk.length = 0;
+ }
+ stringifyCurrentChunk(i);
+};
+const getHoistedNode = (node) => (node.type === 1 && node.tagType === 0 || node.type == 12) && node.codegenNode && node.codegenNode.type === 4 && node.codegenNode.hoisted;
+const dataAriaRE = /^(data|aria)-/;
+const isStringifiableAttr = (name, ns) => {
+ return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : false) || dataAriaRE.test(name);
+};
+const replaceHoist = (node, replacement, context) => {
+ const hoistToReplace = node.codegenNode.hoisted;
+ context.hoists[context.hoists.indexOf(hoistToReplace)] = replacement;
+};
+const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
+ `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
+);
+function analyzeNode(node) {
+ if (node.type === 1 && isNonStringifiable(node.tag)) {
+ return false;
+ }
+ if (node.type === 12) {
+ return [1, 0];
+ }
+ let nc = 1;
+ let ec = node.props.length > 0 ? 1 : 0;
+ let bailed = false;
+ const bail = () => {
+ bailed = true;
+ return false;
+ };
+ function walk(node2) {
+ for (let i = 0; i < node2.props.length; i++) {
+ const p = node2.props[i];
+ if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
+ return bail();
+ }
+ if (p.type === 7 && p.name === "bind") {
+ if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
+ return bail();
+ }
+ if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
+ return bail();
+ }
+ }
+ }
+ for (let i = 0; i < node2.children.length; i++) {
+ nc++;
+ const child = node2.children[i];
+ if (child.type === 1) {
+ if (child.props.length > 0) {
+ ec++;
+ }
+ walk(child);
+ if (bailed) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ return walk(node) ? [nc, ec] : false;
+}
+function stringifyNode(node, context) {
+ if (shared.isString(node)) {
+ return node;
+ }
+ if (shared.isSymbol(node)) {
+ return ``;
+ }
+ switch (node.type) {
+ case 1:
+ return stringifyElement(node, context);
+ case 2:
+ return shared.escapeHtml(node.content);
+ case 3:
+ return `<!--${shared.escapeHtml(node.content)}-->`;
+ case 5:
+ return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
+ case 8:
+ return shared.escapeHtml(evaluateConstant(node));
+ case 12:
+ return stringifyNode(node.content, context);
+ default:
+ return "";
+ }
+}
+function stringifyElement(node, context) {
+ let res = `<${node.tag}`;
+ let innerHTML = "";
+ for (let i = 0; i < node.props.length; i++) {
+ const p = node.props[i];
+ if (p.type === 6) {
+ res += ` ${p.name}`;
+ if (p.value) {
+ res += `="${shared.escapeHtml(p.value.content)}"`;
+ }
+ } else if (p.type === 7) {
+ if (p.name === "bind") {
+ const exp = p.exp;
+ if (exp.content[0] === "_") {
+ res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+ continue;
+ }
+ if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
+ continue;
+ }
+ let evaluated = evaluateConstant(exp);
+ if (evaluated != null) {
+ const arg = p.arg && p.arg.content;
+ if (arg === "class") {
+ evaluated = shared.normalizeClass(evaluated);
+ } else if (arg === "style") {
+ evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+ }
+ res += ` ${p.arg.content}="${shared.escapeHtml(
+ evaluated
+ )}"`;
+ }
+ } else if (p.name === "html") {
+ innerHTML = evaluateConstant(p.exp);
+ } else if (p.name === "text") {
+ innerHTML = shared.escapeHtml(
+ shared.toDisplayString(evaluateConstant(p.exp))
+ );
+ }
+ }
+ }
+ if (context.scopeId) {
+ res += ` ${context.scopeId}`;
+ }
+ res += `>`;
+ if (innerHTML) {
+ res += innerHTML;
+ } else {
+ for (let i = 0; i < node.children.length; i++) {
+ res += stringifyNode(node.children[i], context);
+ }
+ }
+ if (!shared.isVoidTag(node.tag)) {
+ res += `</${node.tag}>`;
+ }
+ return res;
+}
+function evaluateConstant(exp) {
+ if (exp.type === 4) {
+ return new Function(`return (${exp.content})`)();
+ } else {
+ let res = ``;
+ exp.children.forEach((c) => {
+ if (shared.isString(c) || shared.isSymbol(c)) {
+ return;
+ }
+ if (c.type === 2) {
+ res += c.content;
+ } else if (c.type === 5) {
+ res += shared.toDisplayString(evaluateConstant(c.content));
+ } else {
+ res += evaluateConstant(c);
+ }
+ });
+ return res;
+ }
+}
+
+const ignoreSideEffectTags = (node, context) => {
+ if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+ context.removeNode();
+ }
+};
+
+const DOMNodeTransforms = [
+ transformStyle,
+ ...[]
+];
+const DOMDirectiveTransforms = {
+ cloak: compilerCore.noopDirectiveTransform,
+ html: transformVHtml,
+ text: transformVText,
+ model: transformModel,
+ // override compiler-core
+ on: transformOn,
+ // override compiler-core
+ show: transformShow
+};
+function compile(template, options = {}) {
+ return compilerCore.baseCompile(
+ template,
+ shared.extend({}, parserOptions, options, {
+ nodeTransforms: [
+ // ignore <script> and <tag>
+ // this is not put inside DOMNodeTransforms because that list is used
+ // by compiler-ssr to generate vnode fallback branches
+ ignoreSideEffectTags,
+ ...DOMNodeTransforms,
+ ...options.nodeTransforms || []
+ ],
+ directiveTransforms: shared.extend(
+ {},
+ DOMDirectiveTransforms,
+ options.directiveTransforms || {}
+ ),
+ transformHoist: stringifyStatic
+ })
+ );
+}
+function parse(template, options = {}) {
+ return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
+}
+
+exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
+exports.DOMNodeTransforms = DOMNodeTransforms;
+exports.TRANSITION = TRANSITION;
+exports.TRANSITION_GROUP = TRANSITION_GROUP;
+exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
+exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
+exports.V_MODEL_RADIO = V_MODEL_RADIO;
+exports.V_MODEL_SELECT = V_MODEL_SELECT;
+exports.V_MODEL_TEXT = V_MODEL_TEXT;
+exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
+exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
+exports.V_SHOW = V_SHOW;
+exports.compile = compile;
+exports.createDOMCompilerError = createDOMCompilerError;
+exports.parse = parse;
+exports.parserOptions = parserOptions;
+exports.transformStyle = transformStyle;
+Object.keys(compilerCore).forEach(function (k) {
+ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
+});
diff --git a/.output/server/node_modules/@vue/compiler-ssr/dist/compiler-ssr.cjs.js b/.output/server/node_modules/@vue/compiler-ssr/dist/compiler-ssr.cjs.js
new file mode 100644
index 0000000..51022d3
--- /dev/null
+++ b/.output/server/node_modules/@vue/compiler-ssr/dist/compiler-ssr.cjs.js
@@ -0,0 +1,1359 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var shared = require('@vue/shared');
+
+const SSR_INTERPOLATE = Symbol(`ssrInterpolate`);
+const SSR_RENDER_VNODE = Symbol(`ssrRenderVNode`);
+const SSR_RENDER_COMPONENT = Symbol(`ssrRenderComponent`);
+const SSR_RENDER_SLOT = Symbol(`ssrRenderSlot`);
+const SSR_RENDER_SLOT_INNER = Symbol(`ssrRenderSlotInner`);
+const SSR_RENDER_CLASS = Symbol(`ssrRenderClass`);
+const SSR_RENDER_STYLE = Symbol(`ssrRenderStyle`);
+const SSR_RENDER_ATTRS = Symbol(`ssrRenderAttrs`);
+const SSR_RENDER_ATTR = Symbol(`ssrRenderAttr`);
+const SSR_RENDER_DYNAMIC_ATTR = Symbol(`ssrRenderDynamicAttr`);
+const SSR_RENDER_LIST = Symbol(`ssrRenderList`);
+const SSR_INCLUDE_BOOLEAN_ATTR = Symbol(`ssrIncludeBooleanAttr`);
+const SSR_LOOSE_EQUAL = Symbol(`ssrLooseEqual`);
+const SSR_LOOSE_CONTAIN = Symbol(`ssrLooseContain`);
+const SSR_RENDER_DYNAMIC_MODEL = Symbol(`ssrRenderDynamicModel`);
+const SSR_GET_DYNAMIC_MODEL_PROPS = Symbol(`ssrGetDynamicModelProps`);
+const SSR_RENDER_TELEPORT = Symbol(`ssrRenderTeleport`);
+const SSR_RENDER_SUSPENSE = Symbol(`ssrRenderSuspense`);
+const SSR_GET_DIRECTIVE_PROPS = Symbol(`ssrGetDirectiveProps`);
+const ssrHelpers = {
+ [SSR_INTERPOLATE]: `ssrInterpolate`,
+ [SSR_RENDER_VNODE]: `ssrRenderVNode`,
+ [SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
+ [SSR_RENDER_SLOT]: `ssrRenderSlot`,
+ [SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
+ [SSR_RENDER_CLASS]: `ssrRenderClass`,
+ [SSR_RENDER_STYLE]: `ssrRenderStyle`,
+ [SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
+ [SSR_RENDER_ATTR]: `ssrRenderAttr`,
+ [SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
+ [SSR_RENDER_LIST]: `ssrRenderList`,
+ [SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
+ [SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
+ [SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
+ [SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
+ [SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
+ [SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
+ [SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
+ [SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
+};
+compilerDom.registerRuntimeHelpers(ssrHelpers);
+
+const ssrTransformIf = compilerDom.createStructuralDirectiveTransform(
+ /^(if|else|else-if)$/,
+ compilerDom.processIf
+);
+function ssrProcessIf(node, context, disableNestedFragments = false) {
+ const [rootBranch] = node.branches;
+ const ifStatement = compilerDom.createIfStatement(
+ rootBranch.condition,
+ processIfBranch(rootBranch, context, disableNestedFragments)
+ );
+ context.pushStatement(ifStatement);
+ let currentIf = ifStatement;
+ for (let i = 1; i < node.branches.length; i++) {
+ const branch = node.branches[i];
+ const branchBlockStatement = processIfBranch(
+ branch,
+ context,
+ disableNestedFragments
+ );
+ if (branch.condition) {
+ currentIf = currentIf.alternate = compilerDom.createIfStatement(
+ branch.condition,
+ branchBlockStatement
+ );
+ } else {
+ currentIf.alternate = branchBlockStatement;
+ }
+ }
+ if (!currentIf.alternate) {
+ currentIf.alternate = compilerDom.createBlockStatement([
+ compilerDom.createCallExpression(`_push`, ["`<!---->`"])
+ ]);
+ }
+}
+function processIfBranch(branch, context, disableNestedFragments = false) {
+ const { children } = branch;
+ const needFragmentWrapper = !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && // optimize away nested fragments when the only child is a ForNode
+ !(children.length === 1 && children[0].type === 11);
+ return processChildrenAsStatement(branch, context, needFragmentWrapper);
+}
+
+const ssrTransformFor = compilerDom.createStructuralDirectiveTransform(
+ "for",
+ compilerDom.processFor
+);
+function ssrProcessFor(node, context, disableNestedFragments = false) {
+ const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
+ const renderLoop = compilerDom.createFunctionExpression(
+ compilerDom.createForLoopParams(node.parseResult)
+ );
+ renderLoop.body = processChildrenAsStatement(
+ node,
+ context,
+ needFragmentWrapper
+ );
+ if (!disableNestedFragments) {
+ context.pushStringPart(`<!--[-->`);
+ }
+ context.pushStatement(
+ compilerDom.createCallExpression(context.helper(SSR_RENDER_LIST), [
+ node.source,
+ renderLoop
+ ])
+ );
+ if (!disableNestedFragments) {
+ context.pushStringPart(`<!--]-->`);
+ }
+}
+
+const ssrTransformSlotOutlet = (node, context) => {
+ if (compilerDom.isSlotOutlet(node)) {
+ const { slotName, slotProps } = compilerDom.processSlotOutlet(node, context);
+ const args = [
+ `_ctx.$slots`,
+ slotName,
+ slotProps || `{}`,
+ // fallback content placeholder. will be replaced in the process phase
+ `null`,
+ `_push`,
+ `_parent`
+ ];
+ if (context.scopeId && context.slotted !== false) {
+ args.push(`"${context.scopeId}-s"`);
+ }
+ let method = SSR_RENDER_SLOT;
+ const parent = context.parent;
+ if (parent && parent.type === 1 && parent.tagType === 1 && compilerDom.resolveComponentType(parent, context, true) === compilerDom.TRANSITION && parent.children.filter((c) => c.type === 1).length === 1) {
+ method = SSR_RENDER_SLOT_INNER;
+ if (!(context.scopeId && context.slotted !== false)) {
+ args.push("null");
+ }
+ args.push("true");
+ }
+ node.ssrCodegenNode = compilerDom.createCallExpression(context.helper(method), args);
+ }
+};
+function ssrProcessSlotOutlet(node, context) {
+ const renderCall = node.ssrCodegenNode;
+ if (node.children.length) {
+ const fallbackRenderFn = compilerDom.createFunctionExpression([]);
+ fallbackRenderFn.body = processChildrenAsStatement(node, context);
+ renderCall.arguments[3] = fallbackRenderFn;
+ }
+ if (context.withSlotScopeId) {
+ const slotScopeId = renderCall.arguments[6];
+ renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
+ }
+ context.pushStatement(node.ssrCodegenNode);
+}
+
+function createSSRCompilerError(code, loc) {
+ return compilerDom.createCompilerError(code, loc, SSRErrorMessages);
+}
+const SSRErrorMessages = {
+ [65]: `Unsafe attribute name for SSR.`,
+ [66]: `Missing the 'to' prop on teleport element.`,
+ [67]: `Invalid AST node during SSR transform.`
+};
+
+function ssrProcessTeleport(node, context) {
+ const targetProp = compilerDom.findProp(node, "to");
+ if (!targetProp) {
+ context.onError(
+ createSSRCompilerError(66, node.loc)
+ );
+ return;
+ }
+ let target;
+ if (targetProp.type === 6) {
+ target = targetProp.value && compilerDom.createSimpleExpression(targetProp.value.content, true);
+ } else {
+ target = targetProp.exp;
+ }
+ if (!target) {
+ context.onError(
+ createSSRCompilerError(
+ 66,
+ targetProp.loc
+ )
+ );
+ return;
+ }
+ const disabledProp = compilerDom.findProp(
+ node,
+ "disabled",
+ false,
+ true
+ /* allow empty */
+ );
+ const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
+ const contentRenderFn = compilerDom.createFunctionExpression(
+ [`_push`],
+ void 0,
+ // Body is added later
+ true,
+ // newline
+ false,
+ // isSlot
+ node.loc
+ );
+ contentRenderFn.body = processChildrenAsStatement(node, context);
+ context.pushStatement(
+ compilerDom.createCallExpression(context.helper(SSR_RENDER_TELEPORT), [
+ `_push`,
+ contentRenderFn,
+ target,
+ disabled,
+ `_parent`
+ ])
+ );
+}
+
+const wipMap$3 = /* @__PURE__ */ new WeakMap();
+function ssrTransformSuspense(node, context) {
+ return () => {
+ if (node.children.length) {
+ const wipEntry = {
+ slotsExp: null,
+ // to be immediately set
+ wipSlots: []
+ };
+ wipMap$3.set(node, wipEntry);
+ wipEntry.slotsExp = compilerDom.buildSlots(
+ node,
+ context,
+ (_props, _vForExp, children, loc) => {
+ const fn = compilerDom.createFunctionExpression(
+ [],
+ void 0,
+ // no return, assign body later
+ true,
+ // newline
+ false,
+ // suspense slots are not treated as normal slots
+ loc
+ );
+ wipEntry.wipSlots.push({
+ fn,
+ children
+ });
+ return fn;
+ }
+ ).slots;
+ }
+ };
+}
+function ssrProcessSuspense(node, context) {
+ const wipEntry = wipMap$3.get(node);
+ if (!wipEntry) {
+ return;
+ }
+ const { slotsExp, wipSlots } = wipEntry;
+ for (let i = 0; i < wipSlots.length; i++) {
+ const slot = wipSlots[i];
+ slot.fn.body = processChildrenAsStatement(slot, context);
+ }
+ context.pushStatement(
+ compilerDom.createCallExpression(context.helper(SSR_RENDER_SUSPENSE), [
+ `_push`,
+ slotsExp
+ ])
+ );
+}
+
+const rawChildrenMap = /* @__PURE__ */ new WeakMap();
+const ssrTransformElement = (node, context) => {
+ if (node.type !== 1 || node.tagType !== 0) {
+ return;
+ }
+ return function ssrPostTransformElement() {
+ const openTag = [`<${node.tag}`];
+ const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
+ const hasDynamicVBind = compilerDom.hasDynamicKeyVBind(node);
+ const hasCustomDir = node.props.some(
+ (p) => p.type === 7 && !shared.isBuiltInDirective(p.name)
+ );
+ const needMergeProps = hasDynamicVBind || hasCustomDir;
+ if (needMergeProps) {
+ const { props, directives } = compilerDom.buildProps(
+ node,
+ context,
+ node.props,
+ false,
+ false,
+ true
+ /* ssr */
+ );
+ if (props || directives.length) {
+ const mergedProps = buildSSRProps(props, directives, context);
+ const propsExp = compilerDom.createCallExpression(
+ context.helper(SSR_RENDER_ATTRS),
+ [mergedProps]
+ );
+ if (node.tag === "textarea") {
+ const existingText = node.children[0];
+ if (!existingText || existingText.type !== 5) {
+ const tempId = `_temp${context.temps++}`;
+ propsExp.arguments = [
+ compilerDom.createAssignmentExpression(
+ compilerDom.createSimpleExpression(tempId, false),
+ mergedProps
+ )
+ ];
+ rawChildrenMap.set(
+ node,
+ compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
+ compilerDom.createConditionalExpression(
+ compilerDom.createSimpleExpression(`"value" in ${tempId}`, false),
+ compilerDom.createSimpleExpression(`${tempId}.value`, false),
+ compilerDom.createSimpleExpression(
+ existingText ? existingText.content : ``,
+ true
+ ),
+ false
+ )
+ ])
+ );
+ }
+ } else if (node.tag === "input") {
+ const vModel = findVModel(node);
+ if (vModel) {
+ const tempId = `_temp${context.temps++}`;
+ const tempExp = compilerDom.createSimpleExpression(tempId, false);
+ propsExp.arguments = [
+ compilerDom.createSequenceExpression([
+ compilerDom.createAssignmentExpression(tempExp, mergedProps),
+ compilerDom.createCallExpression(context.helper(compilerDom.MERGE_PROPS), [
+ tempExp,
+ compilerDom.createCallExpression(
+ context.helper(SSR_GET_DYNAMIC_MODEL_PROPS),
+ [
+ tempExp,
+ // existing props
+ vModel.exp
+ // model
+ ]
+ )
+ ])
+ ])
+ ];
+ }
+ }
+ if (needTagForRuntime) {
+ propsExp.arguments.push(`"${node.tag}"`);
+ }
+ openTag.push(propsExp);
+ }
+ }
+ let dynamicClassBinding = void 0;
+ let staticClassBinding = void 0;
+ let dynamicStyleBinding = void 0;
+ for (let i = 0; i < node.props.length; i++) {
+ const prop = node.props[i];
+ if (node.tag === "input" && isTrueFalseValue(prop)) {
+ continue;
+ }
+ if (prop.type === 7) {
+ if (prop.name === "html" && prop.exp) {
+ rawChildrenMap.set(node, prop.exp);
+ } else if (prop.name === "text" && prop.exp) {
+ node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
+ } else if (prop.name === "slot") {
+ context.onError(
+ compilerDom.createCompilerError(40, prop.loc)
+ );
+ } else if (isTextareaWithValue(node, prop) && prop.exp) {
+ if (!needMergeProps) {
+ node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
+ }
+ } else if (!needMergeProps && prop.name !== "on") {
+ const directiveTransform = context.directiveTransforms[prop.name];
+ if (directiveTransform) {
+ const { props, ssrTagParts } = directiveTransform(
+ prop,
+ node,
+ context
+ );
+ if (ssrTagParts) {
+ openTag.push(...ssrTagParts);
+ }
+ for (let j = 0; j < props.length; j++) {
+ const { key, value } = props[j];
+ if (compilerDom.isStaticExp(key)) {
+ let attrName = key.content;
+ if (attrName === "key" || attrName === "ref") {
+ continue;
+ }
+ if (attrName === "class") {
+ openTag.push(
+ ` class="`,
+ dynamicClassBinding = compilerDom.createCallExpression(
+ context.helper(SSR_RENDER_CLASS),
+ [value]
+ ),
+ `"`
+ );
+ } else if (attrName === "style") {
+ if (dynamicStyleBinding) {
+ mergeCall(dynamicStyleBinding, value);
+ } else {
+ openTag.push(
+ ` style="`,
+ dynamicStyleBinding = compilerDom.createCallExpression(
+ context.helper(SSR_RENDER_STYLE),
+ [value]
+ ),
+ `"`
+ );
+ }
+ } else {
+ attrName = node.tag.indexOf("-") > 0 ? attrName : shared.propsToAttrMap[attrName] || attrName.toLowerCase();
+ if (shared.isBooleanAttr(attrName)) {
+ openTag.push(
+ compilerDom.createConditionalExpression(
+ compilerDom.createCallExpression(
+ context.helper(SSR_INCLUDE_BOOLEAN_ATTR),
+ [value]
+ ),
+ compilerDom.createSimpleExpression(" " + attrName, true),
+ compilerDom.createSimpleExpression("", true),
+ false
+ /* no newline */
+ )
+ );
+ } else if (shared.isSSRSafeAttrName(attrName)) {
+ openTag.push(
+ compilerDom.createCallExpression(context.helper(SSR_RENDER_ATTR), [
+ key,
+ value
+ ])
+ );
+ } else {
+ context.onError(
+ createSSRCompilerError(
+ 65,
+ key.loc
+ )
+ );
+ }
+ }
+ } else {
+ const args = [key, value];
+ if (needTagForRuntime) {
+ args.push(`"${node.tag}"`);
+ }
+ openTag.push(
+ compilerDom.createCallExpression(
+ context.helper(SSR_RENDER_DYNAMIC_ATTR),
+ args
+ )
+ );
+ }
+ }
+ }
+ }
+ } else {
+ if (node.tag === "textarea" && prop.name === "value" && prop.value) {
+ rawChildrenMap.set(node, shared.escapeHtml(prop.value.content));
+ } else if (!needMergeProps) {
+ if (prop.name === "key" || prop.name === "ref") {
+ continue;
+ }
+ if (prop.name === "class" && prop.value) {
+ staticClassBinding = JSON.stringify(prop.value.content);
+ }
+ openTag.push(
+ ` ${prop.name}` + (prop.value ? `="${shared.escapeHtml(prop.value.content)}"` : ``)
+ );
+ }
+ }
+ }
+ if (dynamicClassBinding && staticClassBinding) {
+ mergeCall(dynamicClassBinding, staticClassBinding);
+ removeStaticBinding(openTag, "class");
+ }
+ if (context.scopeId) {
+ openTag.push(` ${context.scopeId}`);
+ }
+ node.ssrCodegenNode = compilerDom.createTemplateLiteral(openTag);
+ };
+};
+function buildSSRProps(props, directives, context) {
+ let mergePropsArgs = [];
+ if (props) {
+ if (props.type === 14) {
+ mergePropsArgs = props.arguments;
+ } else {
+ mergePropsArgs.push(props);
+ }
+ }
+ if (directives.length) {
+ for (const dir of directives) {
+ mergePropsArgs.push(
+ compilerDom.createCallExpression(context.helper(SSR_GET_DIRECTIVE_PROPS), [
+ `_ctx`,
+ ...compilerDom.buildDirectiveArgs(dir, context).elements
+ ])
+ );
+ }
+ }
+ return mergePropsArgs.length > 1 ? compilerDom.createCallExpression(context.helper(compilerDom.MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
+}
+function isTrueFalseValue(prop) {
+ if (prop.type === 7) {
+ return prop.name === "bind" && prop.arg && compilerDom.isStaticExp(prop.arg) && (prop.arg.content === "true-value" || prop.arg.content === "false-value");
+ } else {
+ return prop.name === "true-value" || prop.name === "false-value";
+ }
+}
+function isTextareaWithValue(node, prop) {
+ return !!(node.tag === "textarea" && prop.name === "bind" && compilerDom.isStaticArgOf(prop.arg, "value"));
+}
+function mergeCall(call, arg) {
+ const existing = call.arguments[0];
+ if (existing.type === 17) {
+ existing.elements.push(arg);
+ } else {
+ call.arguments[0] = compilerDom.createArrayExpression([existing, arg]);
+ }
+}
+function removeStaticBinding(tag, binding) {
+ const regExp = new RegExp(`^ ${binding}=".+"$`);
+ const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
+ if (i > -1) {
+ tag.splice(i, 1);
+ }
+}
+function findVModel(node) {
+ return node.props.find(
+ (p) => p.type === 7 && p.name === "model" && p.exp
+ );
+}
+function ssrProcessElement(node, context) {
+ const isVoidTag = context.options.isVoidTag || shared.NO;
+ const elementsToAdd = node.ssrCodegenNode.elements;
+ for (let j = 0; j < elementsToAdd.length; j++) {
+ context.pushStringPart(elementsToAdd[j]);
+ }
+ if (context.withSlotScopeId) {
+ context.pushStringPart(compilerDom.createSimpleExpression(`_scopeId`, false));
+ }
+ context.pushStringPart(`>`);
+ const rawChildren = rawChildrenMap.get(node);
+ if (rawChildren) {
+ context.pushStringPart(rawChildren);
+ } else if (node.children.length) {
+ processChildren(node, context);
+ }
+ if (!isVoidTag(node.tag)) {
+ context.pushStringPart(`</${node.tag}>`);
+ }
+}
+
+const wipMap$2 = /* @__PURE__ */ new WeakMap();
+function ssrTransformTransitionGroup(node, context) {
+ return () => {
+ const tag = compilerDom.findProp(node, "tag");
+ if (tag) {
+ const otherProps = node.props.filter((p) => p !== tag);
+ const { props, directives } = compilerDom.buildProps(
+ node,
+ context,
+ otherProps,
+ true,
+ false,
+ true
+ /* ssr (skip event listeners) */
+ );
+ let propsExp = null;
+ if (props || directives.length) {
+ propsExp = compilerDom.createCallExpression(context.helper(SSR_RENDER_ATTRS), [
+ buildSSRProps(props, directives, context)
+ ]);
+ }
+ wipMap$2.set(node, {
+ tag,
+ propsExp,
+ scopeId: context.scopeId || null
+ });
+ }
+ };
+}
+function ssrProcessTransitionGroup(node, context) {
+ const entry = wipMap$2.get(node);
+ if (entry) {
+ const { tag, propsExp, scopeId } = entry;
+ if (tag.type === 7) {
+ context.pushStringPart(`<`);
+ context.pushStringPart(tag.exp);
+ if (propsExp) {
+ context.pushStringPart(propsExp);
+ }
+ if (scopeId) {
+ context.pushStringPart(` ${scopeId}`);
+ }
+ context.pushStringPart(`>`);
+ processChildren(
+ node,
+ context,
+ false,
+ /**
+ * TransitionGroup has the special runtime behavior of flattening and
+ * concatenating all children into a single fragment (in order for them to
+ * be patched using the same key map) so we need to account for that here
+ * by disabling nested fragment wrappers from being generated.
+ */
+ true
+ );
+ context.pushStringPart(`</`);
+ context.pushStringPart(tag.exp);
+ context.pushStringPart(`>`);
+ } else {
+ context.pushStringPart(`<${tag.value.content}`);
+ if (propsExp) {
+ context.pushStringPart(propsExp);
+ }
+ if (scopeId) {
+ context.pushStringPart(` ${scopeId}`);
+ }
+ context.pushStringPart(`>`);
+ processChildren(node, context, false, true);
+ context.pushStringPart(`</${tag.value.content}>`);
+ }
+ } else {
+ processChildren(node, context, true, true);
+ }
+}
+
+const wipMap$1 = /* @__PURE__ */ new WeakMap();
+function ssrTransformTransition(node, context) {
+ return () => {
+ const appear = compilerDom.findProp(node, "appear", false, true);
+ wipMap$1.set(node, !!appear);
+ };
+}
+function ssrProcessTransition(node, context) {
+ node.children = node.children.filter((c) => c.type !== 3);
+ const appear = wipMap$1.get(node);
+ if (appear) {
+ context.pushStringPart(`<template>`);
+ processChildren(node, context, false, true);
+ context.pushStringPart(`</template>`);
+ } else {
+ processChildren(node, context, false, true);
+ }
+}
+
+const wipMap = /* @__PURE__ */ new WeakMap();
+const WIP_SLOT = Symbol();
+const componentTypeMap = /* @__PURE__ */ new WeakMap();
+const ssrTransformComponent = (node, context) => {
+ if (node.type !== 1 || node.tagType !== 1) {
+ return;
+ }
+ const component = compilerDom.resolveComponentType(
+ node,
+ context,
+ true
+ /* ssr */
+ );
+ const isDynamicComponent = shared.isObject(component) && component.callee === compilerDom.RESOLVE_DYNAMIC_COMPONENT;
+ componentTypeMap.set(node, component);
+ if (shared.isSymbol(component)) {
+ if (component === compilerDom.SUSPENSE) {
+ return ssrTransformSuspense(node, context);
+ } else if (component === compilerDom.TRANSITION_GROUP) {
+ return ssrTransformTransitionGroup(node, context);
+ } else if (component === compilerDom.TRANSITION) {
+ return ssrTransformTransition(node);
+ }
+ return;
+ }
+ const vnodeBranches = [];
+ const clonedNode = clone(node);
+ return function ssrPostTransformComponent() {
+ if (clonedNode.children.length) {
+ compilerDom.buildSlots(clonedNode, context, (props, vFor, children) => {
+ vnodeBranches.push(
+ createVNodeSlotBranch(props, vFor, children, context)
+ );
+ return compilerDom.createFunctionExpression(void 0);
+ });
+ }
+ let propsExp = `null`;
+ if (node.props.length) {
+ const { props, directives } = compilerDom.buildProps(
+ node,
+ context,
+ void 0,
+ true,
+ isDynamicComponent
+ );
+ if (props || directives.length) {
+ propsExp = buildSSRProps(props, directives, context);
+ }
+ }
+ const wipEntries = [];
+ wipMap.set(node, wipEntries);
+ const buildSSRSlotFn = (props, _vForExp, children, loc) => {
+ const param0 = props && compilerDom.stringifyExpression(props) || `_`;
+ const fn = compilerDom.createFunctionExpression(
+ [param0, `_push`, `_parent`, `_scopeId`],
+ void 0,
+ // no return, assign body later
+ true,
+ // newline
+ true,
+ // isSlot
+ loc
+ );
+ wipEntries.push({
+ type: WIP_SLOT,
+ fn,
+ children,
+ // also collect the corresponding vnode branch built earlier
+ vnodeBranch: vnodeBranches[wipEntries.length]
+ });
+ return fn;
+ };
+ const slots = node.children.length ? compilerDom.buildSlots(node, context, buildSSRSlotFn).slots : `null`;
+ if (typeof component !== "string") {
+ node.ssrCodegenNode = compilerDom.createCallExpression(
+ context.helper(SSR_RENDER_VNODE),
+ [
+ `_push`,
+ compilerDom.createCallExpression(context.helper(compilerDom.CREATE_VNODE), [
+ component,
+ propsExp,
+ slots
+ ]),
+ `_parent`
+ ]
+ );
+ } else {
+ node.ssrCodegenNode = compilerDom.createCallExpression(
+ context.helper(SSR_RENDER_COMPONENT),
+ [component, propsExp, slots, `_parent`]
+ );
+ }
+ };
+};
+function ssrProcessComponent(node, context, parent) {
+ const component = componentTypeMap.get(node);
+ if (!node.ssrCodegenNode) {
+ if (component === compilerDom.TELEPORT) {
+ return ssrProcessTeleport(node, context);
+ } else if (component === compilerDom.SUSPENSE) {
+ return ssrProcessSuspense(node, context);
+ } else if (component === compilerDom.TRANSITION_GROUP) {
+ return ssrProcessTransitionGroup(node, context);
+ } else {
+ if (parent.type === WIP_SLOT) {
+ context.pushStringPart(``);
+ }
+ if (component === compilerDom.TRANSITION) {
+ return ssrProcessTransition(node, context);
+ }
+ processChildren(node, context);
+ }
+ } else {
+ const wipEntries = wipMap.get(node) || [];
+ for (let i = 0; i < wipEntries.length; i++) {
+ const { fn, vnodeBranch } = wipEntries[i];
+ fn.body = compilerDom.createIfStatement(
+ compilerDom.createSimpleExpression(`_push`, false),
+ processChildrenAsStatement(
+ wipEntries[i],
+ context,
+ false,
+ true
+ /* withSlotScopeId */
+ ),
+ vnodeBranch
+ );
+ }
+ if (context.withSlotScopeId) {
+ node.ssrCodegenNode.arguments.push(`_scopeId`);
+ }
+ if (typeof component === "string") {
+ context.pushStatement(
+ compilerDom.createCallExpression(`_push`, [node.ssrCodegenNode])
+ );
+ } else {
+ context.pushStatement(node.ssrCodegenNode);
+ }
+ }
+}
+const rawOptionsMap = /* @__PURE__ */ new WeakMap();
+const [baseNodeTransforms, baseDirectiveTransforms] = compilerDom.getBaseTransformPreset(true);
+const vnodeNodeTransforms = [...baseNodeTransforms, ...compilerDom.DOMNodeTransforms];
+const vnodeDirectiveTransforms = {
+ ...baseDirectiveTransforms,
+ ...compilerDom.DOMDirectiveTransforms
+};
+function createVNodeSlotBranch(props, vForExp, children, parentContext) {
+ const rawOptions = rawOptionsMap.get(parentContext.root);
+ const subOptions = {
+ ...rawOptions,
+ // overwrite with vnode-based transforms
+ nodeTransforms: [
+ ...vnodeNodeTransforms,
+ ...rawOptions.nodeTransforms || []
+ ],
+ directiveTransforms: {
+ ...vnodeDirectiveTransforms,
+ ...rawOptions.directiveTransforms || {}
+ }
+ };
+ const wrapperNode = {
+ type: 1,
+ ns: 0,
+ tag: "template",
+ tagType: 3,
+ isSelfClosing: false,
+ // important: provide v-slot="props" and v-for="exp" on the wrapper for
+ // proper scope analysis
+ props: [
+ {
+ type: 7,
+ name: "slot",
+ exp: props,
+ arg: void 0,
+ modifiers: [],
+ loc: compilerDom.locStub
+ },
+ {
+ type: 7,
+ name: "for",
+ exp: vForExp,
+ arg: void 0,
+ modifiers: [],
+ loc: compilerDom.locStub
+ }
+ ],
+ children,
+ loc: compilerDom.locStub,
+ codegenNode: void 0
+ };
+ subTransform(wrapperNode, subOptions, parentContext);
+ return compilerDom.createReturnStatement(children);
+}
+function subTransform(node, options, parentContext) {
+ const childRoot = compilerDom.createRoot([node]);
+ const childContext = compilerDom.createTransformContext(childRoot, options);
+ childContext.ssr = false;
+ childContext.scopes = { ...parentContext.scopes };
+ childContext.identifiers = { ...parentContext.identifiers };
+ childContext.imports = parentContext.imports;
+ compilerDom.traverseNode(childRoot, childContext);
+ ["helpers", "components", "directives"].forEach((key) => {
+ childContext[key].forEach((value, helperKey) => {
+ if (key === "helpers") {
+ const parentCount = parentContext.helpers.get(helperKey);
+ if (parentCount === void 0) {
+ parentContext.helpers.set(helperKey, value);
+ } else {
+ parentContext.helpers.set(helperKey, value + parentCount);
+ }
+ } else {
+ parentContext[key].add(value);
+ }
+ });
+ });
+}
+function clone(v) {
+ if (shared.isArray(v)) {
+ return v.map(clone);
+ } else if (shared.isObject(v)) {
+ const res = {};
+ for (const key in v) {
+ res[key] = clone(v[key]);
+ }
+ return res;
+ } else {
+ return v;
+ }
+}
+
+function ssrCodegenTransform(ast, options) {
+ const context = createSSRTransformContext(ast, options);
+ if (options.ssrCssVars) {
+ const cssContext = compilerDom.createTransformContext(compilerDom.createRoot([]), options);
+ const varsExp = compilerDom.processExpression(
+ compilerDom.createSimpleExpression(options.ssrCssVars, false),
+ cssContext
+ );
+ context.body.push(
+ compilerDom.createCompoundExpression([`const _cssVars = { style: `, varsExp, `}`])
+ );
+ Array.from(cssContext.helpers.keys()).forEach((helper) => {
+ ast.helpers.add(helper);
+ });
+ }
+ const isFragment = ast.children.length > 1 && ast.children.some((c) => !compilerDom.isText(c));
+ processChildren(ast, context, isFragment);
+ ast.codegenNode = compilerDom.createBlockStatement(context.body);
+ ast.ssrHelpers = Array.from(
+ /* @__PURE__ */ new Set([
+ ...Array.from(ast.helpers).filter((h) => h in ssrHelpers),
+ ...context.helpers
+ ])
+ );
+ ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
+}
+function createSSRTransformContext(root, options, helpers = /* @__PURE__ */ new Set(), withSlotScopeId = false) {
+ const body = [];
+ let currentString = null;
+ return {
+ root,
+ options,
+ body,
+ helpers,
+ withSlotScopeId,
+ onError: options.onError || ((e) => {
+ throw e;
+ }),
+ helper(name) {
+ helpers.add(name);
+ return name;
+ },
+ pushStringPart(part) {
+ if (!currentString) {
+ const currentCall = compilerDom.createCallExpression(`_push`);
+ body.push(currentCall);
+ currentString = compilerDom.createTemplateLiteral([]);
+ currentCall.arguments.push(currentString);
+ }
+ const bufferedElements = currentString.elements;
+ const lastItem = bufferedElements[bufferedElements.length - 1];
+ if (shared.isString(part) && shared.isString(lastItem)) {
+ bufferedElements[bufferedElements.length - 1] += part;
+ } else {
+ bufferedElements.push(part);
+ }
+ },
+ pushStatement(statement) {
+ currentString = null;
+ body.push(statement);
+ }
+ };
+}
+function createChildContext(parent, withSlotScopeId = parent.withSlotScopeId) {
+ return createSSRTransformContext(
+ parent.root,
+ parent.options,
+ parent.helpers,
+ withSlotScopeId
+ );
+}
+function processChildren(parent, context, asFragment = false, disableNestedFragments = false) {
+ if (asFragment) {
+ context.pushStringPart(`<!--[-->`);
+ }
+ const { children } = parent;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ switch (child.type) {
+ case 1:
+ switch (child.tagType) {
+ case 0:
+ ssrProcessElement(child, context);
+ break;
+ case 1:
+ ssrProcessComponent(child, context, parent);
+ break;
+ case 2:
+ ssrProcessSlotOutlet(child, context);
+ break;
+ case 3:
+ break;
+ default:
+ context.onError(
+ createSSRCompilerError(
+ 67,
+ child.loc
+ )
+ );
+ const exhaustiveCheck2 = child;
+ return exhaustiveCheck2;
+ }
+ break;
+ case 2:
+ context.pushStringPart(shared.escapeHtml(child.content));
+ break;
+ case 3:
+ context.pushStringPart(`<!--${child.content}-->`);
+ break;
+ case 5:
+ context.pushStringPart(
+ compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [child.content])
+ );
+ break;
+ case 9:
+ ssrProcessIf(child, context, disableNestedFragments);
+ break;
+ case 11:
+ ssrProcessFor(child, context, disableNestedFragments);
+ break;
+ case 10:
+ break;
+ case 12:
+ case 8:
+ break;
+ default:
+ context.onError(
+ createSSRCompilerError(
+ 67,
+ child.loc
+ )
+ );
+ const exhaustiveCheck = child;
+ return exhaustiveCheck;
+ }
+ }
+ if (asFragment) {
+ context.pushStringPart(`<!--]-->`);
+ }
+}
+function processChildrenAsStatement(parent, parentContext, asFragment = false, withSlotScopeId = parentContext.withSlotScopeId) {
+ const childContext = createChildContext(parentContext, withSlotScopeId);
+ processChildren(parent, childContext, asFragment);
+ return compilerDom.createBlockStatement(childContext.body);
+}
+
+const ssrTransformModel = (dir, node, context) => {
+ const model = dir.exp;
+ function checkDuplicatedValue() {
+ const value = compilerDom.findProp(node, "value");
+ if (value) {
+ context.onError(
+ compilerDom.createDOMCompilerError(
+ 60,
+ value.loc
+ )
+ );
+ }
+ }
+ function processOption(plainNode) {
+ if (plainNode.tag === "option") {
+ if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
+ const value = findValueBinding(plainNode);
+ plainNode.ssrCodegenNode.elements.push(
+ compilerDom.createConditionalExpression(
+ compilerDom.createCallExpression(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [
+ compilerDom.createConditionalExpression(
+ compilerDom.createCallExpression(`Array.isArray`, [model]),
+ compilerDom.createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
+ model,
+ value
+ ]),
+ compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+ model,
+ value
+ ])
+ )
+ ]),
+ compilerDom.createSimpleExpression(" selected", true),
+ compilerDom.createSimpleExpression("", true),
+ false
+ /* no newline */
+ )
+ );
+ }
+ } else if (plainNode.tag === "optgroup") {
+ plainNode.children.forEach(
+ (option) => processOption(option)
+ );
+ }
+ }
+ if (node.tagType === 0) {
+ const res = { props: [] };
+ const defaultProps = [
+ // default value binding for text type inputs
+ compilerDom.createObjectProperty(`value`, model)
+ ];
+ if (node.tag === "input") {
+ const type = compilerDom.findProp(node, "type");
+ if (type) {
+ const value = findValueBinding(node);
+ if (type.type === 7) {
+ res.ssrTagParts = [
+ compilerDom.createCallExpression(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
+ type.exp,
+ model,
+ value
+ ])
+ ];
+ } else if (type.value) {
+ switch (type.value.content) {
+ case "radio":
+ res.props = [
+ compilerDom.createObjectProperty(
+ `checked`,
+ compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+ model,
+ value
+ ])
+ )
+ ];
+ break;
+ case "checkbox":
+ const trueValueBinding = compilerDom.findProp(node, "true-value");
+ if (trueValueBinding) {
+ const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
+ res.props = [
+ compilerDom.createObjectProperty(
+ `checked`,
+ compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+ model,
+ trueValue
+ ])
+ )
+ ];
+ } else {
+ res.props = [
+ compilerDom.createObjectProperty(
+ `checked`,
+ compilerDom.createConditionalExpression(
+ compilerDom.createCallExpression(`Array.isArray`, [model]),
+ compilerDom.createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
+ model,
+ value
+ ]),
+ model
+ )
+ )
+ ];
+ }
+ break;
+ case "file":
+ context.onError(
+ compilerDom.createDOMCompilerError(
+ 59,
+ dir.loc
+ )
+ );
+ break;
+ default:
+ checkDuplicatedValue();
+ res.props = defaultProps;
+ break;
+ }
+ }
+ } else if (compilerDom.hasDynamicKeyVBind(node)) ; else {
+ checkDuplicatedValue();
+ res.props = defaultProps;
+ }
+ } else if (node.tag === "textarea") {
+ checkDuplicatedValue();
+ node.children = [compilerDom.createInterpolation(model, model.loc)];
+ } else if (node.tag === "select") {
+ node.children.forEach((child) => {
+ if (child.type === 1) {
+ processOption(child);
+ }
+ });
+ } else {
+ context.onError(
+ compilerDom.createDOMCompilerError(
+ 57,
+ dir.loc
+ )
+ );
+ }
+ return res;
+ } else {
+ return compilerDom.transformModel(dir, node, context);
+ }
+};
+function findValueBinding(node) {
+ const valueBinding = compilerDom.findProp(node, "value");
+ return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : compilerDom.createSimpleExpression(valueBinding.value.content, true) : compilerDom.createSimpleExpression(`null`, false);
+}
+
+const ssrTransformShow = (dir, node, context) => {
+ if (!dir.exp) {
+ context.onError(
+ compilerDom.createDOMCompilerError(61)
+ );
+ }
+ return {
+ props: [
+ compilerDom.createObjectProperty(
+ `style`,
+ compilerDom.createConditionalExpression(
+ dir.exp,
+ compilerDom.createSimpleExpression(`null`, false),
+ compilerDom.createObjectExpression([
+ compilerDom.createObjectProperty(
+ `display`,
+ compilerDom.createSimpleExpression(`none`, true)
+ )
+ ]),
+ false
+ /* no newline */
+ )
+ )
+ ]
+ };
+};
+
+const filterChild = (node) => node.children.filter((n) => n.type !== 3);
+const hasSingleChild = (node) => filterChild(node).length === 1;
+const ssrInjectFallthroughAttrs = (node, context) => {
+ if (node.type === 0) {
+ context.identifiers._attrs = 1;
+ }
+ if (node.type === 1 && node.tagType === 1 && (compilerDom.isBuiltInType(node.tag, "Transition") || compilerDom.isBuiltInType(node.tag, "KeepAlive"))) {
+ const rootChildren = filterChild(context.root);
+ if (rootChildren.length === 1 && rootChildren[0] === node) {
+ if (hasSingleChild(node)) {
+ injectFallthroughAttrs(node.children[0]);
+ }
+ return;
+ }
+ }
+ const parent = context.parent;
+ if (!parent || parent.type !== 0) {
+ return;
+ }
+ if (node.type === 10 && hasSingleChild(node)) {
+ let hasEncounteredIf = false;
+ for (const c of filterChild(parent)) {
+ if (c.type === 9 || c.type === 1 && compilerDom.findDir(c, "if")) {
+ if (hasEncounteredIf)
+ return;
+ hasEncounteredIf = true;
+ } else if (
+ // node before v-if
+ !hasEncounteredIf || // non else nodes
+ !(c.type === 1 && compilerDom.findDir(c, /else/, true))
+ ) {
+ return;
+ }
+ }
+ injectFallthroughAttrs(node.children[0]);
+ } else if (hasSingleChild(parent)) {
+ injectFallthroughAttrs(node);
+ }
+};
+function injectFallthroughAttrs(node) {
+ if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !compilerDom.findDir(node, "for")) {
+ node.props.push({
+ type: 7,
+ name: "bind",
+ arg: void 0,
+ exp: compilerDom.createSimpleExpression(`_attrs`, false),
+ modifiers: [],
+ loc: compilerDom.locStub
+ });
+ }
+}
+
+const ssrInjectCssVars = (node, context) => {
+ if (!context.ssrCssVars) {
+ return;
+ }
+ if (node.type === 0) {
+ context.identifiers._cssVars = 1;
+ }
+ const parent = context.parent;
+ if (!parent || parent.type !== 0) {
+ return;
+ }
+ if (node.type === 10) {
+ for (const child of node.children) {
+ injectCssVars(child);
+ }
+ } else {
+ injectCssVars(node);
+ }
+};
+function injectCssVars(node) {
+ if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !compilerDom.findDir(node, "for")) {
+ if (compilerDom.isBuiltInType(node.tag, "Suspense")) {
+ for (const child of node.children) {
+ if (child.type === 1 && child.tagType === 3) {
+ child.children.forEach(injectCssVars);
+ } else {
+ injectCssVars(child);
+ }
+ }
+ } else {
+ node.props.push({
+ type: 7,
+ name: "bind",
+ arg: void 0,
+ exp: compilerDom.createSimpleExpression(`_cssVars`, false),
+ modifiers: [],
+ loc: compilerDom.locStub
+ });
+ }
+ }
+}
+
+function compile(template, options = {}) {
+ options = {
+ ...options,
+ // apply DOM-specific parsing options
+ ...compilerDom.parserOptions,
+ ssr: true,
+ inSSR: true,
+ scopeId: options.mode === "function" ? null : options.scopeId,
+ // always prefix since compiler-ssr doesn't have size concern
+ prefixIdentifiers: true,
+ // disable optimizations that are unnecessary for ssr
+ cacheHandlers: false,
+ hoistStatic: false
+ };
+ const ast = compilerDom.baseParse(template, options);
+ rawOptionsMap.set(ast, options);
+ compilerDom.transform(ast, {
+ ...options,
+ hoistStatic: false,
+ nodeTransforms: [
+ ssrTransformIf,
+ ssrTransformFor,
+ compilerDom.trackVForSlotScopes,
+ compilerDom.transformExpression,
+ ssrTransformSlotOutlet,
+ ssrInjectFallthroughAttrs,
+ ssrInjectCssVars,
+ ssrTransformElement,
+ ssrTransformComponent,
+ compilerDom.trackSlotScopes,
+ compilerDom.transformStyle,
+ ...options.nodeTransforms || []
+ // user transforms
+ ],
+ directiveTransforms: {
+ // reusing core v-bind
+ bind: compilerDom.transformBind,
+ on: compilerDom.transformOn,
+ // model and show have dedicated SSR handling
+ model: ssrTransformModel,
+ show: ssrTransformShow,
+ // the following are ignored during SSR
+ // on: noopDirectiveTransform,
+ cloak: compilerDom.noopDirectiveTransform,
+ once: compilerDom.noopDirectiveTransform,
+ memo: compilerDom.noopDirectiveTransform,
+ ...options.directiveTransforms || {}
+ // user transforms
+ }
+ });
+ ssrCodegenTransform(ast, options);
+ return compilerDom.generate(ast, options);
+}
+
+exports.compile = compile;
diff --git a/.output/server/node_modules/@vue/reactivity/dist/reactivity.cjs.js b/.output/server/node_modules/@vue/reactivity/dist/reactivity.cjs.js
new file mode 100644
index 0000000..b0e8c45
--- /dev/null
+++ b/.output/server/node_modules/@vue/reactivity/dist/reactivity.cjs.js
@@ -0,0 +1,1265 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('@vue/shared');
+
+function warn(msg, ...args) {
+ console.warn(`[Vue warn] ${msg}`, ...args);
+}
+
+let activeEffectScope;
+class EffectScope {
+ constructor(detached = false) {
+ this.detached = detached;
+ /**
+ * @internal
+ */
+ this._active = true;
+ /**
+ * @internal
+ */
+ this.effects = [];
+ /**
+ * @internal
+ */
+ this.cleanups = [];
+ this.parent = activeEffectScope;
+ if (!detached && activeEffectScope) {
+ this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+ this
+ ) - 1;
+ }
+ }
+ get active() {
+ return this._active;
+ }
+ run(fn) {
+ if (this._active) {
+ const currentEffectScope = activeEffectScope;
+ try {
+ activeEffectScope = this;
+ return fn();
+ } finally {
+ activeEffectScope = currentEffectScope;
+ }
+ } else {
+ warn(`cannot run an inactive effect scope.`);
+ }
+ }
+ /**
+ * This should only be called on non-detached scopes
+ * @internal
+ */
+ on() {
+ activeEffectScope = this;
+ }
+ /**
+ * This should only be called on non-detached scopes
+ * @internal
+ */
+ off() {
+ activeEffectScope = this.parent;
+ }
+ stop(fromParent) {
+ if (this._active) {
+ let i, l;
+ for (i = 0, l = this.effects.length; i < l; i++) {
+ this.effects[i].stop();
+ }
+ for (i = 0, l = this.cleanups.length; i < l; i++) {
+ this.cleanups[i]();
+ }
+ if (this.scopes) {
+ for (i = 0, l = this.scopes.length; i < l; i++) {
+ this.scopes[i].stop(true);
+ }
+ }
+ if (!this.detached && this.parent && !fromParent) {
+ const last = this.parent.scopes.pop();
+ if (last && last !== this) {
+ this.parent.scopes[this.index] = last;
+ last.index = this.index;
+ }
+ }
+ this.parent = void 0;
+ this._active = false;
+ }
+ }
+}
+function effectScope(detached) {
+ return new EffectScope(detached);
+}
+function recordEffectScope(effect, scope = activeEffectScope) {
+ if (scope && scope.active) {
+ scope.effects.push(effect);
+ }
+}
+function getCurrentScope() {
+ return activeEffectScope;
+}
+function onScopeDispose(fn) {
+ if (activeEffectScope) {
+ activeEffectScope.cleanups.push(fn);
+ } else {
+ warn(
+ `onScopeDispose() is called when there is no active effect scope to be associated with.`
+ );
+ }
+}
+
+const createDep = (effects) => {
+ const dep = new Set(effects);
+ dep.w = 0;
+ dep.n = 0;
+ return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const initDepMarkers = ({ deps }) => {
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].w |= trackOpBit;
+ }
+ }
+};
+const finalizeDepMarkers = (effect) => {
+ const { deps } = effect;
+ if (deps.length) {
+ let ptr = 0;
+ for (let i = 0; i < deps.length; i++) {
+ const dep = deps[i];
+ if (wasTracked(dep) && !newTracked(dep)) {
+ dep.delete(effect);
+ } else {
+ deps[ptr++] = dep;
+ }
+ dep.w &= ~trackOpBit;
+ dep.n &= ~trackOpBit;
+ }
+ deps.length = ptr;
+ }
+};
+
+const targetMap = /* @__PURE__ */ new WeakMap();
+let effectTrackDepth = 0;
+let trackOpBit = 1;
+const maxMarkerBits = 30;
+let activeEffect;
+const ITERATE_KEY = Symbol("iterate" );
+const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate" );
+class ReactiveEffect {
+ constructor(fn, scheduler = null, scope) {
+ this.fn = fn;
+ this.scheduler = scheduler;
+ this.active = true;
+ this.deps = [];
+ this.parent = void 0;
+ recordEffectScope(this, scope);
+ }
+ run() {
+ if (!this.active) {
+ return this.fn();
+ }
+ let parent = activeEffect;
+ let lastShouldTrack = shouldTrack;
+ while (parent) {
+ if (parent === this) {
+ return;
+ }
+ parent = parent.parent;
+ }
+ try {
+ this.parent = activeEffect;
+ activeEffect = this;
+ shouldTrack = true;
+ trackOpBit = 1 << ++effectTrackDepth;
+ if (effectTrackDepth <= maxMarkerBits) {
+ initDepMarkers(this);
+ } else {
+ cleanupEffect(this);
+ }
+ return this.fn();
+ } finally {
+ if (effectTrackDepth <= maxMarkerBits) {
+ finalizeDepMarkers(this);
+ }
+ trackOpBit = 1 << --effectTrackDepth;
+ activeEffect = this.parent;
+ shouldTrack = lastShouldTrack;
+ this.parent = void 0;
+ if (this.deferStop) {
+ this.stop();
+ }
+ }
+ }
+ stop() {
+ if (activeEffect === this) {
+ this.deferStop = true;
+ } else if (this.active) {
+ cleanupEffect(this);
+ if (this.onStop) {
+ this.onStop();
+ }
+ this.active = false;
+ }
+ }
+}
+function cleanupEffect(effect2) {
+ const { deps } = effect2;
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].delete(effect2);
+ }
+ deps.length = 0;
+ }
+}
+function effect(fn, options) {
+ if (fn.effect instanceof ReactiveEffect) {
+ fn = fn.effect.fn;
+ }
+ const _effect = new ReactiveEffect(fn);
+ if (options) {
+ shared.extend(_effect, options);
+ if (options.scope)
+ recordEffectScope(_effect, options.scope);
+ }
+ if (!options || !options.lazy) {
+ _effect.run();
+ }
+ const runner = _effect.run.bind(_effect);
+ runner.effect = _effect;
+ return runner;
+}
+function stop(runner) {
+ runner.effect.stop();
+}
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = false;
+}
+function enableTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = true;
+}
+function resetTracking() {
+ const last = trackStack.pop();
+ shouldTrack = last === void 0 ? true : last;
+}
+function track(target, type, key) {
+ if (shouldTrack && activeEffect) {
+ let depsMap = targetMap.get(target);
+ if (!depsMap) {
+ targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+ }
+ let dep = depsMap.get(key);
+ if (!dep) {
+ depsMap.set(key, dep = createDep());
+ }
+ const eventInfo = { effect: activeEffect, target, type, key } ;
+ trackEffects(dep, eventInfo);
+ }
+}
+function trackEffects(dep, debuggerEventExtraInfo) {
+ let shouldTrack2 = false;
+ if (effectTrackDepth <= maxMarkerBits) {
+ if (!newTracked(dep)) {
+ dep.n |= trackOpBit;
+ shouldTrack2 = !wasTracked(dep);
+ }
+ } else {
+ shouldTrack2 = !dep.has(activeEffect);
+ }
+ if (shouldTrack2) {
+ dep.add(activeEffect);
+ activeEffect.deps.push(dep);
+ if (activeEffect.onTrack) {
+ activeEffect.onTrack(
+ shared.extend(
+ {
+ effect: activeEffect
+ },
+ debuggerEventExtraInfo
+ )
+ );
+ }
+ }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+ const depsMap = targetMap.get(target);
+ if (!depsMap) {
+ return;
+ }
+ let deps = [];
+ if (type === "clear") {
+ deps = [...depsMap.values()];
+ } else if (key === "length" && shared.isArray(target)) {
+ const newLength = Number(newValue);
+ depsMap.forEach((dep, key2) => {
+ if (key2 === "length" || !shared.isSymbol(key2) && key2 >= newLength) {
+ deps.push(dep);
+ }
+ });
+ } else {
+ if (key !== void 0) {
+ deps.push(depsMap.get(key));
+ }
+ switch (type) {
+ case "add":
+ if (!shared.isArray(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ if (shared.isMap(target)) {
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ } else if (shared.isIntegerKey(key)) {
+ deps.push(depsMap.get("length"));
+ }
+ break;
+ case "delete":
+ if (!shared.isArray(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ if (shared.isMap(target)) {
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ }
+ break;
+ case "set":
+ if (shared.isMap(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ }
+ break;
+ }
+ }
+ const eventInfo = { target, type, key, newValue, oldValue, oldTarget } ;
+ if (deps.length === 1) {
+ if (deps[0]) {
+ {
+ triggerEffects(deps[0], eventInfo);
+ }
+ }
+ } else {
+ const effects = [];
+ for (const dep of deps) {
+ if (dep) {
+ effects.push(...dep);
+ }
+ }
+ {
+ triggerEffects(createDep(effects), eventInfo);
+ }
+ }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+ const effects = shared.isArray(dep) ? dep : [...dep];
+ for (const effect2 of effects) {
+ if (effect2.computed) {
+ triggerEffect(effect2, debuggerEventExtraInfo);
+ }
+ }
+ for (const effect2 of effects) {
+ if (!effect2.computed) {
+ triggerEffect(effect2, debuggerEventExtraInfo);
+ }
+ }
+}
+function triggerEffect(effect2, debuggerEventExtraInfo) {
+ if (effect2 !== activeEffect || effect2.allowRecurse) {
+ if (effect2.onTrigger) {
+ effect2.onTrigger(shared.extend({ effect: effect2 }, debuggerEventExtraInfo));
+ }
+ if (effect2.scheduler) {
+ effect2.scheduler();
+ } else {
+ effect2.run();
+ }
+ }
+}
+function getDepFromReactive(object, key) {
+ var _a;
+ return (_a = targetMap.get(object)) == null ? void 0 : _a.get(key);
+}
+
+const isNonTrackableKeys = /* @__PURE__ */ shared.makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+ /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(shared.isSymbol)
+);
+const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+function createArrayInstrumentations() {
+ const instrumentations = {};
+ ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+ instrumentations[key] = function(...args) {
+ const arr = toRaw(this);
+ for (let i = 0, l = this.length; i < l; i++) {
+ track(arr, "get", i + "");
+ }
+ const res = arr[key](...args);
+ if (res === -1 || res === false) {
+ return arr[key](...args.map(toRaw));
+ } else {
+ return res;
+ }
+ };
+ });
+ ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+ instrumentations[key] = function(...args) {
+ pauseTracking();
+ const res = toRaw(this)[key].apply(this, args);
+ resetTracking();
+ return res;
+ };
+ });
+ return instrumentations;
+}
+function hasOwnProperty(key) {
+ const obj = toRaw(this);
+ track(obj, "has", key);
+ return obj.hasOwnProperty(key);
+}
+class BaseReactiveHandler {
+ constructor(_isReadonly = false, _shallow = false) {
+ this._isReadonly = _isReadonly;
+ this._shallow = _shallow;
+ }
+ get(target, key, receiver) {
+ const isReadonly2 = this._isReadonly, shallow = this._shallow;
+ if (key === "__v_isReactive") {
+ return !isReadonly2;
+ } else if (key === "__v_isReadonly") {
+ return isReadonly2;
+ } else if (key === "__v_isShallow") {
+ return shallow;
+ } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
+ return target;
+ }
+ const targetIsArray = shared.isArray(target);
+ if (!isReadonly2) {
+ if (targetIsArray && shared.hasOwn(arrayInstrumentations, key)) {
+ return Reflect.get(arrayInstrumentations, key, receiver);
+ }
+ if (key === "hasOwnProperty") {
+ return hasOwnProperty;
+ }
+ }
+ const res = Reflect.get(target, key, receiver);
+ if (shared.isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+ return res;
+ }
+ if (!isReadonly2) {
+ track(target, "get", key);
+ }
+ if (shallow) {
+ return res;
+ }
+ if (isRef(res)) {
+ return targetIsArray && shared.isIntegerKey(key) ? res : res.value;
+ }
+ if (shared.isObject(res)) {
+ return isReadonly2 ? readonly(res) : reactive(res);
+ }
+ return res;
+ }
+}
+class MutableReactiveHandler extends BaseReactiveHandler {
+ constructor(shallow = false) {
+ super(false, shallow);
+ }
+ set(target, key, value, receiver) {
+ let oldValue = target[key];
+ if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
+ return false;
+ }
+ if (!this._shallow) {
+ if (!isShallow(value) && !isReadonly(value)) {
+ oldValue = toRaw(oldValue);
+ value = toRaw(value);
+ }
+ if (!shared.isArray(target) && isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ }
+ }
+ const hadKey = shared.isArray(target) && shared.isIntegerKey(key) ? Number(key) < target.length : shared.hasOwn(target, key);
+ const result = Reflect.set(target, key, value, receiver);
+ if (target === toRaw(receiver)) {
+ if (!hadKey) {
+ trigger(target, "add", key, value);
+ } else if (shared.hasChanged(value, oldValue)) {
+ trigger(target, "set", key, value, oldValue);
+ }
+ }
+ return result;
+ }
+ deleteProperty(target, key) {
+ const hadKey = shared.hasOwn(target, key);
+ const oldValue = target[key];
+ const result = Reflect.deleteProperty(target, key);
+ if (result && hadKey) {
+ trigger(target, "delete", key, void 0, oldValue);
+ }
+ return result;
+ }
+ has(target, key) {
+ const result = Reflect.has(target, key);
+ if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
+ track(target, "has", key);
+ }
+ return result;
+ }
+ ownKeys(target) {
+ track(
+ target,
+ "iterate",
+ shared.isArray(target) ? "length" : ITERATE_KEY
+ );
+ return Reflect.ownKeys(target);
+ }
+}
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+ constructor(shallow = false) {
+ super(true, shallow);
+ }
+ set(target, key) {
+ {
+ warn(
+ `Set operation on key "${String(key)}" failed: target is readonly.`,
+ target
+ );
+ }
+ return true;
+ }
+ deleteProperty(target, key) {
+ {
+ warn(
+ `Delete operation on key "${String(key)}" failed: target is readonly.`,
+ target
+ );
+ }
+ return true;
+ }
+}
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
+ true
+);
+const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get(target, key, isReadonly = false, isShallow = false) {
+ target = target["__v_raw"];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (!isReadonly) {
+ if (shared.hasChanged(key, rawKey)) {
+ track(rawTarget, "get", key);
+ }
+ track(rawTarget, "get", rawKey);
+ }
+ const { has: has2 } = getProto(rawTarget);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ if (has2.call(rawTarget, key)) {
+ return wrap(target.get(key));
+ } else if (has2.call(rawTarget, rawKey)) {
+ return wrap(target.get(rawKey));
+ } else if (target !== rawTarget) {
+ target.get(key);
+ }
+}
+function has(key, isReadonly = false) {
+ const target = this["__v_raw"];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (!isReadonly) {
+ if (shared.hasChanged(key, rawKey)) {
+ track(rawTarget, "has", key);
+ }
+ track(rawTarget, "has", rawKey);
+ }
+ return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+}
+function size(target, isReadonly = false) {
+ target = target["__v_raw"];
+ !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
+ return Reflect.get(target, "size", target);
+}
+function add(value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const proto = getProto(target);
+ const hadKey = proto.has.call(target, value);
+ if (!hadKey) {
+ target.add(value);
+ trigger(target, "add", value, value);
+ }
+ return this;
+}
+function set(key, value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const { has: has2, get: get2 } = getProto(target);
+ let hadKey = has2.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has2.call(target, key);
+ } else {
+ checkIdentityKeys(target, has2, key);
+ }
+ const oldValue = get2.call(target, key);
+ target.set(key, value);
+ if (!hadKey) {
+ trigger(target, "add", key, value);
+ } else if (shared.hasChanged(value, oldValue)) {
+ trigger(target, "set", key, value, oldValue);
+ }
+ return this;
+}
+function deleteEntry(key) {
+ const target = toRaw(this);
+ const { has: has2, get: get2 } = getProto(target);
+ let hadKey = has2.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has2.call(target, key);
+ } else {
+ checkIdentityKeys(target, has2, key);
+ }
+ const oldValue = get2 ? get2.call(target, key) : void 0;
+ const result = target.delete(key);
+ if (hadKey) {
+ trigger(target, "delete", key, void 0, oldValue);
+ }
+ return result;
+}
+function clear() {
+ const target = toRaw(this);
+ const hadItems = target.size !== 0;
+ const oldTarget = shared.isMap(target) ? new Map(target) : new Set(target) ;
+ const result = target.clear();
+ if (hadItems) {
+ trigger(target, "clear", void 0, void 0, oldTarget);
+ }
+ return result;
+}
+function createForEach(isReadonly, isShallow) {
+ return function forEach(callback, thisArg) {
+ const observed = this;
+ const target = observed["__v_raw"];
+ const rawTarget = toRaw(target);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
+ return target.forEach((value, key) => {
+ return callback.call(thisArg, wrap(value), wrap(key), observed);
+ });
+ };
+}
+function createIterableMethod(method, isReadonly, isShallow) {
+ return function(...args) {
+ const target = this["__v_raw"];
+ const rawTarget = toRaw(target);
+ const targetIsMap = shared.isMap(rawTarget);
+ const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+ const isKeyOnly = method === "keys" && targetIsMap;
+ const innerIterator = target[method](...args);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(
+ rawTarget,
+ "iterate",
+ isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
+ );
+ return {
+ // iterator protocol
+ next() {
+ const { value, done } = innerIterator.next();
+ return done ? { value, done } : {
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+ done
+ };
+ },
+ // iterable protocol
+ [Symbol.iterator]() {
+ return this;
+ }
+ };
+ };
+}
+function createReadonlyMethod(type) {
+ return function(...args) {
+ {
+ const key = args[0] ? `on key "${args[0]}" ` : ``;
+ console.warn(
+ `${shared.capitalize(type)} operation ${key}failed: target is readonly.`,
+ toRaw(this)
+ );
+ }
+ return type === "delete" ? false : type === "clear" ? void 0 : this;
+ };
+}
+function createInstrumentations() {
+ const mutableInstrumentations2 = {
+ get(key) {
+ return get(this, key);
+ },
+ get size() {
+ return size(this);
+ },
+ has,
+ add,
+ set,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, false)
+ };
+ const shallowInstrumentations2 = {
+ get(key) {
+ return get(this, key, false, true);
+ },
+ get size() {
+ return size(this);
+ },
+ has,
+ add,
+ set,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, true)
+ };
+ const readonlyInstrumentations2 = {
+ get(key) {
+ return get(this, key, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has.call(this, key, true);
+ },
+ add: createReadonlyMethod("add"),
+ set: createReadonlyMethod("set"),
+ delete: createReadonlyMethod("delete"),
+ clear: createReadonlyMethod("clear"),
+ forEach: createForEach(true, false)
+ };
+ const shallowReadonlyInstrumentations2 = {
+ get(key) {
+ return get(this, key, true, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has.call(this, key, true);
+ },
+ add: createReadonlyMethod("add"),
+ set: createReadonlyMethod("set"),
+ delete: createReadonlyMethod("delete"),
+ clear: createReadonlyMethod("clear"),
+ forEach: createForEach(true, true)
+ };
+ const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+ iteratorMethods.forEach((method) => {
+ mutableInstrumentations2[method] = createIterableMethod(
+ method,
+ false,
+ false
+ );
+ readonlyInstrumentations2[method] = createIterableMethod(
+ method,
+ true,
+ false
+ );
+ shallowInstrumentations2[method] = createIterableMethod(
+ method,
+ false,
+ true
+ );
+ shallowReadonlyInstrumentations2[method] = createIterableMethod(
+ method,
+ true,
+ true
+ );
+ });
+ return [
+ mutableInstrumentations2,
+ readonlyInstrumentations2,
+ shallowInstrumentations2,
+ shallowReadonlyInstrumentations2
+ ];
+}
+const [
+ mutableInstrumentations,
+ readonlyInstrumentations,
+ shallowInstrumentations,
+ shallowReadonlyInstrumentations
+] = /* @__PURE__ */ createInstrumentations();
+function createInstrumentationGetter(isReadonly, shallow) {
+ const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
+ return (target, key, receiver) => {
+ if (key === "__v_isReactive") {
+ return !isReadonly;
+ } else if (key === "__v_isReadonly") {
+ return isReadonly;
+ } else if (key === "__v_raw") {
+ return target;
+ }
+ return Reflect.get(
+ shared.hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+ key,
+ receiver
+ );
+ };
+}
+const mutableCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const shallowCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(false, true)
+};
+const readonlyCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+const shallowReadonlyCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
+function checkIdentityKeys(target, has2, key) {
+ const rawKey = toRaw(key);
+ if (rawKey !== key && has2.call(target, rawKey)) {
+ const type = shared.toRawType(target);
+ console.warn(
+ `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.`
+ );
+ }
+}
+
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+ switch (rawType) {
+ case "Object":
+ case "Array":
+ return 1 /* COMMON */;
+ case "Map":
+ case "Set":
+ case "WeakMap":
+ case "WeakSet":
+ return 2 /* COLLECTION */;
+ default:
+ return 0 /* INVALID */;
+ }
+}
+function getTargetType(value) {
+ return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(shared.toRawType(value));
+}
+function reactive(target) {
+ if (isReadonly(target)) {
+ return target;
+ }
+ return createReactiveObject(
+ target,
+ false,
+ mutableHandlers,
+ mutableCollectionHandlers,
+ reactiveMap
+ );
+}
+function shallowReactive(target) {
+ return createReactiveObject(
+ target,
+ false,
+ shallowReactiveHandlers,
+ shallowCollectionHandlers,
+ shallowReactiveMap
+ );
+}
+function readonly(target) {
+ return createReactiveObject(
+ target,
+ true,
+ readonlyHandlers,
+ readonlyCollectionHandlers,
+ readonlyMap
+ );
+}
+function shallowReadonly(target) {
+ return createReactiveObject(
+ target,
+ true,
+ shallowReadonlyHandlers,
+ shallowReadonlyCollectionHandlers,
+ shallowReadonlyMap
+ );
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+ if (!shared.isObject(target)) {
+ {
+ console.warn(`value cannot be made reactive: ${String(target)}`);
+ }
+ return target;
+ }
+ if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+ return target;
+ }
+ const existingProxy = proxyMap.get(target);
+ if (existingProxy) {
+ return existingProxy;
+ }
+ const targetType = getTargetType(target);
+ if (targetType === 0 /* INVALID */) {
+ return target;
+ }
+ const proxy = new Proxy(
+ target,
+ targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
+ );
+ proxyMap.set(target, proxy);
+ return proxy;
+}
+function isReactive(value) {
+ if (isReadonly(value)) {
+ return isReactive(value["__v_raw"]);
+ }
+ return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+ return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+ return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+ return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+ const raw = observed && observed["__v_raw"];
+ return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+ shared.def(value, "__v_skip", true);
+ return value;
+}
+const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => shared.isObject(value) ? readonly(value) : value;
+
+function trackRefValue(ref2) {
+ if (shouldTrack && activeEffect) {
+ ref2 = toRaw(ref2);
+ {
+ trackEffects(ref2.dep || (ref2.dep = createDep()), {
+ target: ref2,
+ type: "get",
+ key: "value"
+ });
+ }
+ }
+}
+function triggerRefValue(ref2, newVal) {
+ ref2 = toRaw(ref2);
+ const dep = ref2.dep;
+ if (dep) {
+ {
+ triggerEffects(dep, {
+ target: ref2,
+ type: "set",
+ key: "value",
+ newValue: newVal
+ });
+ }
+ }
+}
+function isRef(r) {
+ return !!(r && r.__v_isRef === true);
+}
+function ref(value) {
+ return createRef(value, false);
+}
+function shallowRef(value) {
+ return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+ if (isRef(rawValue)) {
+ return rawValue;
+ }
+ return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+ constructor(value, __v_isShallow) {
+ this.__v_isShallow = __v_isShallow;
+ this.dep = void 0;
+ this.__v_isRef = true;
+ this._rawValue = __v_isShallow ? value : toRaw(value);
+ this._value = __v_isShallow ? value : toReactive(value);
+ }
+ get value() {
+ trackRefValue(this);
+ return this._value;
+ }
+ set value(newVal) {
+ const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+ newVal = useDirectValue ? newVal : toRaw(newVal);
+ if (shared.hasChanged(newVal, this._rawValue)) {
+ this._rawValue = newVal;
+ this._value = useDirectValue ? newVal : toReactive(newVal);
+ triggerRefValue(this, newVal);
+ }
+ }
+}
+function triggerRef(ref2) {
+ triggerRefValue(ref2, ref2.value );
+}
+function unref(ref2) {
+ return isRef(ref2) ? ref2.value : ref2;
+}
+function toValue(source) {
+ return shared.isFunction(source) ? source() : unref(source);
+}
+const shallowUnwrapHandlers = {
+ get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+ set: (target, key, value, receiver) => {
+ const oldValue = target[key];
+ if (isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ } else {
+ return Reflect.set(target, key, value, receiver);
+ }
+ }
+};
+function proxyRefs(objectWithRefs) {
+ return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+class CustomRefImpl {
+ constructor(factory) {
+ this.dep = void 0;
+ this.__v_isRef = true;
+ const { get, set } = factory(
+ () => trackRefValue(this),
+ () => triggerRefValue(this)
+ );
+ this._get = get;
+ this._set = set;
+ }
+ get value() {
+ return this._get();
+ }
+ set value(newVal) {
+ this._set(newVal);
+ }
+}
+function customRef(factory) {
+ return new CustomRefImpl(factory);
+}
+function toRefs(object) {
+ if (!isProxy(object)) {
+ console.warn(`toRefs() expects a reactive object but received a plain one.`);
+ }
+ const ret = shared.isArray(object) ? new Array(object.length) : {};
+ for (const key in object) {
+ ret[key] = propertyToRef(object, key);
+ }
+ return ret;
+}
+class ObjectRefImpl {
+ constructor(_object, _key, _defaultValue) {
+ this._object = _object;
+ this._key = _key;
+ this._defaultValue = _defaultValue;
+ this.__v_isRef = true;
+ }
+ get value() {
+ const val = this._object[this._key];
+ return val === void 0 ? this._defaultValue : val;
+ }
+ set value(newVal) {
+ this._object[this._key] = newVal;
+ }
+ get dep() {
+ return getDepFromReactive(toRaw(this._object), this._key);
+ }
+}
+class GetterRefImpl {
+ constructor(_getter) {
+ this._getter = _getter;
+ this.__v_isRef = true;
+ this.__v_isReadonly = true;
+ }
+ get value() {
+ return this._getter();
+ }
+}
+function toRef(source, key, defaultValue) {
+ if (isRef(source)) {
+ return source;
+ } else if (shared.isFunction(source)) {
+ return new GetterRefImpl(source);
+ } else if (shared.isObject(source) && arguments.length > 1) {
+ return propertyToRef(source, key, defaultValue);
+ } else {
+ return ref(source);
+ }
+}
+function propertyToRef(source, key, defaultValue) {
+ const val = source[key];
+ return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
+}
+
+class ComputedRefImpl {
+ constructor(getter, _setter, isReadonly, isSSR) {
+ this._setter = _setter;
+ this.dep = void 0;
+ this.__v_isRef = true;
+ this["__v_isReadonly"] = false;
+ this._dirty = true;
+ this.effect = new ReactiveEffect(getter, () => {
+ if (!this._dirty) {
+ this._dirty = true;
+ triggerRefValue(this);
+ }
+ });
+ this.effect.computed = this;
+ this.effect.active = this._cacheable = !isSSR;
+ this["__v_isReadonly"] = isReadonly;
+ }
+ get value() {
+ const self = toRaw(this);
+ trackRefValue(self);
+ if (self._dirty || !self._cacheable) {
+ self._dirty = false;
+ self._value = self.effect.run();
+ }
+ return self._value;
+ }
+ set value(newValue) {
+ this._setter(newValue);
+ }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+ let getter;
+ let setter;
+ const onlyGetter = shared.isFunction(getterOrOptions);
+ if (onlyGetter) {
+ getter = getterOrOptions;
+ setter = () => {
+ console.warn("Write operation failed: computed value is readonly");
+ } ;
+ } else {
+ getter = getterOrOptions.get;
+ setter = getterOrOptions.set;
+ }
+ const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+ if (debugOptions && !isSSR) {
+ cRef.effect.onTrack = debugOptions.onTrack;
+ cRef.effect.onTrigger = debugOptions.onTrigger;
+ }
+ return cRef;
+}
+
+const tick = /* @__PURE__ */ Promise.resolve();
+const queue = [];
+let queued = false;
+const scheduler = (fn) => {
+ queue.push(fn);
+ if (!queued) {
+ queued = true;
+ tick.then(flush);
+ }
+};
+const flush = () => {
+ for (let i = 0; i < queue.length; i++) {
+ queue[i]();
+ }
+ queue.length = 0;
+ queued = false;
+};
+class DeferredComputedRefImpl {
+ constructor(getter) {
+ this.dep = void 0;
+ this._dirty = true;
+ this.__v_isRef = true;
+ this["__v_isReadonly"] = true;
+ let compareTarget;
+ let hasCompareTarget = false;
+ let scheduled = false;
+ this.effect = new ReactiveEffect(getter, (computedTrigger) => {
+ if (this.dep) {
+ if (computedTrigger) {
+ compareTarget = this._value;
+ hasCompareTarget = true;
+ } else if (!scheduled) {
+ const valueToCompare = hasCompareTarget ? compareTarget : this._value;
+ scheduled = true;
+ hasCompareTarget = false;
+ scheduler(() => {
+ if (this.effect.active && this._get() !== valueToCompare) {
+ triggerRefValue(this);
+ }
+ scheduled = false;
+ });
+ }
+ for (const e of this.dep) {
+ if (e.computed instanceof DeferredComputedRefImpl) {
+ e.scheduler(
+ true
+ /* computedTrigger */
+ );
+ }
+ }
+ }
+ this._dirty = true;
+ });
+ this.effect.computed = this;
+ }
+ _get() {
+ if (this._dirty) {
+ this._dirty = false;
+ return this._value = this.effect.run();
+ }
+ return this._value;
+ }
+ get value() {
+ trackRefValue(this);
+ return toRaw(this)._get();
+ }
+}
+function deferredComputed(getter) {
+ return new DeferredComputedRefImpl(getter);
+}
+
+exports.EffectScope = EffectScope;
+exports.ITERATE_KEY = ITERATE_KEY;
+exports.ReactiveEffect = ReactiveEffect;
+exports.computed = computed;
+exports.customRef = customRef;
+exports.deferredComputed = deferredComputed;
+exports.effect = effect;
+exports.effectScope = effectScope;
+exports.enableTracking = enableTracking;
+exports.getCurrentScope = getCurrentScope;
+exports.isProxy = isProxy;
+exports.isReactive = isReactive;
+exports.isReadonly = isReadonly;
+exports.isRef = isRef;
+exports.isShallow = isShallow;
+exports.markRaw = markRaw;
+exports.onScopeDispose = onScopeDispose;
+exports.pauseTracking = pauseTracking;
+exports.proxyRefs = proxyRefs;
+exports.reactive = reactive;
+exports.readonly = readonly;
+exports.ref = ref;
+exports.resetTracking = resetTracking;
+exports.shallowReactive = shallowReactive;
+exports.shallowReadonly = shallowReadonly;
+exports.shallowRef = shallowRef;
+exports.stop = stop;
+exports.toRaw = toRaw;
+exports.toRef = toRef;
+exports.toRefs = toRefs;
+exports.toValue = toValue;
+exports.track = track;
+exports.trigger = trigger;
+exports.triggerRef = triggerRef;
+exports.unref = unref;
diff --git a/.output/server/node_modules/@vue/reactivity/dist/reactivity.cjs.prod.js b/.output/server/node_modules/@vue/reactivity/dist/reactivity.cjs.prod.js
new file mode 100644
index 0000000..2d9c20e
--- /dev/null
+++ b/.output/server/node_modules/@vue/reactivity/dist/reactivity.cjs.prod.js
@@ -0,0 +1,1186 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('@vue/shared');
+
+let activeEffectScope;
+class EffectScope {
+ constructor(detached = false) {
+ this.detached = detached;
+ /**
+ * @internal
+ */
+ this._active = true;
+ /**
+ * @internal
+ */
+ this.effects = [];
+ /**
+ * @internal
+ */
+ this.cleanups = [];
+ this.parent = activeEffectScope;
+ if (!detached && activeEffectScope) {
+ this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+ this
+ ) - 1;
+ }
+ }
+ get active() {
+ return this._active;
+ }
+ run(fn) {
+ if (this._active) {
+ const currentEffectScope = activeEffectScope;
+ try {
+ activeEffectScope = this;
+ return fn();
+ } finally {
+ activeEffectScope = currentEffectScope;
+ }
+ }
+ }
+ /**
+ * This should only be called on non-detached scopes
+ * @internal
+ */
+ on() {
+ activeEffectScope = this;
+ }
+ /**
+ * This should only be called on non-detached scopes
+ * @internal
+ */
+ off() {
+ activeEffectScope = this.parent;
+ }
+ stop(fromParent) {
+ if (this._active) {
+ let i, l;
+ for (i = 0, l = this.effects.length; i < l; i++) {
+ this.effects[i].stop();
+ }
+ for (i = 0, l = this.cleanups.length; i < l; i++) {
+ this.cleanups[i]();
+ }
+ if (this.scopes) {
+ for (i = 0, l = this.scopes.length; i < l; i++) {
+ this.scopes[i].stop(true);
+ }
+ }
+ if (!this.detached && this.parent && !fromParent) {
+ const last = this.parent.scopes.pop();
+ if (last && last !== this) {
+ this.parent.scopes[this.index] = last;
+ last.index = this.index;
+ }
+ }
+ this.parent = void 0;
+ this._active = false;
+ }
+ }
+}
+function effectScope(detached) {
+ return new EffectScope(detached);
+}
+function recordEffectScope(effect, scope = activeEffectScope) {
+ if (scope && scope.active) {
+ scope.effects.push(effect);
+ }
+}
+function getCurrentScope() {
+ return activeEffectScope;
+}
+function onScopeDispose(fn) {
+ if (activeEffectScope) {
+ activeEffectScope.cleanups.push(fn);
+ }
+}
+
+const createDep = (effects) => {
+ const dep = new Set(effects);
+ dep.w = 0;
+ dep.n = 0;
+ return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const initDepMarkers = ({ deps }) => {
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].w |= trackOpBit;
+ }
+ }
+};
+const finalizeDepMarkers = (effect) => {
+ const { deps } = effect;
+ if (deps.length) {
+ let ptr = 0;
+ for (let i = 0; i < deps.length; i++) {
+ const dep = deps[i];
+ if (wasTracked(dep) && !newTracked(dep)) {
+ dep.delete(effect);
+ } else {
+ deps[ptr++] = dep;
+ }
+ dep.w &= ~trackOpBit;
+ dep.n &= ~trackOpBit;
+ }
+ deps.length = ptr;
+ }
+};
+
+const targetMap = /* @__PURE__ */ new WeakMap();
+let effectTrackDepth = 0;
+let trackOpBit = 1;
+const maxMarkerBits = 30;
+let activeEffect;
+const ITERATE_KEY = Symbol("");
+const MAP_KEY_ITERATE_KEY = Symbol("");
+class ReactiveEffect {
+ constructor(fn, scheduler = null, scope) {
+ this.fn = fn;
+ this.scheduler = scheduler;
+ this.active = true;
+ this.deps = [];
+ this.parent = void 0;
+ recordEffectScope(this, scope);
+ }
+ run() {
+ if (!this.active) {
+ return this.fn();
+ }
+ let parent = activeEffect;
+ let lastShouldTrack = shouldTrack;
+ while (parent) {
+ if (parent === this) {
+ return;
+ }
+ parent = parent.parent;
+ }
+ try {
+ this.parent = activeEffect;
+ activeEffect = this;
+ shouldTrack = true;
+ trackOpBit = 1 << ++effectTrackDepth;
+ if (effectTrackDepth <= maxMarkerBits) {
+ initDepMarkers(this);
+ } else {
+ cleanupEffect(this);
+ }
+ return this.fn();
+ } finally {
+ if (effectTrackDepth <= maxMarkerBits) {
+ finalizeDepMarkers(this);
+ }
+ trackOpBit = 1 << --effectTrackDepth;
+ activeEffect = this.parent;
+ shouldTrack = lastShouldTrack;
+ this.parent = void 0;
+ if (this.deferStop) {
+ this.stop();
+ }
+ }
+ }
+ stop() {
+ if (activeEffect === this) {
+ this.deferStop = true;
+ } else if (this.active) {
+ cleanupEffect(this);
+ if (this.onStop) {
+ this.onStop();
+ }
+ this.active = false;
+ }
+ }
+}
+function cleanupEffect(effect2) {
+ const { deps } = effect2;
+ if (deps.length) {
+ for (let i = 0; i < deps.length; i++) {
+ deps[i].delete(effect2);
+ }
+ deps.length = 0;
+ }
+}
+function effect(fn, options) {
+ if (fn.effect instanceof ReactiveEffect) {
+ fn = fn.effect.fn;
+ }
+ const _effect = new ReactiveEffect(fn);
+ if (options) {
+ shared.extend(_effect, options);
+ if (options.scope)
+ recordEffectScope(_effect, options.scope);
+ }
+ if (!options || !options.lazy) {
+ _effect.run();
+ }
+ const runner = _effect.run.bind(_effect);
+ runner.effect = _effect;
+ return runner;
+}
+function stop(runner) {
+ runner.effect.stop();
+}
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = false;
+}
+function enableTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = true;
+}
+function resetTracking() {
+ const last = trackStack.pop();
+ shouldTrack = last === void 0 ? true : last;
+}
+function track(target, type, key) {
+ if (shouldTrack && activeEffect) {
+ let depsMap = targetMap.get(target);
+ if (!depsMap) {
+ targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+ }
+ let dep = depsMap.get(key);
+ if (!dep) {
+ depsMap.set(key, dep = createDep());
+ }
+ trackEffects(dep);
+ }
+}
+function trackEffects(dep, debuggerEventExtraInfo) {
+ let shouldTrack2 = false;
+ if (effectTrackDepth <= maxMarkerBits) {
+ if (!newTracked(dep)) {
+ dep.n |= trackOpBit;
+ shouldTrack2 = !wasTracked(dep);
+ }
+ } else {
+ shouldTrack2 = !dep.has(activeEffect);
+ }
+ if (shouldTrack2) {
+ dep.add(activeEffect);
+ activeEffect.deps.push(dep);
+ }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+ const depsMap = targetMap.get(target);
+ if (!depsMap) {
+ return;
+ }
+ let deps = [];
+ if (type === "clear") {
+ deps = [...depsMap.values()];
+ } else if (key === "length" && shared.isArray(target)) {
+ const newLength = Number(newValue);
+ depsMap.forEach((dep, key2) => {
+ if (key2 === "length" || !shared.isSymbol(key2) && key2 >= newLength) {
+ deps.push(dep);
+ }
+ });
+ } else {
+ if (key !== void 0) {
+ deps.push(depsMap.get(key));
+ }
+ switch (type) {
+ case "add":
+ if (!shared.isArray(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ if (shared.isMap(target)) {
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ } else if (shared.isIntegerKey(key)) {
+ deps.push(depsMap.get("length"));
+ }
+ break;
+ case "delete":
+ if (!shared.isArray(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ if (shared.isMap(target)) {
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+ }
+ }
+ break;
+ case "set":
+ if (shared.isMap(target)) {
+ deps.push(depsMap.get(ITERATE_KEY));
+ }
+ break;
+ }
+ }
+ if (deps.length === 1) {
+ if (deps[0]) {
+ {
+ triggerEffects(deps[0]);
+ }
+ }
+ } else {
+ const effects = [];
+ for (const dep of deps) {
+ if (dep) {
+ effects.push(...dep);
+ }
+ }
+ {
+ triggerEffects(createDep(effects));
+ }
+ }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+ const effects = shared.isArray(dep) ? dep : [...dep];
+ for (const effect2 of effects) {
+ if (effect2.computed) {
+ triggerEffect(effect2);
+ }
+ }
+ for (const effect2 of effects) {
+ if (!effect2.computed) {
+ triggerEffect(effect2);
+ }
+ }
+}
+function triggerEffect(effect2, debuggerEventExtraInfo) {
+ if (effect2 !== activeEffect || effect2.allowRecurse) {
+ if (effect2.scheduler) {
+ effect2.scheduler();
+ } else {
+ effect2.run();
+ }
+ }
+}
+function getDepFromReactive(object, key) {
+ var _a;
+ return (_a = targetMap.get(object)) == null ? void 0 : _a.get(key);
+}
+
+const isNonTrackableKeys = /* @__PURE__ */ shared.makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+ /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(shared.isSymbol)
+);
+const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+function createArrayInstrumentations() {
+ const instrumentations = {};
+ ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+ instrumentations[key] = function(...args) {
+ const arr = toRaw(this);
+ for (let i = 0, l = this.length; i < l; i++) {
+ track(arr, "get", i + "");
+ }
+ const res = arr[key](...args);
+ if (res === -1 || res === false) {
+ return arr[key](...args.map(toRaw));
+ } else {
+ return res;
+ }
+ };
+ });
+ ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+ instrumentations[key] = function(...args) {
+ pauseTracking();
+ const res = toRaw(this)[key].apply(this, args);
+ resetTracking();
+ return res;
+ };
+ });
+ return instrumentations;
+}
+function hasOwnProperty(key) {
+ const obj = toRaw(this);
+ track(obj, "has", key);
+ return obj.hasOwnProperty(key);
+}
+class BaseReactiveHandler {
+ constructor(_isReadonly = false, _shallow = false) {
+ this._isReadonly = _isReadonly;
+ this._shallow = _shallow;
+ }
+ get(target, key, receiver) {
+ const isReadonly2 = this._isReadonly, shallow = this._shallow;
+ if (key === "__v_isReactive") {
+ return !isReadonly2;
+ } else if (key === "__v_isReadonly") {
+ return isReadonly2;
+ } else if (key === "__v_isShallow") {
+ return shallow;
+ } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
+ return target;
+ }
+ const targetIsArray = shared.isArray(target);
+ if (!isReadonly2) {
+ if (targetIsArray && shared.hasOwn(arrayInstrumentations, key)) {
+ return Reflect.get(arrayInstrumentations, key, receiver);
+ }
+ if (key === "hasOwnProperty") {
+ return hasOwnProperty;
+ }
+ }
+ const res = Reflect.get(target, key, receiver);
+ if (shared.isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+ return res;
+ }
+ if (!isReadonly2) {
+ track(target, "get", key);
+ }
+ if (shallow) {
+ return res;
+ }
+ if (isRef(res)) {
+ return targetIsArray && shared.isIntegerKey(key) ? res : res.value;
+ }
+ if (shared.isObject(res)) {
+ return isReadonly2 ? readonly(res) : reactive(res);
+ }
+ return res;
+ }
+}
+class MutableReactiveHandler extends BaseReactiveHandler {
+ constructor(shallow = false) {
+ super(false, shallow);
+ }
+ set(target, key, value, receiver) {
+ let oldValue = target[key];
+ if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
+ return false;
+ }
+ if (!this._shallow) {
+ if (!isShallow(value) && !isReadonly(value)) {
+ oldValue = toRaw(oldValue);
+ value = toRaw(value);
+ }
+ if (!shared.isArray(target) && isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ }
+ }
+ const hadKey = shared.isArray(target) && shared.isIntegerKey(key) ? Number(key) < target.length : shared.hasOwn(target, key);
+ const result = Reflect.set(target, key, value, receiver);
+ if (target === toRaw(receiver)) {
+ if (!hadKey) {
+ trigger(target, "add", key, value);
+ } else if (shared.hasChanged(value, oldValue)) {
+ trigger(target, "set", key, value);
+ }
+ }
+ return result;
+ }
+ deleteProperty(target, key) {
+ const hadKey = shared.hasOwn(target, key);
+ target[key];
+ const result = Reflect.deleteProperty(target, key);
+ if (result && hadKey) {
+ trigger(target, "delete", key, void 0);
+ }
+ return result;
+ }
+ has(target, key) {
+ const result = Reflect.has(target, key);
+ if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
+ track(target, "has", key);
+ }
+ return result;
+ }
+ ownKeys(target) {
+ track(
+ target,
+ "iterate",
+ shared.isArray(target) ? "length" : ITERATE_KEY
+ );
+ return Reflect.ownKeys(target);
+ }
+}
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+ constructor(shallow = false) {
+ super(true, shallow);
+ }
+ set(target, key) {
+ return true;
+ }
+ deleteProperty(target, key) {
+ return true;
+ }
+}
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
+ true
+);
+const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get(target, key, isReadonly = false, isShallow = false) {
+ target = target["__v_raw"];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (!isReadonly) {
+ if (shared.hasChanged(key, rawKey)) {
+ track(rawTarget, "get", key);
+ }
+ track(rawTarget, "get", rawKey);
+ }
+ const { has: has2 } = getProto(rawTarget);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ if (has2.call(rawTarget, key)) {
+ return wrap(target.get(key));
+ } else if (has2.call(rawTarget, rawKey)) {
+ return wrap(target.get(rawKey));
+ } else if (target !== rawTarget) {
+ target.get(key);
+ }
+}
+function has(key, isReadonly = false) {
+ const target = this["__v_raw"];
+ const rawTarget = toRaw(target);
+ const rawKey = toRaw(key);
+ if (!isReadonly) {
+ if (shared.hasChanged(key, rawKey)) {
+ track(rawTarget, "has", key);
+ }
+ track(rawTarget, "has", rawKey);
+ }
+ return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+}
+function size(target, isReadonly = false) {
+ target = target["__v_raw"];
+ !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
+ return Reflect.get(target, "size", target);
+}
+function add(value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const proto = getProto(target);
+ const hadKey = proto.has.call(target, value);
+ if (!hadKey) {
+ target.add(value);
+ trigger(target, "add", value, value);
+ }
+ return this;
+}
+function set(key, value) {
+ value = toRaw(value);
+ const target = toRaw(this);
+ const { has: has2, get: get2 } = getProto(target);
+ let hadKey = has2.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has2.call(target, key);
+ }
+ const oldValue = get2.call(target, key);
+ target.set(key, value);
+ if (!hadKey) {
+ trigger(target, "add", key, value);
+ } else if (shared.hasChanged(value, oldValue)) {
+ trigger(target, "set", key, value);
+ }
+ return this;
+}
+function deleteEntry(key) {
+ const target = toRaw(this);
+ const { has: has2, get: get2 } = getProto(target);
+ let hadKey = has2.call(target, key);
+ if (!hadKey) {
+ key = toRaw(key);
+ hadKey = has2.call(target, key);
+ }
+ get2 ? get2.call(target, key) : void 0;
+ const result = target.delete(key);
+ if (hadKey) {
+ trigger(target, "delete", key, void 0);
+ }
+ return result;
+}
+function clear() {
+ const target = toRaw(this);
+ const hadItems = target.size !== 0;
+ const result = target.clear();
+ if (hadItems) {
+ trigger(target, "clear", void 0, void 0);
+ }
+ return result;
+}
+function createForEach(isReadonly, isShallow) {
+ return function forEach(callback, thisArg) {
+ const observed = this;
+ const target = observed["__v_raw"];
+ const rawTarget = toRaw(target);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
+ return target.forEach((value, key) => {
+ return callback.call(thisArg, wrap(value), wrap(key), observed);
+ });
+ };
+}
+function createIterableMethod(method, isReadonly, isShallow) {
+ return function(...args) {
+ const target = this["__v_raw"];
+ const rawTarget = toRaw(target);
+ const targetIsMap = shared.isMap(rawTarget);
+ const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+ const isKeyOnly = method === "keys" && targetIsMap;
+ const innerIterator = target[method](...args);
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+ !isReadonly && track(
+ rawTarget,
+ "iterate",
+ isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
+ );
+ return {
+ // iterator protocol
+ next() {
+ const { value, done } = innerIterator.next();
+ return done ? { value, done } : {
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+ done
+ };
+ },
+ // iterable protocol
+ [Symbol.iterator]() {
+ return this;
+ }
+ };
+ };
+}
+function createReadonlyMethod(type) {
+ return function(...args) {
+ return type === "delete" ? false : type === "clear" ? void 0 : this;
+ };
+}
+function createInstrumentations() {
+ const mutableInstrumentations2 = {
+ get(key) {
+ return get(this, key);
+ },
+ get size() {
+ return size(this);
+ },
+ has,
+ add,
+ set,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, false)
+ };
+ const shallowInstrumentations2 = {
+ get(key) {
+ return get(this, key, false, true);
+ },
+ get size() {
+ return size(this);
+ },
+ has,
+ add,
+ set,
+ delete: deleteEntry,
+ clear,
+ forEach: createForEach(false, true)
+ };
+ const readonlyInstrumentations2 = {
+ get(key) {
+ return get(this, key, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has.call(this, key, true);
+ },
+ add: createReadonlyMethod("add"),
+ set: createReadonlyMethod("set"),
+ delete: createReadonlyMethod("delete"),
+ clear: createReadonlyMethod("clear"),
+ forEach: createForEach(true, false)
+ };
+ const shallowReadonlyInstrumentations2 = {
+ get(key) {
+ return get(this, key, true, true);
+ },
+ get size() {
+ return size(this, true);
+ },
+ has(key) {
+ return has.call(this, key, true);
+ },
+ add: createReadonlyMethod("add"),
+ set: createReadonlyMethod("set"),
+ delete: createReadonlyMethod("delete"),
+ clear: createReadonlyMethod("clear"),
+ forEach: createForEach(true, true)
+ };
+ const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+ iteratorMethods.forEach((method) => {
+ mutableInstrumentations2[method] = createIterableMethod(
+ method,
+ false,
+ false
+ );
+ readonlyInstrumentations2[method] = createIterableMethod(
+ method,
+ true,
+ false
+ );
+ shallowInstrumentations2[method] = createIterableMethod(
+ method,
+ false,
+ true
+ );
+ shallowReadonlyInstrumentations2[method] = createIterableMethod(
+ method,
+ true,
+ true
+ );
+ });
+ return [
+ mutableInstrumentations2,
+ readonlyInstrumentations2,
+ shallowInstrumentations2,
+ shallowReadonlyInstrumentations2
+ ];
+}
+const [
+ mutableInstrumentations,
+ readonlyInstrumentations,
+ shallowInstrumentations,
+ shallowReadonlyInstrumentations
+] = /* @__PURE__ */ createInstrumentations();
+function createInstrumentationGetter(isReadonly, shallow) {
+ const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
+ return (target, key, receiver) => {
+ if (key === "__v_isReactive") {
+ return !isReadonly;
+ } else if (key === "__v_isReadonly") {
+ return isReadonly;
+ } else if (key === "__v_raw") {
+ return target;
+ }
+ return Reflect.get(
+ shared.hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+ key,
+ receiver
+ );
+ };
+}
+const mutableCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const shallowCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(false, true)
+};
+const readonlyCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+const shallowReadonlyCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
+
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+ switch (rawType) {
+ case "Object":
+ case "Array":
+ return 1 /* COMMON */;
+ case "Map":
+ case "Set":
+ case "WeakMap":
+ case "WeakSet":
+ return 2 /* COLLECTION */;
+ default:
+ return 0 /* INVALID */;
+ }
+}
+function getTargetType(value) {
+ return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(shared.toRawType(value));
+}
+function reactive(target) {
+ if (isReadonly(target)) {
+ return target;
+ }
+ return createReactiveObject(
+ target,
+ false,
+ mutableHandlers,
+ mutableCollectionHandlers,
+ reactiveMap
+ );
+}
+function shallowReactive(target) {
+ return createReactiveObject(
+ target,
+ false,
+ shallowReactiveHandlers,
+ shallowCollectionHandlers,
+ shallowReactiveMap
+ );
+}
+function readonly(target) {
+ return createReactiveObject(
+ target,
+ true,
+ readonlyHandlers,
+ readonlyCollectionHandlers,
+ readonlyMap
+ );
+}
+function shallowReadonly(target) {
+ return createReactiveObject(
+ target,
+ true,
+ shallowReadonlyHandlers,
+ shallowReadonlyCollectionHandlers,
+ shallowReadonlyMap
+ );
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+ if (!shared.isObject(target)) {
+ return target;
+ }
+ if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+ return target;
+ }
+ const existingProxy = proxyMap.get(target);
+ if (existingProxy) {
+ return existingProxy;
+ }
+ const targetType = getTargetType(target);
+ if (targetType === 0 /* INVALID */) {
+ return target;
+ }
+ const proxy = new Proxy(
+ target,
+ targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
+ );
+ proxyMap.set(target, proxy);
+ return proxy;
+}
+function isReactive(value) {
+ if (isReadonly(value)) {
+ return isReactive(value["__v_raw"]);
+ }
+ return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+ return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+ return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+ return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+ const raw = observed && observed["__v_raw"];
+ return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+ shared.def(value, "__v_skip", true);
+ return value;
+}
+const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => shared.isObject(value) ? readonly(value) : value;
+
+function trackRefValue(ref2) {
+ if (shouldTrack && activeEffect) {
+ ref2 = toRaw(ref2);
+ {
+ trackEffects(ref2.dep || (ref2.dep = createDep()));
+ }
+ }
+}
+function triggerRefValue(ref2, newVal) {
+ ref2 = toRaw(ref2);
+ const dep = ref2.dep;
+ if (dep) {
+ {
+ triggerEffects(dep);
+ }
+ }
+}
+function isRef(r) {
+ return !!(r && r.__v_isRef === true);
+}
+function ref(value) {
+ return createRef(value, false);
+}
+function shallowRef(value) {
+ return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+ if (isRef(rawValue)) {
+ return rawValue;
+ }
+ return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+ constructor(value, __v_isShallow) {
+ this.__v_isShallow = __v_isShallow;
+ this.dep = void 0;
+ this.__v_isRef = true;
+ this._rawValue = __v_isShallow ? value : toRaw(value);
+ this._value = __v_isShallow ? value : toReactive(value);
+ }
+ get value() {
+ trackRefValue(this);
+ return this._value;
+ }
+ set value(newVal) {
+ const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+ newVal = useDirectValue ? newVal : toRaw(newVal);
+ if (shared.hasChanged(newVal, this._rawValue)) {
+ this._rawValue = newVal;
+ this._value = useDirectValue ? newVal : toReactive(newVal);
+ triggerRefValue(this);
+ }
+ }
+}
+function triggerRef(ref2) {
+ triggerRefValue(ref2);
+}
+function unref(ref2) {
+ return isRef(ref2) ? ref2.value : ref2;
+}
+function toValue(source) {
+ return shared.isFunction(source) ? source() : unref(source);
+}
+const shallowUnwrapHandlers = {
+ get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+ set: (target, key, value, receiver) => {
+ const oldValue = target[key];
+ if (isRef(oldValue) && !isRef(value)) {
+ oldValue.value = value;
+ return true;
+ } else {
+ return Reflect.set(target, key, value, receiver);
+ }
+ }
+};
+function proxyRefs(objectWithRefs) {
+ return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+class CustomRefImpl {
+ constructor(factory) {
+ this.dep = void 0;
+ this.__v_isRef = true;
+ const { get, set } = factory(
+ () => trackRefValue(this),
+ () => triggerRefValue(this)
+ );
+ this._get = get;
+ this._set = set;
+ }
+ get value() {
+ return this._get();
+ }
+ set value(newVal) {
+ this._set(newVal);
+ }
+}
+function customRef(factory) {
+ return new CustomRefImpl(factory);
+}
+function toRefs(object) {
+ const ret = shared.isArray(object) ? new Array(object.length) : {};
+ for (const key in object) {
+ ret[key] = propertyToRef(object, key);
+ }
+ return ret;
+}
+class ObjectRefImpl {
+ constructor(_object, _key, _defaultValue) {
+ this._object = _object;
+ this._key = _key;
+ this._defaultValue = _defaultValue;
+ this.__v_isRef = true;
+ }
+ get value() {
+ const val = this._object[this._key];
+ return val === void 0 ? this._defaultValue : val;
+ }
+ set value(newVal) {
+ this._object[this._key] = newVal;
+ }
+ get dep() {
+ return getDepFromReactive(toRaw(this._object), this._key);
+ }
+}
+class GetterRefImpl {
+ constructor(_getter) {
+ this._getter = _getter;
+ this.__v_isRef = true;
+ this.__v_isReadonly = true;
+ }
+ get value() {
+ return this._getter();
+ }
+}
+function toRef(source, key, defaultValue) {
+ if (isRef(source)) {
+ return source;
+ } else if (shared.isFunction(source)) {
+ return new GetterRefImpl(source);
+ } else if (shared.isObject(source) && arguments.length > 1) {
+ return propertyToRef(source, key, defaultValue);
+ } else {
+ return ref(source);
+ }
+}
+function propertyToRef(source, key, defaultValue) {
+ const val = source[key];
+ return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
+}
+
+class ComputedRefImpl {
+ constructor(getter, _setter, isReadonly, isSSR) {
+ this._setter = _setter;
+ this.dep = void 0;
+ this.__v_isRef = true;
+ this["__v_isReadonly"] = false;
+ this._dirty = true;
+ this.effect = new ReactiveEffect(getter, () => {
+ if (!this._dirty) {
+ this._dirty = true;
+ triggerRefValue(this);
+ }
+ });
+ this.effect.computed = this;
+ this.effect.active = this._cacheable = !isSSR;
+ this["__v_isReadonly"] = isReadonly;
+ }
+ get value() {
+ const self = toRaw(this);
+ trackRefValue(self);
+ if (self._dirty || !self._cacheable) {
+ self._dirty = false;
+ self._value = self.effect.run();
+ }
+ return self._value;
+ }
+ set value(newValue) {
+ this._setter(newValue);
+ }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+ let getter;
+ let setter;
+ const onlyGetter = shared.isFunction(getterOrOptions);
+ if (onlyGetter) {
+ getter = getterOrOptions;
+ setter = shared.NOOP;
+ } else {
+ getter = getterOrOptions.get;
+ setter = getterOrOptions.set;
+ }
+ const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+ return cRef;
+}
+
+const tick = /* @__PURE__ */ Promise.resolve();
+const queue = [];
+let queued = false;
+const scheduler = (fn) => {
+ queue.push(fn);
+ if (!queued) {
+ queued = true;
+ tick.then(flush);
+ }
+};
+const flush = () => {
+ for (let i = 0; i < queue.length; i++) {
+ queue[i]();
+ }
+ queue.length = 0;
+ queued = false;
+};
+class DeferredComputedRefImpl {
+ constructor(getter) {
+ this.dep = void 0;
+ this._dirty = true;
+ this.__v_isRef = true;
+ this["__v_isReadonly"] = true;
+ let compareTarget;
+ let hasCompareTarget = false;
+ let scheduled = false;
+ this.effect = new ReactiveEffect(getter, (computedTrigger) => {
+ if (this.dep) {
+ if (computedTrigger) {
+ compareTarget = this._value;
+ hasCompareTarget = true;
+ } else if (!scheduled) {
+ const valueToCompare = hasCompareTarget ? compareTarget : this._value;
+ scheduled = true;
+ hasCompareTarget = false;
+ scheduler(() => {
+ if (this.effect.active && this._get() !== valueToCompare) {
+ triggerRefValue(this);
+ }
+ scheduled = false;
+ });
+ }
+ for (const e of this.dep) {
+ if (e.computed instanceof DeferredComputedRefImpl) {
+ e.scheduler(
+ true
+ /* computedTrigger */
+ );
+ }
+ }
+ }
+ this._dirty = true;
+ });
+ this.effect.computed = this;
+ }
+ _get() {
+ if (this._dirty) {
+ this._dirty = false;
+ return this._value = this.effect.run();
+ }
+ return this._value;
+ }
+ get value() {
+ trackRefValue(this);
+ return toRaw(this)._get();
+ }
+}
+function deferredComputed(getter) {
+ return new DeferredComputedRefImpl(getter);
+}
+
+exports.EffectScope = EffectScope;
+exports.ITERATE_KEY = ITERATE_KEY;
+exports.ReactiveEffect = ReactiveEffect;
+exports.computed = computed;
+exports.customRef = customRef;
+exports.deferredComputed = deferredComputed;
+exports.effect = effect;
+exports.effectScope = effectScope;
+exports.enableTracking = enableTracking;
+exports.getCurrentScope = getCurrentScope;
+exports.isProxy = isProxy;
+exports.isReactive = isReactive;
+exports.isReadonly = isReadonly;
+exports.isRef = isRef;
+exports.isShallow = isShallow;
+exports.markRaw = markRaw;
+exports.onScopeDispose = onScopeDispose;
+exports.pauseTracking = pauseTracking;
+exports.proxyRefs = proxyRefs;
+exports.reactive = reactive;
+exports.readonly = readonly;
+exports.ref = ref;
+exports.resetTracking = resetTracking;
+exports.shallowReactive = shallowReactive;
+exports.shallowReadonly = shallowReadonly;
+exports.shallowRef = shallowRef;
+exports.stop = stop;
+exports.toRaw = toRaw;
+exports.toRef = toRef;
+exports.toRefs = toRefs;
+exports.toValue = toValue;
+exports.track = track;
+exports.trigger = trigger;
+exports.triggerRef = triggerRef;
+exports.unref = unref;
diff --git a/.output/server/node_modules/@vue/runtime-core/dist/runtime-core.cjs.js b/.output/server/node_modules/@vue/runtime-core/dist/runtime-core.cjs.js
new file mode 100644
index 0000000..be5e426
--- /dev/null
+++ b/.output/server/node_modules/@vue/runtime-core/dist/runtime-core.cjs.js
@@ -0,0 +1,7901 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactivity = require('@vue/reactivity');
+var shared = require('@vue/shared');
+
+const stack = [];
+function pushWarningContext(vnode) {
+ stack.push(vnode);
+}
+function popWarningContext() {
+ stack.pop();
+}
+function warn(msg, ...args) {
+ reactivity.pauseTracking();
+ const instance = stack.length ? stack[stack.length - 1].component : null;
+ const appWarnHandler = instance && instance.appContext.config.warnHandler;
+ const trace = getComponentTrace();
+ if (appWarnHandler) {
+ callWithErrorHandling(
+ appWarnHandler,
+ instance,
+ 11,
+ [
+ msg + args.join(""),
+ instance && instance.proxy,
+ trace.map(
+ ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+ ).join("\n"),
+ trace
+ ]
+ );
+ } else {
+ const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+ if (trace.length && // avoid spamming console during tests
+ true) {
+ warnArgs.push(`
+`, ...formatTrace(trace));
+ }
+ console.warn(...warnArgs);
+ }
+ reactivity.resetTracking();
+}
+function getComponentTrace() {
+ let currentVNode = stack[stack.length - 1];
+ if (!currentVNode) {
+ return [];
+ }
+ const normalizedStack = [];
+ while (currentVNode) {
+ const last = normalizedStack[0];
+ if (last && last.vnode === currentVNode) {
+ last.recurseCount++;
+ } else {
+ normalizedStack.push({
+ vnode: currentVNode,
+ recurseCount: 0
+ });
+ }
+ const parentInstance = currentVNode.component && currentVNode.component.parent;
+ currentVNode = parentInstance && parentInstance.vnode;
+ }
+ return normalizedStack;
+}
+function formatTrace(trace) {
+ const logs = [];
+ trace.forEach((entry, i) => {
+ logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+ });
+ return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+ const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+ const isRoot = vnode.component ? vnode.component.parent == null : false;
+ const open = ` at <${formatComponentName(
+ vnode.component,
+ vnode.type,
+ isRoot
+ )}`;
+ const close = `>` + postfix;
+ return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+ const res = [];
+ const keys = Object.keys(props);
+ keys.slice(0, 3).forEach((key) => {
+ res.push(...formatProp(key, props[key]));
+ });
+ if (keys.length > 3) {
+ res.push(` ...`);
+ }
+ return res;
+}
+function formatProp(key, value, raw) {
+ if (shared.isString(value)) {
+ value = JSON.stringify(value);
+ return raw ? value : [`${key}=${value}`];
+ } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+ return raw ? value : [`${key}=${value}`];
+ } else if (reactivity.isRef(value)) {
+ value = formatProp(key, reactivity.toRaw(value.value), true);
+ return raw ? value : [`${key}=Ref<`, value, `>`];
+ } else if (shared.isFunction(value)) {
+ return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+ } else {
+ value = reactivity.toRaw(value);
+ return raw ? value : [`${key}=`, value];
+ }
+}
+function assertNumber(val, type) {
+ if (val === void 0) {
+ return;
+ } else if (typeof val !== "number") {
+ warn(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
+ } else if (isNaN(val)) {
+ warn(`${type} is NaN - the duration expression might be incorrect.`);
+ }
+}
+
+const ErrorTypeStrings = {
+ ["sp"]: "serverPrefetch hook",
+ ["bc"]: "beforeCreate hook",
+ ["c"]: "created hook",
+ ["bm"]: "beforeMount hook",
+ ["m"]: "mounted hook",
+ ["bu"]: "beforeUpdate hook",
+ ["u"]: "updated",
+ ["bum"]: "beforeUnmount hook",
+ ["um"]: "unmounted hook",
+ ["a"]: "activated hook",
+ ["da"]: "deactivated hook",
+ ["ec"]: "errorCaptured hook",
+ ["rtc"]: "renderTracked hook",
+ ["rtg"]: "renderTriggered hook",
+ [0]: "setup function",
+ [1]: "render function",
+ [2]: "watcher getter",
+ [3]: "watcher callback",
+ [4]: "watcher cleanup function",
+ [5]: "native event handler",
+ [6]: "component event handler",
+ [7]: "vnode hook",
+ [8]: "directive hook",
+ [9]: "transition hook",
+ [10]: "app errorHandler",
+ [11]: "app warnHandler",
+ [12]: "ref function",
+ [13]: "async component loader",
+ [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+ let res;
+ try {
+ res = args ? fn(...args) : fn();
+ } catch (err) {
+ handleError(err, instance, type);
+ }
+ return res;
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+ if (shared.isFunction(fn)) {
+ const res = callWithErrorHandling(fn, instance, type, args);
+ if (res && shared.isPromise(res)) {
+ res.catch((err) => {
+ handleError(err, instance, type);
+ });
+ }
+ return res;
+ }
+ const values = [];
+ for (let i = 0; i < fn.length; i++) {
+ values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+ }
+ return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+ const contextVNode = instance ? instance.vnode : null;
+ if (instance) {
+ let cur = instance.parent;
+ const exposedInstance = instance.proxy;
+ const errorInfo = ErrorTypeStrings[type] ;
+ while (cur) {
+ const errorCapturedHooks = cur.ec;
+ if (errorCapturedHooks) {
+ for (let i = 0; i < errorCapturedHooks.length; i++) {
+ if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+ return;
+ }
+ }
+ }
+ cur = cur.parent;
+ }
+ const appErrorHandler = instance.appContext.config.errorHandler;
+ if (appErrorHandler) {
+ callWithErrorHandling(
+ appErrorHandler,
+ null,
+ 10,
+ [err, exposedInstance, errorInfo]
+ );
+ return;
+ }
+ }
+ logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+ {
+ const info = ErrorTypeStrings[type];
+ if (contextVNode) {
+ pushWarningContext(contextVNode);
+ }
+ warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+ if (contextVNode) {
+ popWarningContext();
+ }
+ if (throwInDev) {
+ throw err;
+ } else {
+ console.error(err);
+ }
+ }
+}
+
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+const RECURSION_LIMIT = 100;
+function nextTick(fn) {
+ const p = currentFlushPromise || resolvedPromise;
+ return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(id) {
+ let start = flushIndex + 1;
+ let end = queue.length;
+ while (start < end) {
+ const middle = start + end >>> 1;
+ const middleJob = queue[middle];
+ const middleJobId = getId(middleJob);
+ if (middleJobId < id || middleJobId === id && middleJob.pre) {
+ start = middle + 1;
+ } else {
+ end = middle;
+ }
+ }
+ return start;
+}
+function queueJob(job) {
+ if (!queue.length || !queue.includes(
+ job,
+ isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
+ )) {
+ if (job.id == null) {
+ queue.push(job);
+ } else {
+ queue.splice(findInsertionIndex(job.id), 0, job);
+ }
+ queueFlush();
+ }
+}
+function queueFlush() {
+ if (!isFlushing && !isFlushPending) {
+ isFlushPending = true;
+ currentFlushPromise = resolvedPromise.then(flushJobs);
+ }
+}
+function invalidateJob(job) {
+ const i = queue.indexOf(job);
+ if (i > flushIndex) {
+ queue.splice(i, 1);
+ }
+}
+function queuePostFlushCb(cb) {
+ if (!shared.isArray(cb)) {
+ if (!activePostFlushCbs || !activePostFlushCbs.includes(
+ cb,
+ cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
+ )) {
+ pendingPostFlushCbs.push(cb);
+ }
+ } else {
+ pendingPostFlushCbs.push(...cb);
+ }
+ queueFlush();
+}
+function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
+ {
+ seen = seen || /* @__PURE__ */ new Map();
+ }
+ for (; i < queue.length; i++) {
+ const cb = queue[i];
+ if (cb && cb.pre) {
+ if (checkRecursiveUpdates(seen, cb)) {
+ continue;
+ }
+ queue.splice(i, 1);
+ i--;
+ cb();
+ }
+ }
+}
+function flushPostFlushCbs(seen) {
+ if (pendingPostFlushCbs.length) {
+ const deduped = [...new Set(pendingPostFlushCbs)];
+ pendingPostFlushCbs.length = 0;
+ if (activePostFlushCbs) {
+ activePostFlushCbs.push(...deduped);
+ return;
+ }
+ activePostFlushCbs = deduped;
+ {
+ seen = seen || /* @__PURE__ */ new Map();
+ }
+ activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+ for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+ if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+ continue;
+ }
+ activePostFlushCbs[postFlushIndex]();
+ }
+ activePostFlushCbs = null;
+ postFlushIndex = 0;
+ }
+}
+const getId = (job) => job.id == null ? Infinity : job.id;
+const comparator = (a, b) => {
+ const diff = getId(a) - getId(b);
+ if (diff === 0) {
+ if (a.pre && !b.pre)
+ return -1;
+ if (b.pre && !a.pre)
+ return 1;
+ }
+ return diff;
+};
+function flushJobs(seen) {
+ isFlushPending = false;
+ isFlushing = true;
+ {
+ seen = seen || /* @__PURE__ */ new Map();
+ }
+ queue.sort(comparator);
+ const check = (job) => checkRecursiveUpdates(seen, job) ;
+ try {
+ for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+ const job = queue[flushIndex];
+ if (job && job.active !== false) {
+ if (check(job)) {
+ continue;
+ }
+ callWithErrorHandling(job, null, 14);
+ }
+ }
+ } finally {
+ flushIndex = 0;
+ queue.length = 0;
+ flushPostFlushCbs(seen);
+ isFlushing = false;
+ currentFlushPromise = null;
+ if (queue.length || pendingPostFlushCbs.length) {
+ flushJobs(seen);
+ }
+ }
+}
+function checkRecursiveUpdates(seen, fn) {
+ if (!seen.has(fn)) {
+ seen.set(fn, 1);
+ } else {
+ const count = seen.get(fn);
+ if (count > RECURSION_LIMIT) {
+ const instance = fn.ownerInstance;
+ const componentName = instance && getComponentName(instance.type);
+ warn(
+ `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.`
+ );
+ return true;
+ } else {
+ seen.set(fn, count + 1);
+ }
+ }
+}
+
+let isHmrUpdating = false;
+const hmrDirtyComponents = /* @__PURE__ */ new Set();
+{
+ shared.getGlobalThis().__VUE_HMR_RUNTIME__ = {
+ createRecord: tryWrap(createRecord),
+ rerender: tryWrap(rerender),
+ reload: tryWrap(reload)
+ };
+}
+const map = /* @__PURE__ */ new Map();
+function registerHMR(instance) {
+ const id = instance.type.__hmrId;
+ let record = map.get(id);
+ if (!record) {
+ createRecord(id, instance.type);
+ record = map.get(id);
+ }
+ record.instances.add(instance);
+}
+function unregisterHMR(instance) {
+ map.get(instance.type.__hmrId).instances.delete(instance);
+}
+function createRecord(id, initialDef) {
+ if (map.has(id)) {
+ return false;
+ }
+ map.set(id, {
+ initialDef: normalizeClassComponent(initialDef),
+ instances: /* @__PURE__ */ new Set()
+ });
+ return true;
+}
+function normalizeClassComponent(component) {
+ return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+ const record = map.get(id);
+ if (!record) {
+ return;
+ }
+ record.initialDef.render = newRender;
+ [...record.instances].forEach((instance) => {
+ if (newRender) {
+ instance.render = newRender;
+ normalizeClassComponent(instance.type).render = newRender;
+ }
+ instance.renderCache = [];
+ isHmrUpdating = true;
+ instance.update();
+ isHmrUpdating = false;
+ });
+}
+function reload(id, newComp) {
+ const record = map.get(id);
+ if (!record)
+ return;
+ newComp = normalizeClassComponent(newComp);
+ updateComponentDef(record.initialDef, newComp);
+ const instances = [...record.instances];
+ for (const instance of instances) {
+ const oldComp = normalizeClassComponent(instance.type);
+ if (!hmrDirtyComponents.has(oldComp)) {
+ if (oldComp !== record.initialDef) {
+ updateComponentDef(oldComp, newComp);
+ }
+ hmrDirtyComponents.add(oldComp);
+ }
+ instance.appContext.propsCache.delete(instance.type);
+ instance.appContext.emitsCache.delete(instance.type);
+ instance.appContext.optionsCache.delete(instance.type);
+ if (instance.ceReload) {
+ hmrDirtyComponents.add(oldComp);
+ instance.ceReload(newComp.styles);
+ hmrDirtyComponents.delete(oldComp);
+ } else if (instance.parent) {
+ queueJob(instance.parent.update);
+ } else if (instance.appContext.reload) {
+ instance.appContext.reload();
+ } else if (typeof window !== "undefined") {
+ window.location.reload();
+ } else {
+ console.warn(
+ "[HMR] Root or manually mounted instance modified. Full reload required."
+ );
+ }
+ }
+ queuePostFlushCb(() => {
+ for (const instance of instances) {
+ hmrDirtyComponents.delete(
+ normalizeClassComponent(instance.type)
+ );
+ }
+ });
+}
+function updateComponentDef(oldComp, newComp) {
+ shared.extend(oldComp, newComp);
+ for (const key in oldComp) {
+ if (key !== "__file" && !(key in newComp)) {
+ delete oldComp[key];
+ }
+ }
+}
+function tryWrap(fn) {
+ return (id, arg) => {
+ try {
+ return fn(id, arg);
+ } catch (e) {
+ console.error(e);
+ console.warn(
+ `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+ );
+ }
+ };
+}
+
+exports.devtools = void 0;
+let buffer = [];
+let devtoolsNotInstalled = false;
+function emit$1(event, ...args) {
+ if (exports.devtools) {
+ exports.devtools.emit(event, ...args);
+ } else if (!devtoolsNotInstalled) {
+ buffer.push({ event, args });
+ }
+}
+function setDevtoolsHook(hook, target) {
+ var _a, _b;
+ exports.devtools = hook;
+ if (exports.devtools) {
+ exports.devtools.enabled = true;
+ buffer.forEach(({ event, args }) => exports.devtools.emit(event, ...args));
+ buffer = [];
+ } else if (
+ // handle late devtools injection - only do this if we are in an actual
+ // browser environment to avoid the timer handle stalling test runner exit
+ // (#4815)
+ typeof window !== "undefined" && // some envs mock window but not fully
+ window.HTMLElement && // also exclude jsdom
+ !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
+ ) {
+ const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+ replay.push((newHook) => {
+ setDevtoolsHook(newHook, target);
+ });
+ setTimeout(() => {
+ if (!exports.devtools) {
+ target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+ devtoolsNotInstalled = true;
+ buffer = [];
+ }
+ }, 3e3);
+ } else {
+ devtoolsNotInstalled = true;
+ buffer = [];
+ }
+}
+function devtoolsInitApp(app, version) {
+ emit$1("app:init" /* APP_INIT */, app, version, {
+ Fragment,
+ Text,
+ Comment,
+ Static
+ });
+}
+function devtoolsUnmountApp(app) {
+ emit$1("app:unmount" /* APP_UNMOUNT */, app);
+}
+const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
+ "component:added" /* COMPONENT_ADDED */
+);
+const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
+const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
+ "component:removed" /* COMPONENT_REMOVED */
+);
+const devtoolsComponentRemoved = (component) => {
+ if (exports.devtools && typeof exports.devtools.cleanupBuffer === "function" && // remove the component if it wasn't buffered
+ !exports.devtools.cleanupBuffer(component)) {
+ _devtoolsComponentRemoved(component);
+ }
+};
+function createDevtoolsComponentHook(hook) {
+ return (component) => {
+ emit$1(
+ hook,
+ component.appContext.app,
+ component.uid,
+ component.parent ? component.parent.uid : void 0,
+ component
+ );
+ };
+}
+const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
+ "perf:start" /* PERFORMANCE_START */
+);
+const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
+ "perf:end" /* PERFORMANCE_END */
+);
+function createDevtoolsPerformanceHook(hook) {
+ return (component, type, time) => {
+ emit$1(hook, component.appContext.app, component.uid, component, type, time);
+ };
+}
+function devtoolsComponentEmit(component, event, params) {
+ emit$1(
+ "component:emit" /* COMPONENT_EMIT */,
+ component.appContext.app,
+ component,
+ event,
+ params
+ );
+}
+
+function emit(instance, event, ...rawArgs) {
+ if (instance.isUnmounted)
+ return;
+ const props = instance.vnode.props || shared.EMPTY_OBJ;
+ {
+ const {
+ emitsOptions,
+ propsOptions: [propsOptions]
+ } = instance;
+ if (emitsOptions) {
+ if (!(event in emitsOptions) && true) {
+ if (!propsOptions || !(shared.toHandlerKey(event) in propsOptions)) {
+ warn(
+ `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${shared.toHandlerKey(event)}" prop.`
+ );
+ }
+ } else {
+ const validator = emitsOptions[event];
+ if (shared.isFunction(validator)) {
+ const isValid = validator(...rawArgs);
+ if (!isValid) {
+ warn(
+ `Invalid event arguments: event validation failed for event "${event}".`
+ );
+ }
+ }
+ }
+ }
+ }
+ let args = rawArgs;
+ const isModelListener = event.startsWith("update:");
+ const modelArg = isModelListener && event.slice(7);
+ if (modelArg && modelArg in props) {
+ const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
+ const { number, trim } = props[modifiersKey] || shared.EMPTY_OBJ;
+ if (trim) {
+ args = rawArgs.map((a) => shared.isString(a) ? a.trim() : a);
+ }
+ if (number) {
+ args = rawArgs.map(shared.looseToNumber);
+ }
+ }
+ {
+ devtoolsComponentEmit(instance, event, args);
+ }
+ {
+ const lowerCaseEvent = event.toLowerCase();
+ if (lowerCaseEvent !== event && props[shared.toHandlerKey(lowerCaseEvent)]) {
+ warn(
+ `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
+ instance,
+ instance.type
+ )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${shared.hyphenate(event)}" instead of "${event}".`
+ );
+ }
+ }
+ let handlerName;
+ let handler = props[handlerName = shared.toHandlerKey(event)] || // also try camelCase event handler (#2249)
+ props[handlerName = shared.toHandlerKey(shared.camelize(event))];
+ if (!handler && isModelListener) {
+ handler = props[handlerName = shared.toHandlerKey(shared.hyphenate(event))];
+ }
+ if (handler) {
+ callWithAsyncErrorHandling(
+ handler,
+ instance,
+ 6,
+ args
+ );
+ }
+ const onceHandler = props[handlerName + `Once`];
+ if (onceHandler) {
+ if (!instance.emitted) {
+ instance.emitted = {};
+ } else if (instance.emitted[handlerName]) {
+ return;
+ }
+ instance.emitted[handlerName] = true;
+ callWithAsyncErrorHandling(
+ onceHandler,
+ instance,
+ 6,
+ args
+ );
+ }
+}
+function normalizeEmitsOptions(comp, appContext, asMixin = false) {
+ const cache = appContext.emitsCache;
+ const cached = cache.get(comp);
+ if (cached !== void 0) {
+ return cached;
+ }
+ const raw = comp.emits;
+ let normalized = {};
+ let hasExtends = false;
+ if (!shared.isFunction(comp)) {
+ const extendEmits = (raw2) => {
+ const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+ if (normalizedFromExtend) {
+ hasExtends = true;
+ shared.extend(normalized, normalizedFromExtend);
+ }
+ };
+ if (!asMixin && appContext.mixins.length) {
+ appContext.mixins.forEach(extendEmits);
+ }
+ if (comp.extends) {
+ extendEmits(comp.extends);
+ }
+ if (comp.mixins) {
+ comp.mixins.forEach(extendEmits);
+ }
+ }
+ if (!raw && !hasExtends) {
+ if (shared.isObject(comp)) {
+ cache.set(comp, null);
+ }
+ return null;
+ }
+ if (shared.isArray(raw)) {
+ raw.forEach((key) => normalized[key] = null);
+ } else {
+ shared.extend(normalized, raw);
+ }
+ if (shared.isObject(comp)) {
+ cache.set(comp, normalized);
+ }
+ return normalized;
+}
+function isEmitListener(options, key) {
+ if (!options || !shared.isOn(key)) {
+ return false;
+ }
+ key = key.slice(2).replace(/Once$/, "");
+ return shared.hasOwn(options, key[0].toLowerCase() + key.slice(1)) || shared.hasOwn(options, shared.hyphenate(key)) || shared.hasOwn(options, key);
+}
+
+let currentRenderingInstance = null;
+let currentScopeId = null;
+function setCurrentRenderingInstance(instance) {
+ const prev = currentRenderingInstance;
+ currentRenderingInstance = instance;
+ currentScopeId = instance && instance.type.__scopeId || null;
+ return prev;
+}
+function pushScopeId(id) {
+ currentScopeId = id;
+}
+function popScopeId() {
+ currentScopeId = null;
+}
+const withScopeId = (_id) => withCtx;
+function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
+ if (!ctx)
+ return fn;
+ if (fn._n) {
+ return fn;
+ }
+ const renderFnWithContext = (...args) => {
+ if (renderFnWithContext._d) {
+ setBlockTracking(-1);
+ }
+ const prevInstance = setCurrentRenderingInstance(ctx);
+ let res;
+ try {
+ res = fn(...args);
+ } finally {
+ setCurrentRenderingInstance(prevInstance);
+ if (renderFnWithContext._d) {
+ setBlockTracking(1);
+ }
+ }
+ {
+ devtoolsComponentUpdated(ctx);
+ }
+ return res;
+ };
+ renderFnWithContext._n = true;
+ renderFnWithContext._c = true;
+ renderFnWithContext._d = true;
+ return renderFnWithContext;
+}
+
+let accessedAttrs = false;
+function markAttrsAccessed() {
+ accessedAttrs = true;
+}
+function renderComponentRoot(instance) {
+ const {
+ type: Component,
+ vnode,
+ proxy,
+ withProxy,
+ props,
+ propsOptions: [propsOptions],
+ slots,
+ attrs,
+ emit,
+ render,
+ renderCache,
+ data,
+ setupState,
+ ctx,
+ inheritAttrs
+ } = instance;
+ let result;
+ let fallthroughAttrs;
+ const prev = setCurrentRenderingInstance(instance);
+ {
+ accessedAttrs = false;
+ }
+ try {
+ if (vnode.shapeFlag & 4) {
+ const proxyToUse = withProxy || proxy;
+ const thisProxy = setupState.__isScriptSetup ? new Proxy(proxyToUse, {
+ get(target, key, receiver) {
+ warn(
+ `Property '${String(
+ key
+ )}' was accessed via 'this'. Avoid using 'this' in templates.`
+ );
+ return Reflect.get(target, key, receiver);
+ }
+ }) : proxyToUse;
+ result = normalizeVNode(
+ render.call(
+ thisProxy,
+ proxyToUse,
+ renderCache,
+ props,
+ setupState,
+ data,
+ ctx
+ )
+ );
+ fallthroughAttrs = attrs;
+ } else {
+ const render2 = Component;
+ if (attrs === props) {
+ markAttrsAccessed();
+ }
+ result = normalizeVNode(
+ render2.length > 1 ? render2(
+ props,
+ true ? {
+ get attrs() {
+ markAttrsAccessed();
+ return attrs;
+ },
+ slots,
+ emit
+ } : { attrs, slots, emit }
+ ) : render2(
+ props,
+ null
+ /* we know it doesn't need it */
+ )
+ );
+ fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
+ }
+ } catch (err) {
+ blockStack.length = 0;
+ handleError(err, instance, 1);
+ result = createVNode(Comment);
+ }
+ let root = result;
+ let setRoot = void 0;
+ if (result.patchFlag > 0 && result.patchFlag & 2048) {
+ [root, setRoot] = getChildRoot(result);
+ }
+ if (fallthroughAttrs && inheritAttrs !== false) {
+ const keys = Object.keys(fallthroughAttrs);
+ const { shapeFlag } = root;
+ if (keys.length) {
+ if (shapeFlag & (1 | 6)) {
+ if (propsOptions && keys.some(shared.isModelListener)) {
+ fallthroughAttrs = filterModelListeners(
+ fallthroughAttrs,
+ propsOptions
+ );
+ }
+ root = cloneVNode(root, fallthroughAttrs);
+ } else if (!accessedAttrs && root.type !== Comment) {
+ const allAttrs = Object.keys(attrs);
+ const eventAttrs = [];
+ const extraAttrs = [];
+ for (let i = 0, l = allAttrs.length; i < l; i++) {
+ const key = allAttrs[i];
+ if (shared.isOn(key)) {
+ if (!shared.isModelListener(key)) {
+ eventAttrs.push(key[2].toLowerCase() + key.slice(3));
+ }
+ } else {
+ extraAttrs.push(key);
+ }
+ }
+ if (extraAttrs.length) {
+ warn(
+ `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`
+ );
+ }
+ if (eventAttrs.length) {
+ warn(
+ `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
+ );
+ }
+ }
+ }
+ }
+ if (vnode.dirs) {
+ if (!isElementRoot(root)) {
+ warn(
+ `Runtime directive used on component with non-element root node. The directives will not function as intended.`
+ );
+ }
+ root = cloneVNode(root);
+ root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+ }
+ if (vnode.transition) {
+ if (!isElementRoot(root)) {
+ warn(
+ `Component inside <Transition> renders non-element root node that cannot be animated.`
+ );
+ }
+ root.transition = vnode.transition;
+ }
+ if (setRoot) {
+ setRoot(root);
+ } else {
+ result = root;
+ }
+ setCurrentRenderingInstance(prev);
+ return result;
+}
+const getChildRoot = (vnode) => {
+ const rawChildren = vnode.children;
+ const dynamicChildren = vnode.dynamicChildren;
+ const childRoot = filterSingleRoot(rawChildren);
+ if (!childRoot) {
+ return [vnode, void 0];
+ }
+ const index = rawChildren.indexOf(childRoot);
+ const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
+ const setRoot = (updatedRoot) => {
+ rawChildren[index] = updatedRoot;
+ if (dynamicChildren) {
+ if (dynamicIndex > -1) {
+ dynamicChildren[dynamicIndex] = updatedRoot;
+ } else if (updatedRoot.patchFlag > 0) {
+ vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
+ }
+ }
+ };
+ return [normalizeVNode(childRoot), setRoot];
+};
+function filterSingleRoot(children) {
+ let singleRoot;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isVNode(child)) {
+ if (child.type !== Comment || child.children === "v-if") {
+ if (singleRoot) {
+ return;
+ } else {
+ singleRoot = child;
+ }
+ }
+ } else {
+ return;
+ }
+ }
+ return singleRoot;
+}
+const getFunctionalFallthrough = (attrs) => {
+ let res;
+ for (const key in attrs) {
+ if (key === "class" || key === "style" || shared.isOn(key)) {
+ (res || (res = {}))[key] = attrs[key];
+ }
+ }
+ return res;
+};
+const filterModelListeners = (attrs, props) => {
+ const res = {};
+ for (const key in attrs) {
+ if (!shared.isModelListener(key) || !(key.slice(9) in props)) {
+ res[key] = attrs[key];
+ }
+ }
+ return res;
+};
+const isElementRoot = (vnode) => {
+ return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
+};
+function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+ const { props: prevProps, children: prevChildren, component } = prevVNode;
+ const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+ const emits = component.emitsOptions;
+ if ((prevChildren || nextChildren) && isHmrUpdating) {
+ return true;
+ }
+ if (nextVNode.dirs || nextVNode.transition) {
+ return true;
+ }
+ if (optimized && patchFlag >= 0) {
+ if (patchFlag & 1024) {
+ return true;
+ }
+ if (patchFlag & 16) {
+ if (!prevProps) {
+ return !!nextProps;
+ }
+ return hasPropsChanged(prevProps, nextProps, emits);
+ } else if (patchFlag & 8) {
+ const dynamicProps = nextVNode.dynamicProps;
+ for (let i = 0; i < dynamicProps.length; i++) {
+ const key = dynamicProps[i];
+ if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
+ return true;
+ }
+ }
+ }
+ } else {
+ if (prevChildren || nextChildren) {
+ if (!nextChildren || !nextChildren.$stable) {
+ return true;
+ }
+ }
+ if (prevProps === nextProps) {
+ return false;
+ }
+ if (!prevProps) {
+ return !!nextProps;
+ }
+ if (!nextProps) {
+ return true;
+ }
+ return hasPropsChanged(prevProps, nextProps, emits);
+ }
+ return false;
+}
+function hasPropsChanged(prevProps, nextProps, emitsOptions) {
+ const nextKeys = Object.keys(nextProps);
+ if (nextKeys.length !== Object.keys(prevProps).length) {
+ return true;
+ }
+ for (let i = 0; i < nextKeys.length; i++) {
+ const key = nextKeys[i];
+ if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
+ return true;
+ }
+ }
+ return false;
+}
+function updateHOCHostEl({ vnode, parent }, el) {
+ while (parent && parent.subTree === vnode) {
+ (vnode = parent.vnode).el = el;
+ parent = parent.parent;
+ }
+}
+
+const COMPONENTS = "components";
+const DIRECTIVES = "directives";
+function resolveComponent(name, maybeSelfReference) {
+ return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+}
+const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+function resolveDynamicComponent(component) {
+ if (shared.isString(component)) {
+ return resolveAsset(COMPONENTS, component, false) || component;
+ } else {
+ return component || NULL_DYNAMIC_COMPONENT;
+ }
+}
+function resolveDirective(name) {
+ return resolveAsset(DIRECTIVES, name);
+}
+function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+ const instance = currentRenderingInstance || currentInstance;
+ if (instance) {
+ const Component = instance.type;
+ if (type === COMPONENTS) {
+ const selfName = getComponentName(
+ Component,
+ false
+ /* do not include inferred name to avoid breaking existing code */
+ );
+ if (selfName && (selfName === name || selfName === shared.camelize(name) || selfName === shared.capitalize(shared.camelize(name)))) {
+ return Component;
+ }
+ }
+ const res = (
+ // local registration
+ // check instance[type] first which is resolved for options API
+ resolve(instance[type] || Component[type], name) || // global registration
+ resolve(instance.appContext[type], name)
+ );
+ if (!res && maybeSelfReference) {
+ return Component;
+ }
+ if (warnMissing && !res) {
+ const extra = type === COMPONENTS ? `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
+ warn(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+ }
+ return res;
+ } else {
+ warn(
+ `resolve${shared.capitalize(type.slice(0, -1))} can only be used in render() or setup().`
+ );
+ }
+}
+function resolve(registry, name) {
+ return registry && (registry[name] || registry[shared.camelize(name)] || registry[shared.capitalize(shared.camelize(name))]);
+}
+
+const isSuspense = (type) => type.__isSuspense;
+const SuspenseImpl = {
+ name: "Suspense",
+ // In order to make Suspense tree-shakable, we need to avoid importing it
+ // directly in the renderer. The renderer checks for the __isSuspense flag
+ // on a vnode's type and calls the `process` method, passing in renderer
+ // internals.
+ __isSuspense: true,
+ process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+ if (n1 == null) {
+ mountSuspense(
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals
+ );
+ } else {
+ patchSuspense(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals
+ );
+ }
+ },
+ hydrate: hydrateSuspense,
+ create: createSuspenseBoundary,
+ normalize: normalizeSuspenseChildren
+};
+const Suspense = SuspenseImpl ;
+function triggerEvent(vnode, name) {
+ const eventListener = vnode.props && vnode.props[name];
+ if (shared.isFunction(eventListener)) {
+ eventListener();
+ }
+}
+function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+ const {
+ p: patch,
+ o: { createElement }
+ } = rendererInternals;
+ const hiddenContainer = createElement("div");
+ const suspense = vnode.suspense = createSuspenseBoundary(
+ vnode,
+ parentSuspense,
+ parentComponent,
+ container,
+ hiddenContainer,
+ anchor,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals
+ );
+ patch(
+ null,
+ suspense.pendingBranch = vnode.ssContent,
+ hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds
+ );
+ if (suspense.deps > 0) {
+ triggerEvent(vnode, "onPending");
+ triggerEvent(vnode, "onFallback");
+ patch(
+ null,
+ vnode.ssFallback,
+ container,
+ anchor,
+ parentComponent,
+ null,
+ // fallback tree will not have suspense context
+ isSVG,
+ slotScopeIds
+ );
+ setActiveBranch(suspense, vnode.ssFallback);
+ } else {
+ suspense.resolve(false, true);
+ }
+}
+function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+ const suspense = n2.suspense = n1.suspense;
+ suspense.vnode = n2;
+ n2.el = n1.el;
+ const newBranch = n2.ssContent;
+ const newFallback = n2.ssFallback;
+ const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+ if (pendingBranch) {
+ suspense.pendingBranch = newBranch;
+ if (isSameVNodeType(newBranch, pendingBranch)) {
+ patch(
+ pendingBranch,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ } else if (isInFallback) {
+ patch(
+ activeBranch,
+ newFallback,
+ container,
+ anchor,
+ parentComponent,
+ null,
+ // fallback tree will not have suspense context
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, newFallback);
+ }
+ } else {
+ suspense.pendingId++;
+ if (isHydrating) {
+ suspense.isHydrating = false;
+ suspense.activeBranch = pendingBranch;
+ } else {
+ unmount(pendingBranch, parentComponent, suspense);
+ }
+ suspense.deps = 0;
+ suspense.effects.length = 0;
+ suspense.hiddenContainer = createElement("div");
+ if (isInFallback) {
+ patch(
+ null,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ } else {
+ patch(
+ activeBranch,
+ newFallback,
+ container,
+ anchor,
+ parentComponent,
+ null,
+ // fallback tree will not have suspense context
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, newFallback);
+ }
+ } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+ patch(
+ activeBranch,
+ newBranch,
+ container,
+ anchor,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ suspense.resolve(true);
+ } else {
+ patch(
+ null,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ }
+ }
+ }
+ } else {
+ if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+ patch(
+ activeBranch,
+ newBranch,
+ container,
+ anchor,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, newBranch);
+ } else {
+ triggerEvent(n2, "onPending");
+ suspense.pendingBranch = newBranch;
+ suspense.pendingId++;
+ patch(
+ null,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ } else {
+ const { timeout, pendingId } = suspense;
+ if (timeout > 0) {
+ setTimeout(() => {
+ if (suspense.pendingId === pendingId) {
+ suspense.fallback(newFallback);
+ }
+ }, timeout);
+ } else if (timeout === 0) {
+ suspense.fallback(newFallback);
+ }
+ }
+ }
+ }
+}
+let hasWarned = false;
+function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+ if (!hasWarned) {
+ hasWarned = true;
+ console[console.info ? "info" : "log"](
+ `<Suspense> is an experimental feature and its API will likely change.`
+ );
+ }
+ const {
+ p: patch,
+ m: move,
+ um: unmount,
+ n: next,
+ o: { parentNode, remove }
+ } = rendererInternals;
+ let parentSuspenseId;
+ const isSuspensible = isVNodeSuspensible(vnode);
+ if (isSuspensible) {
+ if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
+ parentSuspenseId = parentSuspense.pendingId;
+ parentSuspense.deps++;
+ }
+ }
+ const timeout = vnode.props ? shared.toNumber(vnode.props.timeout) : void 0;
+ {
+ assertNumber(timeout, `Suspense timeout`);
+ }
+ const suspense = {
+ vnode,
+ parent: parentSuspense,
+ parentComponent,
+ isSVG,
+ container,
+ hiddenContainer,
+ anchor,
+ deps: 0,
+ pendingId: 0,
+ timeout: typeof timeout === "number" ? timeout : -1,
+ activeBranch: null,
+ pendingBranch: null,
+ isInFallback: true,
+ isHydrating,
+ isUnmounted: false,
+ effects: [],
+ resolve(resume = false, sync = false) {
+ {
+ if (!resume && !suspense.pendingBranch) {
+ throw new Error(
+ `suspense.resolve() is called without a pending branch.`
+ );
+ }
+ if (suspense.isUnmounted) {
+ throw new Error(
+ `suspense.resolve() is called on an already unmounted suspense boundary.`
+ );
+ }
+ }
+ const {
+ vnode: vnode2,
+ activeBranch,
+ pendingBranch,
+ pendingId,
+ effects,
+ parentComponent: parentComponent2,
+ container: container2
+ } = suspense;
+ let delayEnter = false;
+ if (suspense.isHydrating) {
+ suspense.isHydrating = false;
+ } else if (!resume) {
+ delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
+ if (delayEnter) {
+ activeBranch.transition.afterLeave = () => {
+ if (pendingId === suspense.pendingId) {
+ move(pendingBranch, container2, anchor2, 0);
+ queuePostFlushCb(effects);
+ }
+ };
+ }
+ let { anchor: anchor2 } = suspense;
+ if (activeBranch) {
+ anchor2 = next(activeBranch);
+ unmount(activeBranch, parentComponent2, suspense, true);
+ }
+ if (!delayEnter) {
+ move(pendingBranch, container2, anchor2, 0);
+ }
+ }
+ setActiveBranch(suspense, pendingBranch);
+ suspense.pendingBranch = null;
+ suspense.isInFallback = false;
+ let parent = suspense.parent;
+ let hasUnresolvedAncestor = false;
+ while (parent) {
+ if (parent.pendingBranch) {
+ parent.effects.push(...effects);
+ hasUnresolvedAncestor = true;
+ break;
+ }
+ parent = parent.parent;
+ }
+ if (!hasUnresolvedAncestor && !delayEnter) {
+ queuePostFlushCb(effects);
+ }
+ suspense.effects = [];
+ if (isSuspensible) {
+ if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+ parentSuspense.deps--;
+ if (parentSuspense.deps === 0 && !sync) {
+ parentSuspense.resolve();
+ }
+ }
+ }
+ triggerEvent(vnode2, "onResolve");
+ },
+ fallback(fallbackVNode) {
+ if (!suspense.pendingBranch) {
+ return;
+ }
+ const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG2 } = suspense;
+ triggerEvent(vnode2, "onFallback");
+ const anchor2 = next(activeBranch);
+ const mountFallback = () => {
+ if (!suspense.isInFallback) {
+ return;
+ }
+ patch(
+ null,
+ fallbackVNode,
+ container2,
+ anchor2,
+ parentComponent2,
+ null,
+ // fallback tree will not have suspense context
+ isSVG2,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, fallbackVNode);
+ };
+ const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
+ if (delayEnter) {
+ activeBranch.transition.afterLeave = mountFallback;
+ }
+ suspense.isInFallback = true;
+ unmount(
+ activeBranch,
+ parentComponent2,
+ null,
+ // no suspense so unmount hooks fire now
+ true
+ // shouldRemove
+ );
+ if (!delayEnter) {
+ mountFallback();
+ }
+ },
+ move(container2, anchor2, type) {
+ suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+ suspense.container = container2;
+ },
+ next() {
+ return suspense.activeBranch && next(suspense.activeBranch);
+ },
+ registerDep(instance, setupRenderEffect) {
+ const isInPendingSuspense = !!suspense.pendingBranch;
+ if (isInPendingSuspense) {
+ suspense.deps++;
+ }
+ const hydratedEl = instance.vnode.el;
+ instance.asyncDep.catch((err) => {
+ handleError(err, instance, 0);
+ }).then((asyncSetupResult) => {
+ if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
+ return;
+ }
+ instance.asyncResolved = true;
+ const { vnode: vnode2 } = instance;
+ {
+ pushWarningContext(vnode2);
+ }
+ handleSetupResult(instance, asyncSetupResult, false);
+ if (hydratedEl) {
+ vnode2.el = hydratedEl;
+ }
+ const placeholder = !hydratedEl && instance.subTree.el;
+ setupRenderEffect(
+ instance,
+ vnode2,
+ // component may have been moved before resolve.
+ // if this is not a hydration, instance.subTree will be the comment
+ // placeholder.
+ parentNode(hydratedEl || instance.subTree.el),
+ // anchor will not be used if this is hydration, so only need to
+ // consider the comment placeholder case.
+ hydratedEl ? null : next(instance.subTree),
+ suspense,
+ isSVG,
+ optimized
+ );
+ if (placeholder) {
+ remove(placeholder);
+ }
+ updateHOCHostEl(instance, vnode2.el);
+ {
+ popWarningContext();
+ }
+ if (isInPendingSuspense && --suspense.deps === 0) {
+ suspense.resolve();
+ }
+ });
+ },
+ unmount(parentSuspense2, doRemove) {
+ suspense.isUnmounted = true;
+ if (suspense.activeBranch) {
+ unmount(
+ suspense.activeBranch,
+ parentComponent,
+ parentSuspense2,
+ doRemove
+ );
+ }
+ if (suspense.pendingBranch) {
+ unmount(
+ suspense.pendingBranch,
+ parentComponent,
+ parentSuspense2,
+ doRemove
+ );
+ }
+ }
+ };
+ return suspense;
+}
+function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+ const suspense = vnode.suspense = createSuspenseBoundary(
+ vnode,
+ parentSuspense,
+ parentComponent,
+ node.parentNode,
+ document.createElement("div"),
+ null,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals,
+ true
+ /* hydrating */
+ );
+ const result = hydrateNode(
+ node,
+ suspense.pendingBranch = vnode.ssContent,
+ parentComponent,
+ suspense,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps === 0) {
+ suspense.resolve(false, true);
+ }
+ return result;
+}
+function normalizeSuspenseChildren(vnode) {
+ const { shapeFlag, children } = vnode;
+ const isSlotChildren = shapeFlag & 32;
+ vnode.ssContent = normalizeSuspenseSlot(
+ isSlotChildren ? children.default : children
+ );
+ vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
+}
+function normalizeSuspenseSlot(s) {
+ let block;
+ if (shared.isFunction(s)) {
+ const trackBlock = isBlockTreeEnabled && s._c;
+ if (trackBlock) {
+ s._d = false;
+ openBlock();
+ }
+ s = s();
+ if (trackBlock) {
+ s._d = true;
+ block = currentBlock;
+ closeBlock();
+ }
+ }
+ if (shared.isArray(s)) {
+ const singleChild = filterSingleRoot(s);
+ if (!singleChild && s.filter((child) => child !== NULL_DYNAMIC_COMPONENT).length > 0) {
+ warn(`<Suspense> slots expect a single root node.`);
+ }
+ s = singleChild;
+ }
+ s = normalizeVNode(s);
+ if (block && !s.dynamicChildren) {
+ s.dynamicChildren = block.filter((c) => c !== s);
+ }
+ return s;
+}
+function queueEffectWithSuspense(fn, suspense) {
+ if (suspense && suspense.pendingBranch) {
+ if (shared.isArray(fn)) {
+ suspense.effects.push(...fn);
+ } else {
+ suspense.effects.push(fn);
+ }
+ } else {
+ queuePostFlushCb(fn);
+ }
+}
+function setActiveBranch(suspense, branch) {
+ suspense.activeBranch = branch;
+ const { vnode, parentComponent } = suspense;
+ const el = vnode.el = branch.el;
+ if (parentComponent && parentComponent.subTree === vnode) {
+ parentComponent.vnode.el = el;
+ updateHOCHostEl(parentComponent, el);
+ }
+}
+function isVNodeSuspensible(vnode) {
+ var _a;
+ return ((_a = vnode.props) == null ? void 0 : _a.suspensible) != null && vnode.props.suspensible !== false;
+}
+
+function watchEffect(effect, options) {
+ return doWatch(effect, null, options);
+}
+function watchPostEffect(effect, options) {
+ return doWatch(
+ effect,
+ null,
+ shared.extend({}, options, { flush: "post" })
+ );
+}
+function watchSyncEffect(effect, options) {
+ return doWatch(
+ effect,
+ null,
+ shared.extend({}, options, { flush: "sync" })
+ );
+}
+const INITIAL_WATCHER_VALUE = {};
+function watch(source, cb, options) {
+ if (!shared.isFunction(cb)) {
+ warn(
+ `\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`
+ );
+ }
+ return doWatch(source, cb, options);
+}
+function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = shared.EMPTY_OBJ) {
+ var _a;
+ if (!cb) {
+ if (immediate !== void 0) {
+ warn(
+ `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ if (deep !== void 0) {
+ warn(
+ `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ }
+ const warnInvalidSource = (s) => {
+ warn(
+ `Invalid watch source: `,
+ s,
+ `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
+ );
+ };
+ const instance = reactivity.getCurrentScope() === ((_a = currentInstance) == null ? void 0 : _a.scope) ? currentInstance : null;
+ let getter;
+ let forceTrigger = false;
+ let isMultiSource = false;
+ if (reactivity.isRef(source)) {
+ getter = () => source.value;
+ forceTrigger = reactivity.isShallow(source);
+ } else if (reactivity.isReactive(source)) {
+ getter = () => source;
+ deep = true;
+ } else if (shared.isArray(source)) {
+ isMultiSource = true;
+ forceTrigger = source.some((s) => reactivity.isReactive(s) || reactivity.isShallow(s));
+ getter = () => source.map((s) => {
+ if (reactivity.isRef(s)) {
+ return s.value;
+ } else if (reactivity.isReactive(s)) {
+ return traverse(s);
+ } else if (shared.isFunction(s)) {
+ return callWithErrorHandling(s, instance, 2);
+ } else {
+ warnInvalidSource(s);
+ }
+ });
+ } else if (shared.isFunction(source)) {
+ if (cb) {
+ getter = () => callWithErrorHandling(source, instance, 2);
+ } else {
+ getter = () => {
+ if (instance && instance.isUnmounted) {
+ return;
+ }
+ if (cleanup) {
+ cleanup();
+ }
+ return callWithAsyncErrorHandling(
+ source,
+ instance,
+ 3,
+ [onCleanup]
+ );
+ };
+ }
+ } else {
+ getter = shared.NOOP;
+ warnInvalidSource(source);
+ }
+ if (cb && deep) {
+ const baseGetter = getter;
+ getter = () => traverse(baseGetter());
+ }
+ let cleanup;
+ let onCleanup = (fn) => {
+ cleanup = effect.onStop = () => {
+ callWithErrorHandling(fn, instance, 4);
+ cleanup = effect.onStop = void 0;
+ };
+ };
+ let ssrCleanup;
+ if (isInSSRComponentSetup) {
+ onCleanup = shared.NOOP;
+ if (!cb) {
+ getter();
+ } else if (immediate) {
+ callWithAsyncErrorHandling(cb, instance, 3, [
+ getter(),
+ isMultiSource ? [] : void 0,
+ onCleanup
+ ]);
+ }
+ if (flush === "sync") {
+ const ctx = useSSRContext();
+ ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+ } else {
+ return shared.NOOP;
+ }
+ }
+ let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+ const job = () => {
+ if (!effect.active) {
+ return;
+ }
+ if (cb) {
+ const newValue = effect.run();
+ if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => shared.hasChanged(v, oldValue[i])) : shared.hasChanged(newValue, oldValue)) || false) {
+ if (cleanup) {
+ cleanup();
+ }
+ callWithAsyncErrorHandling(cb, instance, 3, [
+ newValue,
+ // pass undefined as the old value when it's changed for the first time
+ oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+ onCleanup
+ ]);
+ oldValue = newValue;
+ }
+ } else {
+ effect.run();
+ }
+ };
+ job.allowRecurse = !!cb;
+ let scheduler;
+ if (flush === "sync") {
+ scheduler = job;
+ } else if (flush === "post") {
+ scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+ } else {
+ job.pre = true;
+ if (instance)
+ job.id = instance.uid;
+ scheduler = () => queueJob(job);
+ }
+ const effect = new reactivity.ReactiveEffect(getter, scheduler);
+ {
+ effect.onTrack = onTrack;
+ effect.onTrigger = onTrigger;
+ }
+ if (cb) {
+ if (immediate) {
+ job();
+ } else {
+ oldValue = effect.run();
+ }
+ } else if (flush === "post") {
+ queuePostRenderEffect(
+ effect.run.bind(effect),
+ instance && instance.suspense
+ );
+ } else {
+ effect.run();
+ }
+ const unwatch = () => {
+ effect.stop();
+ if (instance && instance.scope) {
+ shared.remove(instance.scope.effects, effect);
+ }
+ };
+ if (ssrCleanup)
+ ssrCleanup.push(unwatch);
+ return unwatch;
+}
+function instanceWatch(source, value, options) {
+ const publicThis = this.proxy;
+ const getter = shared.isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+ let cb;
+ if (shared.isFunction(value)) {
+ cb = value;
+ } else {
+ cb = value.handler;
+ options = value;
+ }
+ const cur = currentInstance;
+ setCurrentInstance(this);
+ const res = doWatch(getter, cb.bind(publicThis), options);
+ if (cur) {
+ setCurrentInstance(cur);
+ } else {
+ unsetCurrentInstance();
+ }
+ return res;
+}
+function createPathGetter(ctx, path) {
+ const segments = path.split(".");
+ return () => {
+ let cur = ctx;
+ for (let i = 0; i < segments.length && cur; i++) {
+ cur = cur[segments[i]];
+ }
+ return cur;
+ };
+}
+function traverse(value, seen) {
+ if (!shared.isObject(value) || value["__v_skip"]) {
+ return value;
+ }
+ seen = seen || /* @__PURE__ */ new Set();
+ if (seen.has(value)) {
+ return value;
+ }
+ seen.add(value);
+ if (reactivity.isRef(value)) {
+ traverse(value.value, seen);
+ } else if (shared.isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ traverse(value[i], seen);
+ }
+ } else if (shared.isSet(value) || shared.isMap(value)) {
+ value.forEach((v) => {
+ traverse(v, seen);
+ });
+ } else if (shared.isPlainObject(value)) {
+ for (const key in value) {
+ traverse(value[key], seen);
+ }
+ }
+ return value;
+}
+
+function validateDirectiveName(name) {
+ if (shared.isBuiltInDirective(name)) {
+ warn("Do not use built-in directive ids as custom directive id: " + name);
+ }
+}
+function withDirectives(vnode, directives) {
+ const internalInstance = currentRenderingInstance;
+ if (internalInstance === null) {
+ warn(`withDirectives can only be used inside render functions.`);
+ return vnode;
+ }
+ const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
+ const bindings = vnode.dirs || (vnode.dirs = []);
+ for (let i = 0; i < directives.length; i++) {
+ let [dir, value, arg, modifiers = shared.EMPTY_OBJ] = directives[i];
+ if (dir) {
+ if (shared.isFunction(dir)) {
+ dir = {
+ mounted: dir,
+ updated: dir
+ };
+ }
+ if (dir.deep) {
+ traverse(value);
+ }
+ bindings.push({
+ dir,
+ instance,
+ value,
+ oldValue: void 0,
+ arg,
+ modifiers
+ });
+ }
+ }
+ return vnode;
+}
+function invokeDirectiveHook(vnode, prevVNode, instance, name) {
+ const bindings = vnode.dirs;
+ const oldBindings = prevVNode && prevVNode.dirs;
+ for (let i = 0; i < bindings.length; i++) {
+ const binding = bindings[i];
+ if (oldBindings) {
+ binding.oldValue = oldBindings[i].value;
+ }
+ let hook = binding.dir[name];
+ if (hook) {
+ reactivity.pauseTracking();
+ callWithAsyncErrorHandling(hook, instance, 8, [
+ vnode.el,
+ binding,
+ vnode,
+ prevVNode
+ ]);
+ reactivity.resetTracking();
+ }
+ }
+}
+
+const leaveCbKey = Symbol("_leaveCb");
+const enterCbKey = Symbol("_enterCb");
+function useTransitionState() {
+ const state = {
+ isMounted: false,
+ isLeaving: false,
+ isUnmounting: false,
+ leavingVNodes: /* @__PURE__ */ new Map()
+ };
+ onMounted(() => {
+ state.isMounted = true;
+ });
+ onBeforeUnmount(() => {
+ state.isUnmounting = true;
+ });
+ return state;
+}
+const TransitionHookValidator = [Function, Array];
+const BaseTransitionPropsValidators = {
+ mode: String,
+ appear: Boolean,
+ persisted: Boolean,
+ // enter
+ onBeforeEnter: TransitionHookValidator,
+ onEnter: TransitionHookValidator,
+ onAfterEnter: TransitionHookValidator,
+ onEnterCancelled: TransitionHookValidator,
+ // leave
+ onBeforeLeave: TransitionHookValidator,
+ onLeave: TransitionHookValidator,
+ onAfterLeave: TransitionHookValidator,
+ onLeaveCancelled: TransitionHookValidator,
+ // appear
+ onBeforeAppear: TransitionHookValidator,
+ onAppear: TransitionHookValidator,
+ onAfterAppear: TransitionHookValidator,
+ onAppearCancelled: TransitionHookValidator
+};
+const BaseTransitionImpl = {
+ name: `BaseTransition`,
+ props: BaseTransitionPropsValidators,
+ setup(props, { slots }) {
+ const instance = getCurrentInstance();
+ const state = useTransitionState();
+ let prevTransitionKey;
+ return () => {
+ const children = slots.default && getTransitionRawChildren(slots.default(), true);
+ if (!children || !children.length) {
+ return;
+ }
+ let child = children[0];
+ if (children.length > 1) {
+ let hasFound = false;
+ for (const c of children) {
+ if (c.type !== Comment) {
+ if (hasFound) {
+ warn(
+ "<transition> can only be used on a single element or component. Use <transition-group> for lists."
+ );
+ break;
+ }
+ child = c;
+ hasFound = true;
+ }
+ }
+ }
+ const rawProps = reactivity.toRaw(props);
+ const { mode } = rawProps;
+ if (mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
+ warn(`invalid <transition> mode: ${mode}`);
+ }
+ if (state.isLeaving) {
+ return emptyPlaceholder(child);
+ }
+ const innerChild = getKeepAliveChild(child);
+ if (!innerChild) {
+ return emptyPlaceholder(child);
+ }
+ const enterHooks = resolveTransitionHooks(
+ innerChild,
+ rawProps,
+ state,
+ instance
+ );
+ setTransitionHooks(innerChild, enterHooks);
+ const oldChild = instance.subTree;
+ const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
+ let transitionKeyChanged = false;
+ const { getTransitionKey } = innerChild.type;
+ if (getTransitionKey) {
+ const key = getTransitionKey();
+ if (prevTransitionKey === void 0) {
+ prevTransitionKey = key;
+ } else if (key !== prevTransitionKey) {
+ prevTransitionKey = key;
+ transitionKeyChanged = true;
+ }
+ }
+ if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
+ const leavingHooks = resolveTransitionHooks(
+ oldInnerChild,
+ rawProps,
+ state,
+ instance
+ );
+ setTransitionHooks(oldInnerChild, leavingHooks);
+ if (mode === "out-in") {
+ state.isLeaving = true;
+ leavingHooks.afterLeave = () => {
+ state.isLeaving = false;
+ if (instance.update.active !== false) {
+ instance.update();
+ }
+ };
+ return emptyPlaceholder(child);
+ } else if (mode === "in-out" && innerChild.type !== Comment) {
+ leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
+ const leavingVNodesCache = getLeavingNodesForType(
+ state,
+ oldInnerChild
+ );
+ leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
+ el[leaveCbKey] = () => {
+ earlyRemove();
+ el[leaveCbKey] = void 0;
+ delete enterHooks.delayedLeave;
+ };
+ enterHooks.delayedLeave = delayedLeave;
+ };
+ }
+ }
+ return child;
+ };
+ }
+};
+const BaseTransition = BaseTransitionImpl;
+function getLeavingNodesForType(state, vnode) {
+ const { leavingVNodes } = state;
+ let leavingVNodesCache = leavingVNodes.get(vnode.type);
+ if (!leavingVNodesCache) {
+ leavingVNodesCache = /* @__PURE__ */ Object.create(null);
+ leavingVNodes.set(vnode.type, leavingVNodesCache);
+ }
+ return leavingVNodesCache;
+}
+function resolveTransitionHooks(vnode, props, state, instance) {
+ const {
+ appear,
+ mode,
+ persisted = false,
+ onBeforeEnter,
+ onEnter,
+ onAfterEnter,
+ onEnterCancelled,
+ onBeforeLeave,
+ onLeave,
+ onAfterLeave,
+ onLeaveCancelled,
+ onBeforeAppear,
+ onAppear,
+ onAfterAppear,
+ onAppearCancelled
+ } = props;
+ const key = String(vnode.key);
+ const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+ const callHook = (hook, args) => {
+ hook && callWithAsyncErrorHandling(
+ hook,
+ instance,
+ 9,
+ args
+ );
+ };
+ const callAsyncHook = (hook, args) => {
+ const done = args[1];
+ callHook(hook, args);
+ if (shared.isArray(hook)) {
+ if (hook.every((hook2) => hook2.length <= 1))
+ done();
+ } else if (hook.length <= 1) {
+ done();
+ }
+ };
+ const hooks = {
+ mode,
+ persisted,
+ beforeEnter(el) {
+ let hook = onBeforeEnter;
+ if (!state.isMounted) {
+ if (appear) {
+ hook = onBeforeAppear || onBeforeEnter;
+ } else {
+ return;
+ }
+ }
+ if (el[leaveCbKey]) {
+ el[leaveCbKey](
+ true
+ /* cancelled */
+ );
+ }
+ const leavingVNode = leavingVNodesCache[key];
+ if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
+ leavingVNode.el[leaveCbKey]();
+ }
+ callHook(hook, [el]);
+ },
+ enter(el) {
+ let hook = onEnter;
+ let afterHook = onAfterEnter;
+ let cancelHook = onEnterCancelled;
+ if (!state.isMounted) {
+ if (appear) {
+ hook = onAppear || onEnter;
+ afterHook = onAfterAppear || onAfterEnter;
+ cancelHook = onAppearCancelled || onEnterCancelled;
+ } else {
+ return;
+ }
+ }
+ let called = false;
+ const done = el[enterCbKey] = (cancelled) => {
+ if (called)
+ return;
+ called = true;
+ if (cancelled) {
+ callHook(cancelHook, [el]);
+ } else {
+ callHook(afterHook, [el]);
+ }
+ if (hooks.delayedLeave) {
+ hooks.delayedLeave();
+ }
+ el[enterCbKey] = void 0;
+ };
+ if (hook) {
+ callAsyncHook(hook, [el, done]);
+ } else {
+ done();
+ }
+ },
+ leave(el, remove) {
+ const key2 = String(vnode.key);
+ if (el[enterCbKey]) {
+ el[enterCbKey](
+ true
+ /* cancelled */
+ );
+ }
+ if (state.isUnmounting) {
+ return remove();
+ }
+ callHook(onBeforeLeave, [el]);
+ let called = false;
+ const done = el[leaveCbKey] = (cancelled) => {
+ if (called)
+ return;
+ called = true;
+ remove();
+ if (cancelled) {
+ callHook(onLeaveCancelled, [el]);
+ } else {
+ callHook(onAfterLeave, [el]);
+ }
+ el[leaveCbKey] = void 0;
+ if (leavingVNodesCache[key2] === vnode) {
+ delete leavingVNodesCache[key2];
+ }
+ };
+ leavingVNodesCache[key2] = vnode;
+ if (onLeave) {
+ callAsyncHook(onLeave, [el, done]);
+ } else {
+ done();
+ }
+ },
+ clone(vnode2) {
+ return resolveTransitionHooks(vnode2, props, state, instance);
+ }
+ };
+ return hooks;
+}
+function emptyPlaceholder(vnode) {
+ if (isKeepAlive(vnode)) {
+ vnode = cloneVNode(vnode);
+ vnode.children = null;
+ return vnode;
+ }
+}
+function getKeepAliveChild(vnode) {
+ return isKeepAlive(vnode) ? (
+ // #7121 ensure get the child component subtree in case
+ // it's been replaced during HMR
+ vnode.component ? vnode.component.subTree : vnode.children ? vnode.children[0] : void 0
+ ) : vnode;
+}
+function setTransitionHooks(vnode, hooks) {
+ if (vnode.shapeFlag & 6 && vnode.component) {
+ setTransitionHooks(vnode.component.subTree, hooks);
+ } else if (vnode.shapeFlag & 128) {
+ vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+ vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+ } else {
+ vnode.transition = hooks;
+ }
+}
+function getTransitionRawChildren(children, keepComment = false, parentKey) {
+ let ret = [];
+ let keyedFragmentCount = 0;
+ for (let i = 0; i < children.length; i++) {
+ let child = children[i];
+ const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
+ if (child.type === Fragment) {
+ if (child.patchFlag & 128)
+ keyedFragmentCount++;
+ ret = ret.concat(
+ getTransitionRawChildren(child.children, keepComment, key)
+ );
+ } else if (keepComment || child.type !== Comment) {
+ ret.push(key != null ? cloneVNode(child, { key }) : child);
+ }
+ }
+ if (keyedFragmentCount > 1) {
+ for (let i = 0; i < ret.length; i++) {
+ ret[i].patchFlag = -2;
+ }
+ }
+ return ret;
+}
+
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineComponent(options, extraOptions) {
+ return shared.isFunction(options) ? (
+ // #8326: extend call and options.name access are considered side-effects
+ // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+ /* @__PURE__ */ (() => shared.extend({ name: options.name }, extraOptions, { setup: options }))()
+ ) : options;
+}
+
+const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineAsyncComponent(source) {
+ if (shared.isFunction(source)) {
+ source = { loader: source };
+ }
+ const {
+ loader,
+ loadingComponent,
+ errorComponent,
+ delay = 200,
+ timeout,
+ // undefined = never times out
+ suspensible = true,
+ onError: userOnError
+ } = source;
+ let pendingRequest = null;
+ let resolvedComp;
+ let retries = 0;
+ const retry = () => {
+ retries++;
+ pendingRequest = null;
+ return load();
+ };
+ const load = () => {
+ let thisRequest;
+ return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+ err = err instanceof Error ? err : new Error(String(err));
+ if (userOnError) {
+ return new Promise((resolve, reject) => {
+ const userRetry = () => resolve(retry());
+ const userFail = () => reject(err);
+ userOnError(err, userRetry, userFail, retries + 1);
+ });
+ } else {
+ throw err;
+ }
+ }).then((comp) => {
+ if (thisRequest !== pendingRequest && pendingRequest) {
+ return pendingRequest;
+ }
+ if (!comp) {
+ warn(
+ `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
+ );
+ }
+ if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+ comp = comp.default;
+ }
+ if (comp && !shared.isObject(comp) && !shared.isFunction(comp)) {
+ throw new Error(`Invalid async component load result: ${comp}`);
+ }
+ resolvedComp = comp;
+ return comp;
+ }));
+ };
+ return defineComponent({
+ name: "AsyncComponentWrapper",
+ __asyncLoader: load,
+ get __asyncResolved() {
+ return resolvedComp;
+ },
+ setup() {
+ const instance = currentInstance;
+ if (resolvedComp) {
+ return () => createInnerComp(resolvedComp, instance);
+ }
+ const onError = (err) => {
+ pendingRequest = null;
+ handleError(
+ err,
+ instance,
+ 13,
+ !errorComponent
+ /* do not throw in dev if user provided error component */
+ );
+ };
+ if (suspensible && instance.suspense || isInSSRComponentSetup) {
+ return load().then((comp) => {
+ return () => createInnerComp(comp, instance);
+ }).catch((err) => {
+ onError(err);
+ return () => errorComponent ? createVNode(errorComponent, {
+ error: err
+ }) : null;
+ });
+ }
+ const loaded = reactivity.ref(false);
+ const error = reactivity.ref();
+ const delayed = reactivity.ref(!!delay);
+ if (delay) {
+ setTimeout(() => {
+ delayed.value = false;
+ }, delay);
+ }
+ if (timeout != null) {
+ setTimeout(() => {
+ if (!loaded.value && !error.value) {
+ const err = new Error(
+ `Async component timed out after ${timeout}ms.`
+ );
+ onError(err);
+ error.value = err;
+ }
+ }, timeout);
+ }
+ load().then(() => {
+ loaded.value = true;
+ if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+ queueJob(instance.parent.update);
+ }
+ }).catch((err) => {
+ onError(err);
+ error.value = err;
+ });
+ return () => {
+ if (loaded.value && resolvedComp) {
+ return createInnerComp(resolvedComp, instance);
+ } else if (error.value && errorComponent) {
+ return createVNode(errorComponent, {
+ error: error.value
+ });
+ } else if (loadingComponent && !delayed.value) {
+ return createVNode(loadingComponent);
+ }
+ };
+ }
+ });
+}
+function createInnerComp(comp, parent) {
+ const { ref: ref2, props, children, ce } = parent.vnode;
+ const vnode = createVNode(comp, props, children);
+ vnode.ref = ref2;
+ vnode.ce = ce;
+ delete parent.vnode.ce;
+ return vnode;
+}
+
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+const KeepAliveImpl = {
+ name: `KeepAlive`,
+ // Marker for special handling inside the renderer. We are not using a ===
+ // check directly on KeepAlive in the renderer, because importing it directly
+ // would prevent it from being tree-shaken.
+ __isKeepAlive: true,
+ props: {
+ include: [String, RegExp, Array],
+ exclude: [String, RegExp, Array],
+ max: [String, Number]
+ },
+ setup(props, { slots }) {
+ const instance = getCurrentInstance();
+ const sharedContext = instance.ctx;
+ if (!sharedContext.renderer) {
+ return () => {
+ const children = slots.default && slots.default();
+ return children && children.length === 1 ? children[0] : children;
+ };
+ }
+ const cache = /* @__PURE__ */ new Map();
+ const keys = /* @__PURE__ */ new Set();
+ let current = null;
+ {
+ instance.__v_cache = cache;
+ }
+ const parentSuspense = instance.suspense;
+ const {
+ renderer: {
+ p: patch,
+ m: move,
+ um: _unmount,
+ o: { createElement }
+ }
+ } = sharedContext;
+ const storageContainer = createElement("div");
+ sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
+ const instance2 = vnode.component;
+ move(vnode, container, anchor, 0, parentSuspense);
+ patch(
+ instance2.vnode,
+ vnode,
+ container,
+ anchor,
+ instance2,
+ parentSuspense,
+ isSVG,
+ vnode.slotScopeIds,
+ optimized
+ );
+ queuePostRenderEffect(() => {
+ instance2.isDeactivated = false;
+ if (instance2.a) {
+ shared.invokeArrayFns(instance2.a);
+ }
+ const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+ if (vnodeHook) {
+ invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+ }
+ }, parentSuspense);
+ {
+ devtoolsComponentAdded(instance2);
+ }
+ };
+ sharedContext.deactivate = (vnode) => {
+ const instance2 = vnode.component;
+ move(vnode, storageContainer, null, 1, parentSuspense);
+ queuePostRenderEffect(() => {
+ if (instance2.da) {
+ shared.invokeArrayFns(instance2.da);
+ }
+ const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+ if (vnodeHook) {
+ invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+ }
+ instance2.isDeactivated = true;
+ }, parentSuspense);
+ {
+ devtoolsComponentAdded(instance2);
+ }
+ };
+ function unmount(vnode) {
+ resetShapeFlag(vnode);
+ _unmount(vnode, instance, parentSuspense, true);
+ }
+ function pruneCache(filter) {
+ cache.forEach((vnode, key) => {
+ const name = getComponentName(vnode.type);
+ if (name && (!filter || !filter(name))) {
+ pruneCacheEntry(key);
+ }
+ });
+ }
+ function pruneCacheEntry(key) {
+ const cached = cache.get(key);
+ if (!current || !isSameVNodeType(cached, current)) {
+ unmount(cached);
+ } else if (current) {
+ resetShapeFlag(current);
+ }
+ cache.delete(key);
+ keys.delete(key);
+ }
+ watch(
+ () => [props.include, props.exclude],
+ ([include, exclude]) => {
+ include && pruneCache((name) => matches(include, name));
+ exclude && pruneCache((name) => !matches(exclude, name));
+ },
+ // prune post-render after `current` has been updated
+ { flush: "post", deep: true }
+ );
+ let pendingCacheKey = null;
+ const cacheSubtree = () => {
+ if (pendingCacheKey != null) {
+ cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+ }
+ };
+ onMounted(cacheSubtree);
+ onUpdated(cacheSubtree);
+ onBeforeUnmount(() => {
+ cache.forEach((cached) => {
+ const { subTree, suspense } = instance;
+ const vnode = getInnerChild(subTree);
+ if (cached.type === vnode.type && cached.key === vnode.key) {
+ resetShapeFlag(vnode);
+ const da = vnode.component.da;
+ da && queuePostRenderEffect(da, suspense);
+ return;
+ }
+ unmount(cached);
+ });
+ });
+ return () => {
+ pendingCacheKey = null;
+ if (!slots.default) {
+ return null;
+ }
+ const children = slots.default();
+ const rawVNode = children[0];
+ if (children.length > 1) {
+ {
+ warn(`KeepAlive should contain exactly one component child.`);
+ }
+ current = null;
+ return children;
+ } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
+ current = null;
+ return rawVNode;
+ }
+ let vnode = getInnerChild(rawVNode);
+ const comp = vnode.type;
+ const name = getComponentName(
+ isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
+ );
+ const { include, exclude, max } = props;
+ if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+ current = vnode;
+ return rawVNode;
+ }
+ const key = vnode.key == null ? comp : vnode.key;
+ const cachedVNode = cache.get(key);
+ if (vnode.el) {
+ vnode = cloneVNode(vnode);
+ if (rawVNode.shapeFlag & 128) {
+ rawVNode.ssContent = vnode;
+ }
+ }
+ pendingCacheKey = key;
+ if (cachedVNode) {
+ vnode.el = cachedVNode.el;
+ vnode.component = cachedVNode.component;
+ if (vnode.transition) {
+ setTransitionHooks(vnode, vnode.transition);
+ }
+ vnode.shapeFlag |= 512;
+ keys.delete(key);
+ keys.add(key);
+ } else {
+ keys.add(key);
+ if (max && keys.size > parseInt(max, 10)) {
+ pruneCacheEntry(keys.values().next().value);
+ }
+ }
+ vnode.shapeFlag |= 256;
+ current = vnode;
+ return isSuspense(rawVNode.type) ? rawVNode : vnode;
+ };
+ }
+};
+const KeepAlive = KeepAliveImpl;
+function matches(pattern, name) {
+ if (shared.isArray(pattern)) {
+ return pattern.some((p) => matches(p, name));
+ } else if (shared.isString(pattern)) {
+ return pattern.split(",").includes(name);
+ } else if (shared.isRegExp(pattern)) {
+ return pattern.test(name);
+ }
+ return false;
+}
+function onActivated(hook, target) {
+ registerKeepAliveHook(hook, "a", target);
+}
+function onDeactivated(hook, target) {
+ registerKeepAliveHook(hook, "da", target);
+}
+function registerKeepAliveHook(hook, type, target = currentInstance) {
+ const wrappedHook = hook.__wdc || (hook.__wdc = () => {
+ let current = target;
+ while (current) {
+ if (current.isDeactivated) {
+ return;
+ }
+ current = current.parent;
+ }
+ return hook();
+ });
+ injectHook(type, wrappedHook, target);
+ if (target) {
+ let current = target.parent;
+ while (current && current.parent) {
+ if (isKeepAlive(current.parent.vnode)) {
+ injectToKeepAliveRoot(wrappedHook, type, target, current);
+ }
+ current = current.parent;
+ }
+ }
+}
+function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+ const injected = injectHook(
+ type,
+ hook,
+ keepAliveRoot,
+ true
+ /* prepend */
+ );
+ onUnmounted(() => {
+ shared.remove(keepAliveRoot[type], injected);
+ }, target);
+}
+function resetShapeFlag(vnode) {
+ vnode.shapeFlag &= ~256;
+ vnode.shapeFlag &= ~512;
+}
+function getInnerChild(vnode) {
+ return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
+}
+
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+ if (target) {
+ const hooks = target[type] || (target[type] = []);
+ const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+ if (target.isUnmounted) {
+ return;
+ }
+ reactivity.pauseTracking();
+ setCurrentInstance(target);
+ const res = callWithAsyncErrorHandling(hook, target, type, args);
+ unsetCurrentInstance();
+ reactivity.resetTracking();
+ return res;
+ });
+ if (prepend) {
+ hooks.unshift(wrappedHook);
+ } else {
+ hooks.push(wrappedHook);
+ }
+ return wrappedHook;
+ } else {
+ const apiName = shared.toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ""));
+ warn(
+ `${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.` )
+ );
+ }
+}
+const createHook = (lifecycle) => (hook, target = currentInstance) => (
+ // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
+ (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
+);
+const onBeforeMount = createHook("bm");
+const onMounted = createHook("m");
+const onBeforeUpdate = createHook("bu");
+const onUpdated = createHook("u");
+const onBeforeUnmount = createHook("bum");
+const onUnmounted = createHook("um");
+const onServerPrefetch = createHook("sp");
+const onRenderTriggered = createHook(
+ "rtg"
+);
+const onRenderTracked = createHook(
+ "rtc"
+);
+function onErrorCaptured(hook, target = currentInstance) {
+ injectHook("ec", hook, target);
+}
+
+function renderList(source, renderItem, cache, index) {
+ let ret;
+ const cached = cache && cache[index];
+ if (shared.isArray(source) || shared.isString(source)) {
+ ret = new Array(source.length);
+ for (let i = 0, l = source.length; i < l; i++) {
+ ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
+ }
+ } else if (typeof source === "number") {
+ if (!Number.isInteger(source)) {
+ warn(`The v-for range expect an integer value but got ${source}.`);
+ }
+ ret = new Array(source);
+ for (let i = 0; i < source; i++) {
+ ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
+ }
+ } else if (shared.isObject(source)) {
+ if (source[Symbol.iterator]) {
+ ret = Array.from(
+ source,
+ (item, i) => renderItem(item, i, void 0, cached && cached[i])
+ );
+ } else {
+ const keys = Object.keys(source);
+ ret = new Array(keys.length);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ const key = keys[i];
+ ret[i] = renderItem(source[key], key, i, cached && cached[i]);
+ }
+ }
+ } else {
+ ret = [];
+ }
+ if (cache) {
+ cache[index] = ret;
+ }
+ return ret;
+}
+
+function createSlots(slots, dynamicSlots) {
+ for (let i = 0; i < dynamicSlots.length; i++) {
+ const slot = dynamicSlots[i];
+ if (shared.isArray(slot)) {
+ for (let j = 0; j < slot.length; j++) {
+ slots[slot[j].name] = slot[j].fn;
+ }
+ } else if (slot) {
+ slots[slot.name] = slot.key ? (...args) => {
+ const res = slot.fn(...args);
+ if (res)
+ res.key = slot.key;
+ return res;
+ } : slot.fn;
+ }
+ }
+ return slots;
+}
+
+function renderSlot(slots, name, props = {}, fallback, noSlotted) {
+ if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
+ if (name !== "default")
+ props.name = name;
+ return createVNode("slot", props, fallback && fallback());
+ }
+ let slot = slots[name];
+ if (slot && slot.length > 1) {
+ warn(
+ `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.`
+ );
+ slot = () => [];
+ }
+ if (slot && slot._c) {
+ slot._d = false;
+ }
+ openBlock();
+ const validSlotContent = slot && ensureValidVNode(slot(props));
+ const rendered = createBlock(
+ Fragment,
+ {
+ key: props.key || // slot content array of a dynamic conditional slot may have a branch
+ // key attached in the `createSlots` helper, respect that
+ validSlotContent && validSlotContent.key || `_${name}`
+ },
+ validSlotContent || (fallback ? fallback() : []),
+ validSlotContent && slots._ === 1 ? 64 : -2
+ );
+ if (!noSlotted && rendered.scopeId) {
+ rendered.slotScopeIds = [rendered.scopeId + "-s"];
+ }
+ if (slot && slot._c) {
+ slot._d = true;
+ }
+ return rendered;
+}
+function ensureValidVNode(vnodes) {
+ return vnodes.some((child) => {
+ if (!isVNode(child))
+ return true;
+ if (child.type === Comment)
+ return false;
+ if (child.type === Fragment && !ensureValidVNode(child.children))
+ return false;
+ return true;
+ }) ? vnodes : null;
+}
+
+function toHandlers(obj, preserveCaseIfNecessary) {
+ const ret = {};
+ if (!shared.isObject(obj)) {
+ warn(`v-on with no argument expects an object value.`);
+ return ret;
+ }
+ for (const key in obj) {
+ ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : shared.toHandlerKey(key)] = obj[key];
+ }
+ return ret;
+}
+
+const getPublicInstance = (i) => {
+ if (!i)
+ return null;
+ if (isStatefulComponent(i))
+ return getExposeProxy(i) || i.proxy;
+ return getPublicInstance(i.parent);
+};
+const publicPropertiesMap = (
+ // Move PURE marker to new line to workaround compiler discarding it
+ // due to type annotation
+ /* @__PURE__ */ shared.extend(/* @__PURE__ */ Object.create(null), {
+ $: (i) => i,
+ $el: (i) => i.vnode.el,
+ $data: (i) => i.data,
+ $props: (i) => reactivity.shallowReadonly(i.props) ,
+ $attrs: (i) => reactivity.shallowReadonly(i.attrs) ,
+ $slots: (i) => reactivity.shallowReadonly(i.slots) ,
+ $refs: (i) => reactivity.shallowReadonly(i.refs) ,
+ $parent: (i) => getPublicInstance(i.parent),
+ $root: (i) => getPublicInstance(i.root),
+ $emit: (i) => i.emit,
+ $options: (i) => resolveMergedOptions(i) ,
+ $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
+ $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+ $watch: (i) => instanceWatch.bind(i)
+ })
+);
+const isReservedPrefix = (key) => key === "_" || key === "$";
+const hasSetupBinding = (state, key) => state !== shared.EMPTY_OBJ && !state.__isScriptSetup && shared.hasOwn(state, key);
+const PublicInstanceProxyHandlers = {
+ get({ _: instance }, key) {
+ const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+ if (key === "__isVue") {
+ return true;
+ }
+ let normalizedProps;
+ if (key[0] !== "$") {
+ const n = accessCache[key];
+ if (n !== void 0) {
+ switch (n) {
+ case 1 /* SETUP */:
+ return setupState[key];
+ case 2 /* DATA */:
+ return data[key];
+ case 4 /* CONTEXT */:
+ return ctx[key];
+ case 3 /* PROPS */:
+ return props[key];
+ }
+ } else if (hasSetupBinding(setupState, key)) {
+ accessCache[key] = 1 /* SETUP */;
+ return setupState[key];
+ } else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
+ accessCache[key] = 2 /* DATA */;
+ return data[key];
+ } else if (
+ // only cache other properties when instance has declared (thus stable)
+ // props
+ (normalizedProps = instance.propsOptions[0]) && shared.hasOwn(normalizedProps, key)
+ ) {
+ accessCache[key] = 3 /* PROPS */;
+ return props[key];
+ } else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
+ accessCache[key] = 4 /* CONTEXT */;
+ return ctx[key];
+ } else if (shouldCacheAccess) {
+ accessCache[key] = 0 /* OTHER */;
+ }
+ }
+ const publicGetter = publicPropertiesMap[key];
+ let cssModule, globalProperties;
+ if (publicGetter) {
+ if (key === "$attrs") {
+ reactivity.track(instance, "get", key);
+ markAttrsAccessed();
+ } else if (key === "$slots") {
+ reactivity.track(instance, "get", key);
+ }
+ return publicGetter(instance);
+ } else if (
+ // css module (injected by vue-loader)
+ (cssModule = type.__cssModules) && (cssModule = cssModule[key])
+ ) {
+ return cssModule;
+ } else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
+ accessCache[key] = 4 /* CONTEXT */;
+ return ctx[key];
+ } else if (
+ // global properties
+ globalProperties = appContext.config.globalProperties, shared.hasOwn(globalProperties, key)
+ ) {
+ {
+ return globalProperties[key];
+ }
+ } else if (currentRenderingInstance && (!shared.isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
+ // to infinite warning loop
+ key.indexOf("__v") !== 0)) {
+ if (data !== shared.EMPTY_OBJ && isReservedPrefix(key[0]) && shared.hasOwn(data, key)) {
+ warn(
+ `Property ${JSON.stringify(
+ key
+ )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+ );
+ } else if (instance === currentRenderingInstance) {
+ warn(
+ `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
+ );
+ }
+ }
+ },
+ set({ _: instance }, key, value) {
+ const { data, setupState, ctx } = instance;
+ if (hasSetupBinding(setupState, key)) {
+ setupState[key] = value;
+ return true;
+ } else if (setupState.__isScriptSetup && shared.hasOwn(setupState, key)) {
+ warn(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+ return false;
+ } else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
+ data[key] = value;
+ return true;
+ } else if (shared.hasOwn(instance.props, key)) {
+ warn(`Attempting to mutate prop "${key}". Props are readonly.`);
+ return false;
+ }
+ if (key[0] === "$" && key.slice(1) in instance) {
+ warn(
+ `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
+ );
+ return false;
+ } else {
+ if (key in instance.appContext.config.globalProperties) {
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ value
+ });
+ } else {
+ ctx[key] = value;
+ }
+ }
+ return true;
+ },
+ has({
+ _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+ }, key) {
+ let normalizedProps;
+ return !!accessCache[key] || data !== shared.EMPTY_OBJ && shared.hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && shared.hasOwn(normalizedProps, key) || shared.hasOwn(ctx, key) || shared.hasOwn(publicPropertiesMap, key) || shared.hasOwn(appContext.config.globalProperties, key);
+ },
+ defineProperty(target, key, descriptor) {
+ if (descriptor.get != null) {
+ target._.accessCache[key] = 0;
+ } else if (shared.hasOwn(descriptor, "value")) {
+ this.set(target, key, descriptor.value, null);
+ }
+ return Reflect.defineProperty(target, key, descriptor);
+ }
+};
+{
+ PublicInstanceProxyHandlers.ownKeys = (target) => {
+ warn(
+ `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
+ );
+ return Reflect.ownKeys(target);
+ };
+}
+const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ shared.extend(
+ {},
+ PublicInstanceProxyHandlers,
+ {
+ get(target, key) {
+ if (key === Symbol.unscopables) {
+ return;
+ }
+ return PublicInstanceProxyHandlers.get(target, key, target);
+ },
+ has(_, key) {
+ const has = key[0] !== "_" && !shared.isGloballyAllowed(key);
+ if (!has && PublicInstanceProxyHandlers.has(_, key)) {
+ warn(
+ `Property ${JSON.stringify(
+ key
+ )} should not start with _ which is a reserved prefix for Vue internals.`
+ );
+ }
+ return has;
+ }
+ }
+);
+function createDevRenderContext(instance) {
+ const target = {};
+ Object.defineProperty(target, `_`, {
+ configurable: true,
+ enumerable: false,
+ get: () => instance
+ });
+ Object.keys(publicPropertiesMap).forEach((key) => {
+ Object.defineProperty(target, key, {
+ configurable: true,
+ enumerable: false,
+ get: () => publicPropertiesMap[key](instance),
+ // intercepted by the proxy so no need for implementation,
+ // but needed to prevent set errors
+ set: shared.NOOP
+ });
+ });
+ return target;
+}
+function exposePropsOnRenderContext(instance) {
+ const {
+ ctx,
+ propsOptions: [propsOptions]
+ } = instance;
+ if (propsOptions) {
+ Object.keys(propsOptions).forEach((key) => {
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => instance.props[key],
+ set: shared.NOOP
+ });
+ });
+ }
+}
+function exposeSetupStateOnRenderContext(instance) {
+ const { ctx, setupState } = instance;
+ Object.keys(reactivity.toRaw(setupState)).forEach((key) => {
+ if (!setupState.__isScriptSetup) {
+ if (isReservedPrefix(key[0])) {
+ warn(
+ `setup() return property ${JSON.stringify(
+ key
+ )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
+ );
+ return;
+ }
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => setupState[key],
+ set: shared.NOOP
+ });
+ }
+ });
+}
+
+const warnRuntimeUsage = (method) => warn(
+ `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
+);
+function defineProps() {
+ {
+ warnRuntimeUsage(`defineProps`);
+ }
+ return null;
+}
+function defineEmits() {
+ {
+ warnRuntimeUsage(`defineEmits`);
+ }
+ return null;
+}
+function defineExpose(exposed) {
+ {
+ warnRuntimeUsage(`defineExpose`);
+ }
+}
+function defineOptions(options) {
+ {
+ warnRuntimeUsage(`defineOptions`);
+ }
+}
+function defineSlots() {
+ {
+ warnRuntimeUsage(`defineSlots`);
+ }
+ return null;
+}
+function defineModel() {
+ {
+ warnRuntimeUsage("defineModel");
+ }
+}
+function withDefaults(props, defaults) {
+ {
+ warnRuntimeUsage(`withDefaults`);
+ }
+ return null;
+}
+function useSlots() {
+ return getContext().slots;
+}
+function useAttrs() {
+ return getContext().attrs;
+}
+function useModel(props, name, options) {
+ const i = getCurrentInstance();
+ if (!i) {
+ warn(`useModel() called without active instance.`);
+ return reactivity.ref();
+ }
+ if (!i.propsOptions[0][name]) {
+ warn(`useModel() called with prop "${name}" which is not declared.`);
+ return reactivity.ref();
+ }
+ if (options && options.local) {
+ const proxy = reactivity.ref(props[name]);
+ watch(
+ () => props[name],
+ (v) => proxy.value = v
+ );
+ watch(proxy, (value) => {
+ if (value !== props[name]) {
+ i.emit(`update:${name}`, value);
+ }
+ });
+ return proxy;
+ } else {
+ return {
+ __v_isRef: true,
+ get value() {
+ return props[name];
+ },
+ set value(value) {
+ i.emit(`update:${name}`, value);
+ }
+ };
+ }
+}
+function getContext() {
+ const i = getCurrentInstance();
+ if (!i) {
+ warn(`useContext() called without active instance.`);
+ }
+ return i.setupContext || (i.setupContext = createSetupContext(i));
+}
+function normalizePropsOrEmits(props) {
+ return shared.isArray(props) ? props.reduce(
+ (normalized, p) => (normalized[p] = null, normalized),
+ {}
+ ) : props;
+}
+function mergeDefaults(raw, defaults) {
+ const props = normalizePropsOrEmits(raw);
+ for (const key in defaults) {
+ if (key.startsWith("__skip"))
+ continue;
+ let opt = props[key];
+ if (opt) {
+ if (shared.isArray(opt) || shared.isFunction(opt)) {
+ opt = props[key] = { type: opt, default: defaults[key] };
+ } else {
+ opt.default = defaults[key];
+ }
+ } else if (opt === null) {
+ opt = props[key] = { default: defaults[key] };
+ } else {
+ warn(`props default key "${key}" has no corresponding declaration.`);
+ }
+ if (opt && defaults[`__skip_${key}`]) {
+ opt.skipFactory = true;
+ }
+ }
+ return props;
+}
+function mergeModels(a, b) {
+ if (!a || !b)
+ return a || b;
+ if (shared.isArray(a) && shared.isArray(b))
+ return a.concat(b);
+ return shared.extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+}
+function createPropsRestProxy(props, excludedKeys) {
+ const ret = {};
+ for (const key in props) {
+ if (!excludedKeys.includes(key)) {
+ Object.defineProperty(ret, key, {
+ enumerable: true,
+ get: () => props[key]
+ });
+ }
+ }
+ return ret;
+}
+function withAsyncContext(getAwaitable) {
+ const ctx = getCurrentInstance();
+ if (!ctx) {
+ warn(
+ `withAsyncContext called without active current instance. This is likely a bug.`
+ );
+ }
+ let awaitable = getAwaitable();
+ unsetCurrentInstance();
+ if (shared.isPromise(awaitable)) {
+ awaitable = awaitable.catch((e) => {
+ setCurrentInstance(ctx);
+ throw e;
+ });
+ }
+ return [awaitable, () => setCurrentInstance(ctx)];
+}
+
+function createDuplicateChecker() {
+ const cache = /* @__PURE__ */ Object.create(null);
+ return (type, key) => {
+ if (cache[key]) {
+ warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
+ } else {
+ cache[key] = type;
+ }
+ };
+}
+let shouldCacheAccess = true;
+function applyOptions(instance) {
+ const options = resolveMergedOptions(instance);
+ const publicThis = instance.proxy;
+ const ctx = instance.ctx;
+ shouldCacheAccess = false;
+ if (options.beforeCreate) {
+ callHook(options.beforeCreate, instance, "bc");
+ }
+ const {
+ // state
+ data: dataOptions,
+ computed: computedOptions,
+ methods,
+ watch: watchOptions,
+ provide: provideOptions,
+ inject: injectOptions,
+ // lifecycle
+ created,
+ beforeMount,
+ mounted,
+ beforeUpdate,
+ updated,
+ activated,
+ deactivated,
+ beforeDestroy,
+ beforeUnmount,
+ destroyed,
+ unmounted,
+ render,
+ renderTracked,
+ renderTriggered,
+ errorCaptured,
+ serverPrefetch,
+ // public API
+ expose,
+ inheritAttrs,
+ // assets
+ components,
+ directives,
+ filters
+ } = options;
+ const checkDuplicateProperties = createDuplicateChecker() ;
+ {
+ const [propsOptions] = instance.propsOptions;
+ if (propsOptions) {
+ for (const key in propsOptions) {
+ checkDuplicateProperties("Props" /* PROPS */, key);
+ }
+ }
+ }
+ if (injectOptions) {
+ resolveInjections(injectOptions, ctx, checkDuplicateProperties);
+ }
+ if (methods) {
+ for (const key in methods) {
+ const methodHandler = methods[key];
+ if (shared.isFunction(methodHandler)) {
+ {
+ Object.defineProperty(ctx, key, {
+ value: methodHandler.bind(publicThis),
+ configurable: true,
+ enumerable: true,
+ writable: true
+ });
+ }
+ {
+ checkDuplicateProperties("Methods" /* METHODS */, key);
+ }
+ } else {
+ warn(
+ `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
+ );
+ }
+ }
+ }
+ if (dataOptions) {
+ if (!shared.isFunction(dataOptions)) {
+ warn(
+ `The data option must be a function. Plain object usage is no longer supported.`
+ );
+ }
+ const data = dataOptions.call(publicThis, publicThis);
+ if (shared.isPromise(data)) {
+ warn(
+ `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
+ );
+ }
+ if (!shared.isObject(data)) {
+ warn(`data() should return an object.`);
+ } else {
+ instance.data = reactivity.reactive(data);
+ {
+ for (const key in data) {
+ checkDuplicateProperties("Data" /* DATA */, key);
+ if (!isReservedPrefix(key[0])) {
+ Object.defineProperty(ctx, key, {
+ configurable: true,
+ enumerable: true,
+ get: () => data[key],
+ set: shared.NOOP
+ });
+ }
+ }
+ }
+ }
+ }
+ shouldCacheAccess = true;
+ if (computedOptions) {
+ for (const key in computedOptions) {
+ const opt = computedOptions[key];
+ const get = shared.isFunction(opt) ? opt.bind(publicThis, publicThis) : shared.isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : shared.NOOP;
+ if (get === shared.NOOP) {
+ warn(`Computed property "${key}" has no getter.`);
+ }
+ const set = !shared.isFunction(opt) && shared.isFunction(opt.set) ? opt.set.bind(publicThis) : () => {
+ warn(
+ `Write operation failed: computed property "${key}" is readonly.`
+ );
+ } ;
+ const c = computed({
+ get,
+ set
+ });
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => c.value,
+ set: (v) => c.value = v
+ });
+ {
+ checkDuplicateProperties("Computed" /* COMPUTED */, key);
+ }
+ }
+ }
+ if (watchOptions) {
+ for (const key in watchOptions) {
+ createWatcher(watchOptions[key], ctx, publicThis, key);
+ }
+ }
+ if (provideOptions) {
+ const provides = shared.isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
+ Reflect.ownKeys(provides).forEach((key) => {
+ provide(key, provides[key]);
+ });
+ }
+ if (created) {
+ callHook(created, instance, "c");
+ }
+ function registerLifecycleHook(register, hook) {
+ if (shared.isArray(hook)) {
+ hook.forEach((_hook) => register(_hook.bind(publicThis)));
+ } else if (hook) {
+ register(hook.bind(publicThis));
+ }
+ }
+ registerLifecycleHook(onBeforeMount, beforeMount);
+ registerLifecycleHook(onMounted, mounted);
+ registerLifecycleHook(onBeforeUpdate, beforeUpdate);
+ registerLifecycleHook(onUpdated, updated);
+ registerLifecycleHook(onActivated, activated);
+ registerLifecycleHook(onDeactivated, deactivated);
+ registerLifecycleHook(onErrorCaptured, errorCaptured);
+ registerLifecycleHook(onRenderTracked, renderTracked);
+ registerLifecycleHook(onRenderTriggered, renderTriggered);
+ registerLifecycleHook(onBeforeUnmount, beforeUnmount);
+ registerLifecycleHook(onUnmounted, unmounted);
+ registerLifecycleHook(onServerPrefetch, serverPrefetch);
+ if (shared.isArray(expose)) {
+ if (expose.length) {
+ const exposed = instance.exposed || (instance.exposed = {});
+ expose.forEach((key) => {
+ Object.defineProperty(exposed, key, {
+ get: () => publicThis[key],
+ set: (val) => publicThis[key] = val
+ });
+ });
+ } else if (!instance.exposed) {
+ instance.exposed = {};
+ }
+ }
+ if (render && instance.render === shared.NOOP) {
+ instance.render = render;
+ }
+ if (inheritAttrs != null) {
+ instance.inheritAttrs = inheritAttrs;
+ }
+ if (components)
+ instance.components = components;
+ if (directives)
+ instance.directives = directives;
+}
+function resolveInjections(injectOptions, ctx, checkDuplicateProperties = shared.NOOP) {
+ if (shared.isArray(injectOptions)) {
+ injectOptions = normalizeInject(injectOptions);
+ }
+ for (const key in injectOptions) {
+ const opt = injectOptions[key];
+ let injected;
+ if (shared.isObject(opt)) {
+ if ("default" in opt) {
+ injected = inject(
+ opt.from || key,
+ opt.default,
+ true
+ /* treat default function as factory */
+ );
+ } else {
+ injected = inject(opt.from || key);
+ }
+ } else {
+ injected = inject(opt);
+ }
+ if (reactivity.isRef(injected)) {
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => injected.value,
+ set: (v) => injected.value = v
+ });
+ } else {
+ ctx[key] = injected;
+ }
+ {
+ checkDuplicateProperties("Inject" /* INJECT */, key);
+ }
+ }
+}
+function callHook(hook, instance, type) {
+ callWithAsyncErrorHandling(
+ shared.isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
+ instance,
+ type
+ );
+}
+function createWatcher(raw, ctx, publicThis, key) {
+ const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+ if (shared.isString(raw)) {
+ const handler = ctx[raw];
+ if (shared.isFunction(handler)) {
+ watch(getter, handler);
+ } else {
+ warn(`Invalid watch handler specified by key "${raw}"`, handler);
+ }
+ } else if (shared.isFunction(raw)) {
+ watch(getter, raw.bind(publicThis));
+ } else if (shared.isObject(raw)) {
+ if (shared.isArray(raw)) {
+ raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
+ } else {
+ const handler = shared.isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
+ if (shared.isFunction(handler)) {
+ watch(getter, handler, raw);
+ } else {
+ warn(`Invalid watch handler specified by key "${raw.handler}"`, handler);
+ }
+ }
+ } else {
+ warn(`Invalid watch option: "${key}"`, raw);
+ }
+}
+function resolveMergedOptions(instance) {
+ const base = instance.type;
+ const { mixins, extends: extendsOptions } = base;
+ const {
+ mixins: globalMixins,
+ optionsCache: cache,
+ config: { optionMergeStrategies }
+ } = instance.appContext;
+ const cached = cache.get(base);
+ let resolved;
+ if (cached) {
+ resolved = cached;
+ } else if (!globalMixins.length && !mixins && !extendsOptions) {
+ {
+ resolved = base;
+ }
+ } else {
+ resolved = {};
+ if (globalMixins.length) {
+ globalMixins.forEach(
+ (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
+ );
+ }
+ mergeOptions(resolved, base, optionMergeStrategies);
+ }
+ if (shared.isObject(base)) {
+ cache.set(base, resolved);
+ }
+ return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+ const { mixins, extends: extendsOptions } = from;
+ if (extendsOptions) {
+ mergeOptions(to, extendsOptions, strats, true);
+ }
+ if (mixins) {
+ mixins.forEach(
+ (m) => mergeOptions(to, m, strats, true)
+ );
+ }
+ for (const key in from) {
+ if (asMixin && key === "expose") {
+ warn(
+ `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
+ );
+ } else {
+ const strat = internalOptionMergeStrats[key] || strats && strats[key];
+ to[key] = strat ? strat(to[key], from[key]) : from[key];
+ }
+ }
+ return to;
+}
+const internalOptionMergeStrats = {
+ data: mergeDataFn,
+ props: mergeEmitsOrPropsOptions,
+ emits: mergeEmitsOrPropsOptions,
+ // objects
+ methods: mergeObjectOptions,
+ computed: mergeObjectOptions,
+ // lifecycle
+ beforeCreate: mergeAsArray,
+ created: mergeAsArray,
+ beforeMount: mergeAsArray,
+ mounted: mergeAsArray,
+ beforeUpdate: mergeAsArray,
+ updated: mergeAsArray,
+ beforeDestroy: mergeAsArray,
+ beforeUnmount: mergeAsArray,
+ destroyed: mergeAsArray,
+ unmounted: mergeAsArray,
+ activated: mergeAsArray,
+ deactivated: mergeAsArray,
+ errorCaptured: mergeAsArray,
+ serverPrefetch: mergeAsArray,
+ // assets
+ components: mergeObjectOptions,
+ directives: mergeObjectOptions,
+ // watch
+ watch: mergeWatchOptions,
+ // provide / inject
+ provide: mergeDataFn,
+ inject: mergeInject
+};
+function mergeDataFn(to, from) {
+ if (!from) {
+ return to;
+ }
+ if (!to) {
+ return from;
+ }
+ return function mergedDataFn() {
+ return (shared.extend)(
+ shared.isFunction(to) ? to.call(this, this) : to,
+ shared.isFunction(from) ? from.call(this, this) : from
+ );
+ };
+}
+function mergeInject(to, from) {
+ return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+ if (shared.isArray(raw)) {
+ const res = {};
+ for (let i = 0; i < raw.length; i++) {
+ res[raw[i]] = raw[i];
+ }
+ return res;
+ }
+ return raw;
+}
+function mergeAsArray(to, from) {
+ return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+ return to ? shared.extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+}
+function mergeEmitsOrPropsOptions(to, from) {
+ if (to) {
+ if (shared.isArray(to) && shared.isArray(from)) {
+ return [.../* @__PURE__ */ new Set([...to, ...from])];
+ }
+ return shared.extend(
+ /* @__PURE__ */ Object.create(null),
+ normalizePropsOrEmits(to),
+ normalizePropsOrEmits(from != null ? from : {})
+ );
+ } else {
+ return from;
+ }
+}
+function mergeWatchOptions(to, from) {
+ if (!to)
+ return from;
+ if (!from)
+ return to;
+ const merged = shared.extend(/* @__PURE__ */ Object.create(null), to);
+ for (const key in from) {
+ merged[key] = mergeAsArray(to[key], from[key]);
+ }
+ return merged;
+}
+
+function createAppContext() {
+ return {
+ app: null,
+ config: {
+ isNativeTag: shared.NO,
+ performance: false,
+ globalProperties: {},
+ optionMergeStrategies: {},
+ errorHandler: void 0,
+ warnHandler: void 0,
+ compilerOptions: {}
+ },
+ mixins: [],
+ components: {},
+ directives: {},
+ provides: /* @__PURE__ */ Object.create(null),
+ optionsCache: /* @__PURE__ */ new WeakMap(),
+ propsCache: /* @__PURE__ */ new WeakMap(),
+ emitsCache: /* @__PURE__ */ new WeakMap()
+ };
+}
+let uid$1 = 0;
+function createAppAPI(render, hydrate) {
+ return function createApp(rootComponent, rootProps = null) {
+ if (!shared.isFunction(rootComponent)) {
+ rootComponent = shared.extend({}, rootComponent);
+ }
+ if (rootProps != null && !shared.isObject(rootProps)) {
+ warn(`root props passed to app.mount() must be an object.`);
+ rootProps = null;
+ }
+ const context = createAppContext();
+ {
+ Object.defineProperty(context.config, "unwrapInjectedRef", {
+ get() {
+ return true;
+ },
+ set() {
+ warn(
+ `app.config.unwrapInjectedRef has been deprecated. 3.3 now always unwraps injected refs in Options API.`
+ );
+ }
+ });
+ }
+ const installedPlugins = /* @__PURE__ */ new WeakSet();
+ let isMounted = false;
+ const app = context.app = {
+ _uid: uid$1++,
+ _component: rootComponent,
+ _props: rootProps,
+ _container: null,
+ _context: context,
+ _instance: null,
+ version,
+ get config() {
+ return context.config;
+ },
+ set config(v) {
+ {
+ warn(
+ `app.config cannot be replaced. Modify individual options instead.`
+ );
+ }
+ },
+ use(plugin, ...options) {
+ if (installedPlugins.has(plugin)) {
+ warn(`Plugin has already been applied to target app.`);
+ } else if (plugin && shared.isFunction(plugin.install)) {
+ installedPlugins.add(plugin);
+ plugin.install(app, ...options);
+ } else if (shared.isFunction(plugin)) {
+ installedPlugins.add(plugin);
+ plugin(app, ...options);
+ } else {
+ warn(
+ `A plugin must either be a function or an object with an "install" function.`
+ );
+ }
+ return app;
+ },
+ mixin(mixin) {
+ {
+ if (!context.mixins.includes(mixin)) {
+ context.mixins.push(mixin);
+ } else {
+ warn(
+ "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
+ );
+ }
+ }
+ return app;
+ },
+ component(name, component) {
+ {
+ validateComponentName(name, context.config);
+ }
+ if (!component) {
+ return context.components[name];
+ }
+ if (context.components[name]) {
+ warn(`Component "${name}" has already been registered in target app.`);
+ }
+ context.components[name] = component;
+ return app;
+ },
+ directive(name, directive) {
+ {
+ validateDirectiveName(name);
+ }
+ if (!directive) {
+ return context.directives[name];
+ }
+ if (context.directives[name]) {
+ warn(`Directive "${name}" has already been registered in target app.`);
+ }
+ context.directives[name] = directive;
+ return app;
+ },
+ mount(rootContainer, isHydrate, isSVG) {
+ if (!isMounted) {
+ if (rootContainer.__vue_app__) {
+ warn(
+ `There is already an app instance mounted on the host container.
+ If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
+ );
+ }
+ const vnode = createVNode(rootComponent, rootProps);
+ vnode.appContext = context;
+ {
+ context.reload = () => {
+ render(cloneVNode(vnode), rootContainer, isSVG);
+ };
+ }
+ if (isHydrate && hydrate) {
+ hydrate(vnode, rootContainer);
+ } else {
+ render(vnode, rootContainer, isSVG);
+ }
+ isMounted = true;
+ app._container = rootContainer;
+ rootContainer.__vue_app__ = app;
+ {
+ app._instance = vnode.component;
+ devtoolsInitApp(app, version);
+ }
+ return getExposeProxy(vnode.component) || vnode.component.proxy;
+ } else {
+ warn(
+ `App has already been mounted.
+If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
+ );
+ }
+ },
+ unmount() {
+ if (isMounted) {
+ render(null, app._container);
+ {
+ app._instance = null;
+ devtoolsUnmountApp(app);
+ }
+ delete app._container.__vue_app__;
+ } else {
+ warn(`Cannot unmount an app that is not mounted.`);
+ }
+ },
+ provide(key, value) {
+ if (key in context.provides) {
+ warn(
+ `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
+ );
+ }
+ context.provides[key] = value;
+ return app;
+ },
+ runWithContext(fn) {
+ currentApp = app;
+ try {
+ return fn();
+ } finally {
+ currentApp = null;
+ }
+ }
+ };
+ return app;
+ };
+}
+let currentApp = null;
+
+function provide(key, value) {
+ if (!currentInstance) {
+ {
+ warn(`provide() can only be used inside setup().`);
+ }
+ } else {
+ let provides = currentInstance.provides;
+ const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+ if (parentProvides === provides) {
+ provides = currentInstance.provides = Object.create(parentProvides);
+ }
+ provides[key] = value;
+ }
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+ const instance = currentInstance || currentRenderingInstance;
+ if (instance || currentApp) {
+ const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+ if (provides && key in provides) {
+ return provides[key];
+ } else if (arguments.length > 1) {
+ return treatDefaultAsFactory && shared.isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+ } else {
+ warn(`injection "${String(key)}" not found.`);
+ }
+ } else {
+ warn(`inject() can only be used inside setup() or functional components.`);
+ }
+}
+function hasInjectionContext() {
+ return !!(currentInstance || currentRenderingInstance || currentApp);
+}
+
+function initProps(instance, rawProps, isStateful, isSSR = false) {
+ const props = {};
+ const attrs = {};
+ shared.def(attrs, InternalObjectKey, 1);
+ instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+ setFullProps(instance, rawProps, props, attrs);
+ for (const key in instance.propsOptions[0]) {
+ if (!(key in props)) {
+ props[key] = void 0;
+ }
+ }
+ {
+ validateProps(rawProps || {}, props, instance);
+ }
+ if (isStateful) {
+ instance.props = isSSR ? props : reactivity.shallowReactive(props);
+ } else {
+ if (!instance.type.props) {
+ instance.props = attrs;
+ } else {
+ instance.props = props;
+ }
+ }
+ instance.attrs = attrs;
+}
+function isInHmrContext(instance) {
+ while (instance) {
+ if (instance.type.__hmrId)
+ return true;
+ instance = instance.parent;
+ }
+}
+function updateProps(instance, rawProps, rawPrevProps, optimized) {
+ const {
+ props,
+ attrs,
+ vnode: { patchFlag }
+ } = instance;
+ const rawCurrentProps = reactivity.toRaw(props);
+ const [options] = instance.propsOptions;
+ let hasAttrsChanged = false;
+ if (
+ // always force full diff in dev
+ // - #1942 if hmr is enabled with sfc component
+ // - vite#872 non-sfc component used by sfc component
+ !isInHmrContext(instance) && (optimized || patchFlag > 0) && !(patchFlag & 16)
+ ) {
+ if (patchFlag & 8) {
+ const propsToUpdate = instance.vnode.dynamicProps;
+ for (let i = 0; i < propsToUpdate.length; i++) {
+ let key = propsToUpdate[i];
+ if (isEmitListener(instance.emitsOptions, key)) {
+ continue;
+ }
+ const value = rawProps[key];
+ if (options) {
+ if (shared.hasOwn(attrs, key)) {
+ if (value !== attrs[key]) {
+ attrs[key] = value;
+ hasAttrsChanged = true;
+ }
+ } else {
+ const camelizedKey = shared.camelize(key);
+ props[camelizedKey] = resolvePropValue(
+ options,
+ rawCurrentProps,
+ camelizedKey,
+ value,
+ instance,
+ false
+ /* isAbsent */
+ );
+ }
+ } else {
+ if (value !== attrs[key]) {
+ attrs[key] = value;
+ hasAttrsChanged = true;
+ }
+ }
+ }
+ }
+ } else {
+ if (setFullProps(instance, rawProps, props, attrs)) {
+ hasAttrsChanged = true;
+ }
+ let kebabKey;
+ for (const key in rawCurrentProps) {
+ if (!rawProps || // for camelCase
+ !shared.hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+ // and converted to camelCase (#955)
+ ((kebabKey = shared.hyphenate(key)) === key || !shared.hasOwn(rawProps, kebabKey))) {
+ if (options) {
+ if (rawPrevProps && // for camelCase
+ (rawPrevProps[key] !== void 0 || // for kebab-case
+ rawPrevProps[kebabKey] !== void 0)) {
+ props[key] = resolvePropValue(
+ options,
+ rawCurrentProps,
+ key,
+ void 0,
+ instance,
+ true
+ /* isAbsent */
+ );
+ }
+ } else {
+ delete props[key];
+ }
+ }
+ }
+ if (attrs !== rawCurrentProps) {
+ for (const key in attrs) {
+ if (!rawProps || !shared.hasOwn(rawProps, key) && true) {
+ delete attrs[key];
+ hasAttrsChanged = true;
+ }
+ }
+ }
+ }
+ if (hasAttrsChanged) {
+ reactivity.trigger(instance, "set", "$attrs");
+ }
+ {
+ validateProps(rawProps || {}, props, instance);
+ }
+}
+function setFullProps(instance, rawProps, props, attrs) {
+ const [options, needCastKeys] = instance.propsOptions;
+ let hasAttrsChanged = false;
+ let rawCastValues;
+ if (rawProps) {
+ for (let key in rawProps) {
+ if (shared.isReservedProp(key)) {
+ continue;
+ }
+ const value = rawProps[key];
+ let camelKey;
+ if (options && shared.hasOwn(options, camelKey = shared.camelize(key))) {
+ if (!needCastKeys || !needCastKeys.includes(camelKey)) {
+ props[camelKey] = value;
+ } else {
+ (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+ }
+ } else if (!isEmitListener(instance.emitsOptions, key)) {
+ if (!(key in attrs) || value !== attrs[key]) {
+ attrs[key] = value;
+ hasAttrsChanged = true;
+ }
+ }
+ }
+ }
+ if (needCastKeys) {
+ const rawCurrentProps = reactivity.toRaw(props);
+ const castValues = rawCastValues || shared.EMPTY_OBJ;
+ for (let i = 0; i < needCastKeys.length; i++) {
+ const key = needCastKeys[i];
+ props[key] = resolvePropValue(
+ options,
+ rawCurrentProps,
+ key,
+ castValues[key],
+ instance,
+ !shared.hasOwn(castValues, key)
+ );
+ }
+ }
+ return hasAttrsChanged;
+}
+function resolvePropValue(options, props, key, value, instance, isAbsent) {
+ const opt = options[key];
+ if (opt != null) {
+ const hasDefault = shared.hasOwn(opt, "default");
+ if (hasDefault && value === void 0) {
+ const defaultValue = opt.default;
+ if (opt.type !== Function && !opt.skipFactory && shared.isFunction(defaultValue)) {
+ const { propsDefaults } = instance;
+ if (key in propsDefaults) {
+ value = propsDefaults[key];
+ } else {
+ setCurrentInstance(instance);
+ value = propsDefaults[key] = defaultValue.call(
+ null,
+ props
+ );
+ unsetCurrentInstance();
+ }
+ } else {
+ value = defaultValue;
+ }
+ }
+ if (opt[0 /* shouldCast */]) {
+ if (isAbsent && !hasDefault) {
+ value = false;
+ } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === shared.hyphenate(key))) {
+ value = true;
+ }
+ }
+ }
+ return value;
+}
+function normalizePropsOptions(comp, appContext, asMixin = false) {
+ const cache = appContext.propsCache;
+ const cached = cache.get(comp);
+ if (cached) {
+ return cached;
+ }
+ const raw = comp.props;
+ const normalized = {};
+ const needCastKeys = [];
+ let hasExtends = false;
+ if (!shared.isFunction(comp)) {
+ const extendProps = (raw2) => {
+ hasExtends = true;
+ const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+ shared.extend(normalized, props);
+ if (keys)
+ needCastKeys.push(...keys);
+ };
+ if (!asMixin && appContext.mixins.length) {
+ appContext.mixins.forEach(extendProps);
+ }
+ if (comp.extends) {
+ extendProps(comp.extends);
+ }
+ if (comp.mixins) {
+ comp.mixins.forEach(extendProps);
+ }
+ }
+ if (!raw && !hasExtends) {
+ if (shared.isObject(comp)) {
+ cache.set(comp, shared.EMPTY_ARR);
+ }
+ return shared.EMPTY_ARR;
+ }
+ if (shared.isArray(raw)) {
+ for (let i = 0; i < raw.length; i++) {
+ if (!shared.isString(raw[i])) {
+ warn(`props must be strings when using array syntax.`, raw[i]);
+ }
+ const normalizedKey = shared.camelize(raw[i]);
+ if (validatePropName(normalizedKey)) {
+ normalized[normalizedKey] = shared.EMPTY_OBJ;
+ }
+ }
+ } else if (raw) {
+ if (!shared.isObject(raw)) {
+ warn(`invalid props options`, raw);
+ }
+ for (const key in raw) {
+ const normalizedKey = shared.camelize(key);
+ if (validatePropName(normalizedKey)) {
+ const opt = raw[key];
+ const prop = normalized[normalizedKey] = shared.isArray(opt) || shared.isFunction(opt) ? { type: opt } : shared.extend({}, opt);
+ if (prop) {
+ const booleanIndex = getTypeIndex(Boolean, prop.type);
+ const stringIndex = getTypeIndex(String, prop.type);
+ prop[0 /* shouldCast */] = booleanIndex > -1;
+ prop[1 /* shouldCastTrue */] = stringIndex < 0 || booleanIndex < stringIndex;
+ if (booleanIndex > -1 || shared.hasOwn(prop, "default")) {
+ needCastKeys.push(normalizedKey);
+ }
+ }
+ }
+ }
+ }
+ const res = [normalized, needCastKeys];
+ if (shared.isObject(comp)) {
+ cache.set(comp, res);
+ }
+ return res;
+}
+function validatePropName(key) {
+ if (key[0] !== "$") {
+ return true;
+ } else {
+ warn(`Invalid prop name: "${key}" is a reserved property.`);
+ }
+ return false;
+}
+function getType(ctor) {
+ const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
+ return match ? match[2] : ctor === null ? "null" : "";
+}
+function isSameType(a, b) {
+ return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+ if (shared.isArray(expectedTypes)) {
+ return expectedTypes.findIndex((t) => isSameType(t, type));
+ } else if (shared.isFunction(expectedTypes)) {
+ return isSameType(expectedTypes, type) ? 0 : -1;
+ }
+ return -1;
+}
+function validateProps(rawProps, props, instance) {
+ const resolvedValues = reactivity.toRaw(props);
+ const options = instance.propsOptions[0];
+ for (const key in options) {
+ let opt = options[key];
+ if (opt == null)
+ continue;
+ validateProp(
+ key,
+ resolvedValues[key],
+ opt,
+ !shared.hasOwn(rawProps, key) && !shared.hasOwn(rawProps, shared.hyphenate(key))
+ );
+ }
+}
+function validateProp(name, value, prop, isAbsent) {
+ const { type, required, validator, skipCheck } = prop;
+ if (required && isAbsent) {
+ warn('Missing required prop: "' + name + '"');
+ return;
+ }
+ if (value == null && !required) {
+ return;
+ }
+ if (type != null && type !== true && !skipCheck) {
+ let isValid = false;
+ const types = shared.isArray(type) ? type : [type];
+ const expectedTypes = [];
+ for (let i = 0; i < types.length && !isValid; i++) {
+ const { valid, expectedType } = assertType(value, types[i]);
+ expectedTypes.push(expectedType || "");
+ isValid = valid;
+ }
+ if (!isValid) {
+ warn(getInvalidTypeMessage(name, value, expectedTypes));
+ return;
+ }
+ }
+ if (validator && !validator(value)) {
+ warn('Invalid prop: custom validator check failed for prop "' + name + '".');
+ }
+}
+const isSimpleType = /* @__PURE__ */ shared.makeMap(
+ "String,Number,Boolean,Function,Symbol,BigInt"
+);
+function assertType(value, type) {
+ let valid;
+ const expectedType = getType(type);
+ if (isSimpleType(expectedType)) {
+ const t = typeof value;
+ valid = t === expectedType.toLowerCase();
+ if (!valid && t === "object") {
+ valid = value instanceof type;
+ }
+ } else if (expectedType === "Object") {
+ valid = shared.isObject(value);
+ } else if (expectedType === "Array") {
+ valid = shared.isArray(value);
+ } else if (expectedType === "null") {
+ valid = value === null;
+ } else {
+ valid = value instanceof type;
+ }
+ return {
+ valid,
+ expectedType
+ };
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+ if (expectedTypes.length === 0) {
+ return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
+ }
+ let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(shared.capitalize).join(" | ")}`;
+ const expectedType = expectedTypes[0];
+ const receivedType = shared.toRawType(value);
+ const expectedValue = styleValue(value, expectedType);
+ const receivedValue = styleValue(value, receivedType);
+ if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
+ message += ` with value ${expectedValue}`;
+ }
+ message += `, got ${receivedType} `;
+ if (isExplicable(receivedType)) {
+ message += `with value ${receivedValue}.`;
+ }
+ return message;
+}
+function styleValue(value, type) {
+ if (type === "String") {
+ return `"${value}"`;
+ } else if (type === "Number") {
+ return `${Number(value)}`;
+ } else {
+ return `${value}`;
+ }
+}
+function isExplicable(type) {
+ const explicitTypes = ["string", "number", "boolean"];
+ return explicitTypes.some((elem) => type.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+ return args.some((elem) => elem.toLowerCase() === "boolean");
+}
+
+const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+const normalizeSlotValue = (value) => shared.isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+const normalizeSlot = (key, rawSlot, ctx) => {
+ if (rawSlot._n) {
+ return rawSlot;
+ }
+ const normalized = withCtx((...args) => {
+ if (currentInstance) {
+ warn(
+ `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
+ );
+ }
+ return normalizeSlotValue(rawSlot(...args));
+ }, ctx);
+ normalized._c = false;
+ return normalized;
+};
+const normalizeObjectSlots = (rawSlots, slots, instance) => {
+ const ctx = rawSlots._ctx;
+ for (const key in rawSlots) {
+ if (isInternalKey(key))
+ continue;
+ const value = rawSlots[key];
+ if (shared.isFunction(value)) {
+ slots[key] = normalizeSlot(key, value, ctx);
+ } else if (value != null) {
+ {
+ warn(
+ `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
+ );
+ }
+ const normalized = normalizeSlotValue(value);
+ slots[key] = () => normalized;
+ }
+ }
+};
+const normalizeVNodeSlots = (instance, children) => {
+ if (!isKeepAlive(instance.vnode) && true) {
+ warn(
+ `Non-function value encountered for default slot. Prefer function slots for better performance.`
+ );
+ }
+ const normalized = normalizeSlotValue(children);
+ instance.slots.default = () => normalized;
+};
+const initSlots = (instance, children) => {
+ if (instance.vnode.shapeFlag & 32) {
+ const type = children._;
+ if (type) {
+ instance.slots = reactivity.toRaw(children);
+ shared.def(children, "_", type);
+ } else {
+ normalizeObjectSlots(
+ children,
+ instance.slots = {});
+ }
+ } else {
+ instance.slots = {};
+ if (children) {
+ normalizeVNodeSlots(instance, children);
+ }
+ }
+ shared.def(instance.slots, InternalObjectKey, 1);
+};
+const updateSlots = (instance, children, optimized) => {
+ const { vnode, slots } = instance;
+ let needDeletionCheck = true;
+ let deletionComparisonTarget = shared.EMPTY_OBJ;
+ if (vnode.shapeFlag & 32) {
+ const type = children._;
+ if (type) {
+ if (isHmrUpdating) {
+ shared.extend(slots, children);
+ reactivity.trigger(instance, "set", "$slots");
+ } else if (optimized && type === 1) {
+ needDeletionCheck = false;
+ } else {
+ shared.extend(slots, children);
+ if (!optimized && type === 1) {
+ delete slots._;
+ }
+ }
+ } else {
+ needDeletionCheck = !children.$stable;
+ normalizeObjectSlots(children, slots);
+ }
+ deletionComparisonTarget = children;
+ } else if (children) {
+ normalizeVNodeSlots(instance, children);
+ deletionComparisonTarget = { default: 1 };
+ }
+ if (needDeletionCheck) {
+ for (const key in slots) {
+ if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
+ delete slots[key];
+ }
+ }
+ }
+};
+
+function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
+ if (shared.isArray(rawRef)) {
+ rawRef.forEach(
+ (r, i) => setRef(
+ r,
+ oldRawRef && (shared.isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
+ parentSuspense,
+ vnode,
+ isUnmount
+ )
+ );
+ return;
+ }
+ if (isAsyncWrapper(vnode) && !isUnmount) {
+ return;
+ }
+ const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
+ const value = isUnmount ? null : refValue;
+ const { i: owner, r: ref } = rawRef;
+ if (!owner) {
+ warn(
+ `Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`
+ );
+ return;
+ }
+ const oldRef = oldRawRef && oldRawRef.r;
+ const refs = owner.refs === shared.EMPTY_OBJ ? owner.refs = {} : owner.refs;
+ const setupState = owner.setupState;
+ if (oldRef != null && oldRef !== ref) {
+ if (shared.isString(oldRef)) {
+ refs[oldRef] = null;
+ if (shared.hasOwn(setupState, oldRef)) {
+ setupState[oldRef] = null;
+ }
+ } else if (reactivity.isRef(oldRef)) {
+ oldRef.value = null;
+ }
+ }
+ if (shared.isFunction(ref)) {
+ callWithErrorHandling(ref, owner, 12, [value, refs]);
+ } else {
+ const _isString = shared.isString(ref);
+ const _isRef = reactivity.isRef(ref);
+ if (_isString || _isRef) {
+ const doSet = () => {
+ if (rawRef.f) {
+ const existing = _isString ? shared.hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
+ if (isUnmount) {
+ shared.isArray(existing) && shared.remove(existing, refValue);
+ } else {
+ if (!shared.isArray(existing)) {
+ if (_isString) {
+ refs[ref] = [refValue];
+ if (shared.hasOwn(setupState, ref)) {
+ setupState[ref] = refs[ref];
+ }
+ } else {
+ ref.value = [refValue];
+ if (rawRef.k)
+ refs[rawRef.k] = ref.value;
+ }
+ } else if (!existing.includes(refValue)) {
+ existing.push(refValue);
+ }
+ }
+ } else if (_isString) {
+ refs[ref] = value;
+ if (shared.hasOwn(setupState, ref)) {
+ setupState[ref] = value;
+ }
+ } else if (_isRef) {
+ ref.value = value;
+ if (rawRef.k)
+ refs[rawRef.k] = value;
+ } else {
+ warn("Invalid template ref type:", ref, `(${typeof ref})`);
+ }
+ };
+ if (value) {
+ doSet.id = -1;
+ queuePostRenderEffect(doSet, parentSuspense);
+ } else {
+ doSet();
+ }
+ } else {
+ warn("Invalid template ref type:", ref, `(${typeof ref})`);
+ }
+ }
+}
+
+let hasMismatch = false;
+const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== "foreignObject";
+const isComment = (node) => node.nodeType === 8 /* COMMENT */;
+function createHydrationFunctions(rendererInternals) {
+ const {
+ mt: mountComponent,
+ p: patch,
+ o: {
+ patchProp,
+ createText,
+ nextSibling,
+ parentNode,
+ remove,
+ insert,
+ createComment
+ }
+ } = rendererInternals;
+ const hydrate = (vnode, container) => {
+ if (!container.hasChildNodes()) {
+ warn(
+ `Attempting to hydrate existing markup but container is empty. Performing full mount instead.`
+ );
+ patch(null, vnode, container);
+ flushPostFlushCbs();
+ container._vnode = vnode;
+ return;
+ }
+ hasMismatch = false;
+ hydrateNode(container.firstChild, vnode, null, null, null);
+ flushPostFlushCbs();
+ container._vnode = vnode;
+ if (hasMismatch && true) {
+ console.error(`Hydration completed but contains mismatches.`);
+ }
+ };
+ const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
+ const isFragmentStart = isComment(node) && node.data === "[";
+ const onMismatch = () => handleMismatch(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ isFragmentStart
+ );
+ const { type, ref, shapeFlag, patchFlag } = vnode;
+ let domType = node.nodeType;
+ vnode.el = node;
+ {
+ if (!("__vnode" in node)) {
+ Object.defineProperty(node, "__vnode", {
+ value: vnode,
+ enumerable: false
+ });
+ }
+ if (!("__vueParentComponent" in node)) {
+ Object.defineProperty(node, "__vueParentComponent", {
+ value: parentComponent,
+ enumerable: false
+ });
+ }
+ }
+ if (patchFlag === -2) {
+ optimized = false;
+ vnode.dynamicChildren = null;
+ }
+ let nextNode = null;
+ switch (type) {
+ case Text:
+ if (domType !== 3 /* TEXT */) {
+ if (vnode.children === "") {
+ insert(vnode.el = createText(""), parentNode(node), node);
+ nextNode = node;
+ } else {
+ nextNode = onMismatch();
+ }
+ } else {
+ if (node.data !== vnode.children) {
+ hasMismatch = true;
+ warn(
+ `Hydration text mismatch:
+- Server rendered: ${JSON.stringify(
+ node.data
+ )}
+- Client rendered: ${JSON.stringify(vnode.children)}`
+ );
+ node.data = vnode.children;
+ }
+ nextNode = nextSibling(node);
+ }
+ break;
+ case Comment:
+ if (isTemplateNode(node)) {
+ nextNode = nextSibling(node);
+ replaceNode(
+ vnode.el = node.content.firstChild,
+ node,
+ parentComponent
+ );
+ } else if (domType !== 8 /* COMMENT */ || isFragmentStart) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = nextSibling(node);
+ }
+ break;
+ case Static:
+ if (isFragmentStart) {
+ node = nextSibling(node);
+ domType = node.nodeType;
+ }
+ if (domType === 1 /* ELEMENT */ || domType === 3 /* TEXT */) {
+ nextNode = node;
+ const needToAdoptContent = !vnode.children.length;
+ for (let i = 0; i < vnode.staticCount; i++) {
+ if (needToAdoptContent)
+ vnode.children += nextNode.nodeType === 1 /* ELEMENT */ ? nextNode.outerHTML : nextNode.data;
+ if (i === vnode.staticCount - 1) {
+ vnode.anchor = nextNode;
+ }
+ nextNode = nextSibling(nextNode);
+ }
+ return isFragmentStart ? nextSibling(nextNode) : nextNode;
+ } else {
+ onMismatch();
+ }
+ break;
+ case Fragment:
+ if (!isFragmentStart) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = hydrateFragment(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ }
+ break;
+ default:
+ if (shapeFlag & 1) {
+ if ((domType !== 1 /* ELEMENT */ || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = hydrateElement(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ }
+ } else if (shapeFlag & 6) {
+ vnode.slotScopeIds = slotScopeIds;
+ const container = parentNode(node);
+ if (isFragmentStart) {
+ nextNode = locateClosingAnchor(node);
+ } else if (isComment(node) && node.data === "teleport start") {
+ nextNode = locateClosingAnchor(node, node.data, "teleport end");
+ } else {
+ nextNode = nextSibling(node);
+ }
+ mountComponent(
+ vnode,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(container),
+ optimized
+ );
+ if (isAsyncWrapper(vnode)) {
+ let subTree;
+ if (isFragmentStart) {
+ subTree = createVNode(Fragment);
+ subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
+ } else {
+ subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
+ }
+ subTree.el = node;
+ vnode.component.subTree = subTree;
+ }
+ } else if (shapeFlag & 64) {
+ if (domType !== 8 /* COMMENT */) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = vnode.type.hydrate(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized,
+ rendererInternals,
+ hydrateChildren
+ );
+ }
+ } else if (shapeFlag & 128) {
+ nextNode = vnode.type.hydrate(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(parentNode(node)),
+ slotScopeIds,
+ optimized,
+ rendererInternals,
+ hydrateNode
+ );
+ } else {
+ warn("Invalid HostVNode type:", type, `(${typeof type})`);
+ }
+ }
+ if (ref != null) {
+ setRef(ref, null, parentSuspense, vnode);
+ }
+ return nextNode;
+ };
+ const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+ optimized = optimized || !!vnode.dynamicChildren;
+ const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
+ const forcePatch = type === "input" || type === "option";
+ {
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "created");
+ }
+ if (props) {
+ if (forcePatch || !optimized || patchFlag & (16 | 32)) {
+ for (const key in props) {
+ if (forcePatch && (key.endsWith("value") || key === "indeterminate") || shared.isOn(key) && !shared.isReservedProp(key) || // force hydrate v-bind with .prop modifiers
+ key[0] === ".") {
+ patchProp(
+ el,
+ key,
+ null,
+ props[key],
+ false,
+ void 0,
+ parentComponent
+ );
+ }
+ }
+ } else if (props.onClick) {
+ patchProp(
+ el,
+ "onClick",
+ null,
+ props.onClick,
+ false,
+ void 0,
+ parentComponent
+ );
+ }
+ }
+ let vnodeHooks;
+ if (vnodeHooks = props && props.onVnodeBeforeMount) {
+ invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+ }
+ let needCallTransitionHooks = false;
+ if (isTemplateNode(el)) {
+ needCallTransitionHooks = needTransition(parentSuspense, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
+ const content = el.content.firstChild;
+ if (needCallTransitionHooks) {
+ transition.beforeEnter(content);
+ }
+ replaceNode(content, el, parentComponent);
+ vnode.el = el = content;
+ }
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+ }
+ if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
+ queueEffectWithSuspense(() => {
+ vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+ needCallTransitionHooks && transition.enter(el);
+ dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+ }, parentSuspense);
+ }
+ if (shapeFlag & 16 && // skip if element has innerHTML / textContent
+ !(props && (props.innerHTML || props.textContent))) {
+ let next = hydrateChildren(
+ el.firstChild,
+ vnode,
+ el,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ let hasWarned = false;
+ while (next) {
+ hasMismatch = true;
+ if (!hasWarned) {
+ warn(
+ `Hydration children mismatch in <${vnode.type}>: server rendered element contains more child nodes than client vdom.`
+ );
+ hasWarned = true;
+ }
+ const cur = next;
+ next = next.nextSibling;
+ remove(cur);
+ }
+ } else if (shapeFlag & 8) {
+ if (el.textContent !== vnode.children) {
+ hasMismatch = true;
+ warn(
+ `Hydration text content mismatch in <${vnode.type}>:
+- Server rendered: ${el.textContent}
+- Client rendered: ${vnode.children}`
+ );
+ el.textContent = vnode.children;
+ }
+ }
+ }
+ return el.nextSibling;
+ };
+ const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+ optimized = optimized || !!parentVNode.dynamicChildren;
+ const children = parentVNode.children;
+ const l = children.length;
+ let hasWarned = false;
+ for (let i = 0; i < l; i++) {
+ const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
+ if (node) {
+ node = hydrateNode(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ } else if (vnode.type === Text && !vnode.children) {
+ continue;
+ } else {
+ hasMismatch = true;
+ if (!hasWarned) {
+ warn(
+ `Hydration children mismatch in <${container.tagName.toLowerCase()}>: server rendered element contains fewer child nodes than client vdom.`
+ );
+ hasWarned = true;
+ }
+ patch(
+ null,
+ vnode,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(container),
+ slotScopeIds
+ );
+ }
+ }
+ return node;
+ };
+ const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+ const { slotScopeIds: fragmentSlotScopeIds } = vnode;
+ if (fragmentSlotScopeIds) {
+ slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+ }
+ const container = parentNode(node);
+ const next = hydrateChildren(
+ nextSibling(node),
+ vnode,
+ container,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ if (next && isComment(next) && next.data === "]") {
+ return nextSibling(vnode.anchor = next);
+ } else {
+ hasMismatch = true;
+ insert(vnode.anchor = createComment(`]`), container, next);
+ return next;
+ }
+ };
+ const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
+ hasMismatch = true;
+ warn(
+ `Hydration node mismatch:
+- Client vnode:`,
+ vnode.type,
+ `
+- Server rendered DOM:`,
+ node,
+ node.nodeType === 3 /* TEXT */ ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``
+ );
+ vnode.el = null;
+ if (isFragment) {
+ const end = locateClosingAnchor(node);
+ while (true) {
+ const next2 = nextSibling(node);
+ if (next2 && next2 !== end) {
+ remove(next2);
+ } else {
+ break;
+ }
+ }
+ }
+ const next = nextSibling(node);
+ const container = parentNode(node);
+ remove(node);
+ patch(
+ null,
+ vnode,
+ container,
+ next,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(container),
+ slotScopeIds
+ );
+ return next;
+ };
+ const locateClosingAnchor = (node, open = "[", close = "]") => {
+ let match = 0;
+ while (node) {
+ node = nextSibling(node);
+ if (node && isComment(node)) {
+ if (node.data === open)
+ match++;
+ if (node.data === close) {
+ if (match === 0) {
+ return nextSibling(node);
+ } else {
+ match--;
+ }
+ }
+ }
+ }
+ return node;
+ };
+ const replaceNode = (newNode, oldNode, parentComponent) => {
+ const parentNode2 = oldNode.parentNode;
+ if (parentNode2) {
+ parentNode2.replaceChild(newNode, oldNode);
+ }
+ let parent = parentComponent;
+ while (parent) {
+ if (parent.vnode.el === oldNode) {
+ parent.vnode.el = parent.subTree.el = newNode;
+ }
+ parent = parent.parent;
+ }
+ };
+ const isTemplateNode = (node) => {
+ return node.nodeType === 1 /* ELEMENT */ && node.tagName.toLowerCase() === "template";
+ };
+ return [hydrate, hydrateNode];
+}
+
+let supported;
+let perf;
+function startMeasure(instance, type) {
+ if (instance.appContext.config.performance && isSupported()) {
+ perf.mark(`vue-${type}-${instance.uid}`);
+ }
+ {
+ devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+ }
+}
+function endMeasure(instance, type) {
+ if (instance.appContext.config.performance && isSupported()) {
+ const startTag = `vue-${type}-${instance.uid}`;
+ const endTag = startTag + `:end`;
+ perf.mark(endTag);
+ perf.measure(
+ `<${formatComponentName(instance, instance.type)}> ${type}`,
+ startTag,
+ endTag
+ );
+ perf.clearMarks(startTag);
+ perf.clearMarks(endTag);
+ }
+ {
+ devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+ }
+}
+function isSupported() {
+ if (supported !== void 0) {
+ return supported;
+ }
+ if (typeof window !== "undefined" && window.performance) {
+ supported = true;
+ perf = window.performance;
+ } else {
+ supported = false;
+ }
+ return supported;
+}
+
+const queuePostRenderEffect = queueEffectWithSuspense ;
+function createRenderer(options) {
+ return baseCreateRenderer(options);
+}
+function createHydrationRenderer(options) {
+ return baseCreateRenderer(options, createHydrationFunctions);
+}
+function baseCreateRenderer(options, createHydrationFns) {
+ const target = shared.getGlobalThis();
+ target.__VUE__ = true;
+ {
+ setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+ }
+ const {
+ insert: hostInsert,
+ remove: hostRemove,
+ patchProp: hostPatchProp,
+ createElement: hostCreateElement,
+ createText: hostCreateText,
+ createComment: hostCreateComment,
+ setText: hostSetText,
+ setElementText: hostSetElementText,
+ parentNode: hostParentNode,
+ nextSibling: hostNextSibling,
+ setScopeId: hostSetScopeId = shared.NOOP,
+ insertStaticContent: hostInsertStaticContent
+ } = options;
+ const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = isHmrUpdating ? false : !!n2.dynamicChildren) => {
+ if (n1 === n2) {
+ return;
+ }
+ if (n1 && !isSameVNodeType(n1, n2)) {
+ anchor = getNextHostNode(n1);
+ unmount(n1, parentComponent, parentSuspense, true);
+ n1 = null;
+ }
+ if (n2.patchFlag === -2) {
+ optimized = false;
+ n2.dynamicChildren = null;
+ }
+ const { type, ref, shapeFlag } = n2;
+ switch (type) {
+ case Text:
+ processText(n1, n2, container, anchor);
+ break;
+ case Comment:
+ processCommentNode(n1, n2, container, anchor);
+ break;
+ case Static:
+ if (n1 == null) {
+ mountStaticNode(n2, container, anchor, isSVG);
+ } else {
+ patchStaticNode(n1, n2, container, isSVG);
+ }
+ break;
+ case Fragment:
+ processFragment(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ break;
+ default:
+ if (shapeFlag & 1) {
+ processElement(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else if (shapeFlag & 6) {
+ processComponent(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else if (shapeFlag & 64) {
+ type.process(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ internals
+ );
+ } else if (shapeFlag & 128) {
+ type.process(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ internals
+ );
+ } else {
+ warn("Invalid VNode type:", type, `(${typeof type})`);
+ }
+ }
+ if (ref != null && parentComponent) {
+ setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
+ }
+ };
+ const processText = (n1, n2, container, anchor) => {
+ if (n1 == null) {
+ hostInsert(
+ n2.el = hostCreateText(n2.children),
+ container,
+ anchor
+ );
+ } else {
+ const el = n2.el = n1.el;
+ if (n2.children !== n1.children) {
+ hostSetText(el, n2.children);
+ }
+ }
+ };
+ const processCommentNode = (n1, n2, container, anchor) => {
+ if (n1 == null) {
+ hostInsert(
+ n2.el = hostCreateComment(n2.children || ""),
+ container,
+ anchor
+ );
+ } else {
+ n2.el = n1.el;
+ }
+ };
+ const mountStaticNode = (n2, container, anchor, isSVG) => {
+ [n2.el, n2.anchor] = hostInsertStaticContent(
+ n2.children,
+ container,
+ anchor,
+ isSVG,
+ n2.el,
+ n2.anchor
+ );
+ };
+ const patchStaticNode = (n1, n2, container, isSVG) => {
+ if (n2.children !== n1.children) {
+ const anchor = hostNextSibling(n1.anchor);
+ removeStaticNode(n1);
+ [n2.el, n2.anchor] = hostInsertStaticContent(
+ n2.children,
+ container,
+ anchor,
+ isSVG
+ );
+ } else {
+ n2.el = n1.el;
+ n2.anchor = n1.anchor;
+ }
+ };
+ const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
+ let next;
+ while (el && el !== anchor) {
+ next = hostNextSibling(el);
+ hostInsert(el, container, nextSibling);
+ el = next;
+ }
+ hostInsert(anchor, container, nextSibling);
+ };
+ const removeStaticNode = ({ el, anchor }) => {
+ let next;
+ while (el && el !== anchor) {
+ next = hostNextSibling(el);
+ hostRemove(el);
+ el = next;
+ }
+ hostRemove(anchor);
+ };
+ const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ isSVG = isSVG || n2.type === "svg";
+ if (n1 == null) {
+ mountElement(
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ patchElement(
+ n1,
+ n2,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ let el;
+ let vnodeHook;
+ const { type, props, shapeFlag, transition, dirs } = vnode;
+ el = vnode.el = hostCreateElement(
+ vnode.type,
+ isSVG,
+ props && props.is,
+ props
+ );
+ if (shapeFlag & 8) {
+ hostSetElementText(el, vnode.children);
+ } else if (shapeFlag & 16) {
+ mountChildren(
+ vnode.children,
+ el,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG && type !== "foreignObject",
+ slotScopeIds,
+ optimized
+ );
+ }
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "created");
+ }
+ setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
+ if (props) {
+ for (const key in props) {
+ if (key !== "value" && !shared.isReservedProp(key)) {
+ hostPatchProp(
+ el,
+ key,
+ null,
+ props[key],
+ isSVG,
+ vnode.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ if ("value" in props) {
+ hostPatchProp(el, "value", null, props.value);
+ }
+ if (vnodeHook = props.onVnodeBeforeMount) {
+ invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ }
+ }
+ {
+ Object.defineProperty(el, "__vnode", {
+ value: vnode,
+ enumerable: false
+ });
+ Object.defineProperty(el, "__vueParentComponent", {
+ value: parentComponent,
+ enumerable: false
+ });
+ }
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+ }
+ const needCallTransitionHooks = needTransition(parentSuspense, transition);
+ if (needCallTransitionHooks) {
+ transition.beforeEnter(el);
+ }
+ hostInsert(el, container, anchor);
+ if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
+ queuePostRenderEffect(() => {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ needCallTransitionHooks && transition.enter(el);
+ dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+ }, parentSuspense);
+ }
+ };
+ const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
+ if (scopeId) {
+ hostSetScopeId(el, scopeId);
+ }
+ if (slotScopeIds) {
+ for (let i = 0; i < slotScopeIds.length; i++) {
+ hostSetScopeId(el, slotScopeIds[i]);
+ }
+ }
+ if (parentComponent) {
+ let subTree = parentComponent.subTree;
+ if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
+ subTree = filterSingleRoot(subTree.children) || subTree;
+ }
+ if (vnode === subTree) {
+ const parentVNode = parentComponent.vnode;
+ setScopeId(
+ el,
+ parentVNode,
+ parentVNode.scopeId,
+ parentVNode.slotScopeIds,
+ parentComponent.parent
+ );
+ }
+ }
+ };
+ const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => {
+ for (let i = start; i < children.length; i++) {
+ const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
+ patch(
+ null,
+ child,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ const el = n2.el = n1.el;
+ let { patchFlag, dynamicChildren, dirs } = n2;
+ patchFlag |= n1.patchFlag & 16;
+ const oldProps = n1.props || shared.EMPTY_OBJ;
+ const newProps = n2.props || shared.EMPTY_OBJ;
+ let vnodeHook;
+ parentComponent && toggleRecurse(parentComponent, false);
+ if (vnodeHook = newProps.onVnodeBeforeUpdate) {
+ invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+ }
+ if (dirs) {
+ invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
+ }
+ parentComponent && toggleRecurse(parentComponent, true);
+ if (isHmrUpdating) {
+ patchFlag = 0;
+ optimized = false;
+ dynamicChildren = null;
+ }
+ const areChildrenSVG = isSVG && n2.type !== "foreignObject";
+ if (dynamicChildren) {
+ patchBlockChildren(
+ n1.dynamicChildren,
+ dynamicChildren,
+ el,
+ parentComponent,
+ parentSuspense,
+ areChildrenSVG,
+ slotScopeIds
+ );
+ {
+ traverseStaticChildren(n1, n2);
+ }
+ } else if (!optimized) {
+ patchChildren(
+ n1,
+ n2,
+ el,
+ null,
+ parentComponent,
+ parentSuspense,
+ areChildrenSVG,
+ slotScopeIds,
+ false
+ );
+ }
+ if (patchFlag > 0) {
+ if (patchFlag & 16) {
+ patchProps(
+ el,
+ n2,
+ oldProps,
+ newProps,
+ parentComponent,
+ parentSuspense,
+ isSVG
+ );
+ } else {
+ if (patchFlag & 2) {
+ if (oldProps.class !== newProps.class) {
+ hostPatchProp(el, "class", null, newProps.class, isSVG);
+ }
+ }
+ if (patchFlag & 4) {
+ hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);
+ }
+ if (patchFlag & 8) {
+ const propsToUpdate = n2.dynamicProps;
+ for (let i = 0; i < propsToUpdate.length; i++) {
+ const key = propsToUpdate[i];
+ const prev = oldProps[key];
+ const next = newProps[key];
+ if (next !== prev || key === "value") {
+ hostPatchProp(
+ el,
+ key,
+ prev,
+ next,
+ isSVG,
+ n1.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ }
+ }
+ if (patchFlag & 1) {
+ if (n1.children !== n2.children) {
+ hostSetElementText(el, n2.children);
+ }
+ }
+ } else if (!optimized && dynamicChildren == null) {
+ patchProps(
+ el,
+ n2,
+ oldProps,
+ newProps,
+ parentComponent,
+ parentSuspense,
+ isSVG
+ );
+ }
+ if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
+ queuePostRenderEffect(() => {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+ dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
+ }, parentSuspense);
+ }
+ };
+ const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {
+ for (let i = 0; i < newChildren.length; i++) {
+ const oldVNode = oldChildren[i];
+ const newVNode = newChildren[i];
+ const container = (
+ // oldVNode may be an errored async setup() component inside Suspense
+ // which will not have a mounted element
+ oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
+ // of the Fragment itself so it can move its children.
+ (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
+ // which also requires the correct parent container
+ !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
+ oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
+ // In other cases, the parent container is not actually used so we
+ // just pass the block element here to avoid a DOM parentNode call.
+ fallbackContainer
+ )
+ );
+ patch(
+ oldVNode,
+ newVNode,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ true
+ );
+ }
+ };
+ const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
+ if (oldProps !== newProps) {
+ if (oldProps !== shared.EMPTY_OBJ) {
+ for (const key in oldProps) {
+ if (!shared.isReservedProp(key) && !(key in newProps)) {
+ hostPatchProp(
+ el,
+ key,
+ oldProps[key],
+ null,
+ isSVG,
+ vnode.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ }
+ for (const key in newProps) {
+ if (shared.isReservedProp(key))
+ continue;
+ const next = newProps[key];
+ const prev = oldProps[key];
+ if (next !== prev && key !== "value") {
+ hostPatchProp(
+ el,
+ key,
+ prev,
+ next,
+ isSVG,
+ vnode.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ if ("value" in newProps) {
+ hostPatchProp(el, "value", oldProps.value, newProps.value);
+ }
+ }
+ };
+ const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
+ const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
+ let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
+ if (
+ // #5523 dev root fragment may inherit directives
+ isHmrUpdating || patchFlag & 2048
+ ) {
+ patchFlag = 0;
+ optimized = false;
+ dynamicChildren = null;
+ }
+ if (fragmentSlotScopeIds) {
+ slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+ }
+ if (n1 == null) {
+ hostInsert(fragmentStartAnchor, container, anchor);
+ hostInsert(fragmentEndAnchor, container, anchor);
+ mountChildren(
+ n2.children,
+ container,
+ fragmentEndAnchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
+ // of renderSlot() with no valid children
+ n1.dynamicChildren) {
+ patchBlockChildren(
+ n1.dynamicChildren,
+ dynamicChildren,
+ container,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds
+ );
+ {
+ traverseStaticChildren(n1, n2);
+ }
+ } else {
+ patchChildren(
+ n1,
+ n2,
+ container,
+ fragmentEndAnchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ }
+ };
+ const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ n2.slotScopeIds = slotScopeIds;
+ if (n1 == null) {
+ if (n2.shapeFlag & 512) {
+ parentComponent.ctx.activate(
+ n2,
+ container,
+ anchor,
+ isSVG,
+ optimized
+ );
+ } else {
+ mountComponent(
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ optimized
+ );
+ }
+ } else {
+ updateComponent(n1, n2, optimized);
+ }
+ };
+ const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
+ const instance = (initialVNode.component = createComponentInstance(
+ initialVNode,
+ parentComponent,
+ parentSuspense
+ ));
+ if (instance.type.__hmrId) {
+ registerHMR(instance);
+ }
+ {
+ pushWarningContext(initialVNode);
+ startMeasure(instance, `mount`);
+ }
+ if (isKeepAlive(initialVNode)) {
+ instance.ctx.renderer = internals;
+ }
+ {
+ {
+ startMeasure(instance, `init`);
+ }
+ setupComponent(instance);
+ {
+ endMeasure(instance, `init`);
+ }
+ }
+ if (instance.asyncDep) {
+ parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
+ if (!initialVNode.el) {
+ const placeholder = instance.subTree = createVNode(Comment);
+ processCommentNode(null, placeholder, container, anchor);
+ }
+ return;
+ }
+ setupRenderEffect(
+ instance,
+ initialVNode,
+ container,
+ anchor,
+ parentSuspense,
+ isSVG,
+ optimized
+ );
+ {
+ popWarningContext();
+ endMeasure(instance, `mount`);
+ }
+ };
+ const updateComponent = (n1, n2, optimized) => {
+ const instance = n2.component = n1.component;
+ if (shouldUpdateComponent(n1, n2, optimized)) {
+ if (instance.asyncDep && !instance.asyncResolved) {
+ {
+ pushWarningContext(n2);
+ }
+ updateComponentPreRender(instance, n2, optimized);
+ {
+ popWarningContext();
+ }
+ return;
+ } else {
+ instance.next = n2;
+ invalidateJob(instance.update);
+ instance.update();
+ }
+ } else {
+ n2.el = n1.el;
+ instance.vnode = n2;
+ }
+ };
+ const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
+ const componentUpdateFn = () => {
+ if (!instance.isMounted) {
+ let vnodeHook;
+ const { el, props } = initialVNode;
+ const { bm, m, parent } = instance;
+ const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
+ toggleRecurse(instance, false);
+ if (bm) {
+ shared.invokeArrayFns(bm);
+ }
+ if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
+ invokeVNodeHook(vnodeHook, parent, initialVNode);
+ }
+ toggleRecurse(instance, true);
+ if (el && hydrateNode) {
+ const hydrateSubTree = () => {
+ {
+ startMeasure(instance, `render`);
+ }
+ instance.subTree = renderComponentRoot(instance);
+ {
+ endMeasure(instance, `render`);
+ }
+ {
+ startMeasure(instance, `hydrate`);
+ }
+ hydrateNode(
+ el,
+ instance.subTree,
+ instance,
+ parentSuspense,
+ null
+ );
+ {
+ endMeasure(instance, `hydrate`);
+ }
+ };
+ if (isAsyncWrapperVNode) {
+ initialVNode.type.__asyncLoader().then(
+ // note: we are moving the render call into an async callback,
+ // which means it won't track dependencies - but it's ok because
+ // a server-rendered async wrapper is already in resolved state
+ // and it will never need to change.
+ () => !instance.isUnmounted && hydrateSubTree()
+ );
+ } else {
+ hydrateSubTree();
+ }
+ } else {
+ {
+ startMeasure(instance, `render`);
+ }
+ const subTree = instance.subTree = renderComponentRoot(instance);
+ {
+ endMeasure(instance, `render`);
+ }
+ {
+ startMeasure(instance, `patch`);
+ }
+ patch(
+ null,
+ subTree,
+ container,
+ anchor,
+ instance,
+ parentSuspense,
+ isSVG
+ );
+ {
+ endMeasure(instance, `patch`);
+ }
+ initialVNode.el = subTree.el;
+ }
+ if (m) {
+ queuePostRenderEffect(m, parentSuspense);
+ }
+ if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
+ const scopedInitialVNode = initialVNode;
+ queuePostRenderEffect(
+ () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
+ parentSuspense
+ );
+ }
+ if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
+ instance.a && queuePostRenderEffect(instance.a, parentSuspense);
+ }
+ instance.isMounted = true;
+ {
+ devtoolsComponentAdded(instance);
+ }
+ initialVNode = container = anchor = null;
+ } else {
+ let { next, bu, u, parent, vnode } = instance;
+ let originNext = next;
+ let vnodeHook;
+ {
+ pushWarningContext(next || instance.vnode);
+ }
+ toggleRecurse(instance, false);
+ if (next) {
+ next.el = vnode.el;
+ updateComponentPreRender(instance, next, optimized);
+ } else {
+ next = vnode;
+ }
+ if (bu) {
+ shared.invokeArrayFns(bu);
+ }
+ if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
+ invokeVNodeHook(vnodeHook, parent, next, vnode);
+ }
+ toggleRecurse(instance, true);
+ {
+ startMeasure(instance, `render`);
+ }
+ const nextTree = renderComponentRoot(instance);
+ {
+ endMeasure(instance, `render`);
+ }
+ const prevTree = instance.subTree;
+ instance.subTree = nextTree;
+ {
+ startMeasure(instance, `patch`);
+ }
+ patch(
+ prevTree,
+ nextTree,
+ // parent may have changed if it's in a teleport
+ hostParentNode(prevTree.el),
+ // anchor may have changed if it's in a fragment
+ getNextHostNode(prevTree),
+ instance,
+ parentSuspense,
+ isSVG
+ );
+ {
+ endMeasure(instance, `patch`);
+ }
+ next.el = nextTree.el;
+ if (originNext === null) {
+ updateHOCHostEl(instance, nextTree.el);
+ }
+ if (u) {
+ queuePostRenderEffect(u, parentSuspense);
+ }
+ if (vnodeHook = next.props && next.props.onVnodeUpdated) {
+ queuePostRenderEffect(
+ () => invokeVNodeHook(vnodeHook, parent, next, vnode),
+ parentSuspense
+ );
+ }
+ {
+ devtoolsComponentUpdated(instance);
+ }
+ {
+ popWarningContext();
+ }
+ }
+ };
+ const effect = instance.effect = new reactivity.ReactiveEffect(
+ componentUpdateFn,
+ () => queueJob(update),
+ instance.scope
+ // track it in component's effect scope
+ );
+ const update = instance.update = () => effect.run();
+ update.id = instance.uid;
+ toggleRecurse(instance, true);
+ {
+ effect.onTrack = instance.rtc ? (e) => shared.invokeArrayFns(instance.rtc, e) : void 0;
+ effect.onTrigger = instance.rtg ? (e) => shared.invokeArrayFns(instance.rtg, e) : void 0;
+ update.ownerInstance = instance;
+ }
+ update();
+ };
+ const updateComponentPreRender = (instance, nextVNode, optimized) => {
+ nextVNode.component = instance;
+ const prevProps = instance.vnode.props;
+ instance.vnode = nextVNode;
+ instance.next = null;
+ updateProps(instance, nextVNode.props, prevProps, optimized);
+ updateSlots(instance, nextVNode.children, optimized);
+ reactivity.pauseTracking();
+ flushPreFlushCbs();
+ reactivity.resetTracking();
+ };
+ const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {
+ const c1 = n1 && n1.children;
+ const prevShapeFlag = n1 ? n1.shapeFlag : 0;
+ const c2 = n2.children;
+ const { patchFlag, shapeFlag } = n2;
+ if (patchFlag > 0) {
+ if (patchFlag & 128) {
+ patchKeyedChildren(
+ c1,
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ return;
+ } else if (patchFlag & 256) {
+ patchUnkeyedChildren(
+ c1,
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ return;
+ }
+ }
+ if (shapeFlag & 8) {
+ if (prevShapeFlag & 16) {
+ unmountChildren(c1, parentComponent, parentSuspense);
+ }
+ if (c2 !== c1) {
+ hostSetElementText(container, c2);
+ }
+ } else {
+ if (prevShapeFlag & 16) {
+ if (shapeFlag & 16) {
+ patchKeyedChildren(
+ c1,
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ unmountChildren(c1, parentComponent, parentSuspense, true);
+ }
+ } else {
+ if (prevShapeFlag & 8) {
+ hostSetElementText(container, "");
+ }
+ if (shapeFlag & 16) {
+ mountChildren(
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ }
+ }
+ };
+ const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ c1 = c1 || shared.EMPTY_ARR;
+ c2 = c2 || shared.EMPTY_ARR;
+ const oldLength = c1.length;
+ const newLength = c2.length;
+ const commonLength = Math.min(oldLength, newLength);
+ let i;
+ for (i = 0; i < commonLength; i++) {
+ const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+ patch(
+ c1[i],
+ nextChild,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ if (oldLength > newLength) {
+ unmountChildren(
+ c1,
+ parentComponent,
+ parentSuspense,
+ true,
+ false,
+ commonLength
+ );
+ } else {
+ mountChildren(
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ commonLength
+ );
+ }
+ };
+ const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ let i = 0;
+ const l2 = c2.length;
+ let e1 = c1.length - 1;
+ let e2 = l2 - 1;
+ while (i <= e1 && i <= e2) {
+ const n1 = c1[i];
+ const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+ if (isSameVNodeType(n1, n2)) {
+ patch(
+ n1,
+ n2,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ break;
+ }
+ i++;
+ }
+ while (i <= e1 && i <= e2) {
+ const n1 = c1[e1];
+ const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
+ if (isSameVNodeType(n1, n2)) {
+ patch(
+ n1,
+ n2,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ break;
+ }
+ e1--;
+ e2--;
+ }
+ if (i > e1) {
+ if (i <= e2) {
+ const nextPos = e2 + 1;
+ const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
+ while (i <= e2) {
+ patch(
+ null,
+ c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ i++;
+ }
+ }
+ } else if (i > e2) {
+ while (i <= e1) {
+ unmount(c1[i], parentComponent, parentSuspense, true);
+ i++;
+ }
+ } else {
+ const s1 = i;
+ const s2 = i;
+ const keyToNewIndexMap = /* @__PURE__ */ new Map();
+ for (i = s2; i <= e2; i++) {
+ const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+ if (nextChild.key != null) {
+ if (keyToNewIndexMap.has(nextChild.key)) {
+ warn(
+ `Duplicate keys found during update:`,
+ JSON.stringify(nextChild.key),
+ `Make sure keys are unique.`
+ );
+ }
+ keyToNewIndexMap.set(nextChild.key, i);
+ }
+ }
+ let j;
+ let patched = 0;
+ const toBePatched = e2 - s2 + 1;
+ let moved = false;
+ let maxNewIndexSoFar = 0;
+ const newIndexToOldIndexMap = new Array(toBePatched);
+ for (i = 0; i < toBePatched; i++)
+ newIndexToOldIndexMap[i] = 0;
+ for (i = s1; i <= e1; i++) {
+ const prevChild = c1[i];
+ if (patched >= toBePatched) {
+ unmount(prevChild, parentComponent, parentSuspense, true);
+ continue;
+ }
+ let newIndex;
+ if (prevChild.key != null) {
+ newIndex = keyToNewIndexMap.get(prevChild.key);
+ } else {
+ for (j = s2; j <= e2; j++) {
+ if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
+ newIndex = j;
+ break;
+ }
+ }
+ }
+ if (newIndex === void 0) {
+ unmount(prevChild, parentComponent, parentSuspense, true);
+ } else {
+ newIndexToOldIndexMap[newIndex - s2] = i + 1;
+ if (newIndex >= maxNewIndexSoFar) {
+ maxNewIndexSoFar = newIndex;
+ } else {
+ moved = true;
+ }
+ patch(
+ prevChild,
+ c2[newIndex],
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ patched++;
+ }
+ }
+ const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : shared.EMPTY_ARR;
+ j = increasingNewIndexSequence.length - 1;
+ for (i = toBePatched - 1; i >= 0; i--) {
+ const nextIndex = s2 + i;
+ const nextChild = c2[nextIndex];
+ const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
+ if (newIndexToOldIndexMap[i] === 0) {
+ patch(
+ null,
+ nextChild,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else if (moved) {
+ if (j < 0 || i !== increasingNewIndexSequence[j]) {
+ move(nextChild, container, anchor, 2);
+ } else {
+ j--;
+ }
+ }
+ }
+ }
+ };
+ const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
+ const { el, type, transition, children, shapeFlag } = vnode;
+ if (shapeFlag & 6) {
+ move(vnode.component.subTree, container, anchor, moveType);
+ return;
+ }
+ if (shapeFlag & 128) {
+ vnode.suspense.move(container, anchor, moveType);
+ return;
+ }
+ if (shapeFlag & 64) {
+ type.move(vnode, container, anchor, internals);
+ return;
+ }
+ if (type === Fragment) {
+ hostInsert(el, container, anchor);
+ for (let i = 0; i < children.length; i++) {
+ move(children[i], container, anchor, moveType);
+ }
+ hostInsert(vnode.anchor, container, anchor);
+ return;
+ }
+ if (type === Static) {
+ moveStaticNode(vnode, container, anchor);
+ return;
+ }
+ const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
+ if (needTransition2) {
+ if (moveType === 0) {
+ transition.beforeEnter(el);
+ hostInsert(el, container, anchor);
+ queuePostRenderEffect(() => transition.enter(el), parentSuspense);
+ } else {
+ const { leave, delayLeave, afterLeave } = transition;
+ const remove2 = () => hostInsert(el, container, anchor);
+ const performLeave = () => {
+ leave(el, () => {
+ remove2();
+ afterLeave && afterLeave();
+ });
+ };
+ if (delayLeave) {
+ delayLeave(el, remove2, performLeave);
+ } else {
+ performLeave();
+ }
+ }
+ } else {
+ hostInsert(el, container, anchor);
+ }
+ };
+ const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
+ const {
+ type,
+ props,
+ ref,
+ children,
+ dynamicChildren,
+ shapeFlag,
+ patchFlag,
+ dirs
+ } = vnode;
+ if (ref != null) {
+ setRef(ref, null, parentSuspense, vnode, true);
+ }
+ if (shapeFlag & 256) {
+ parentComponent.ctx.deactivate(vnode);
+ return;
+ }
+ const shouldInvokeDirs = shapeFlag & 1 && dirs;
+ const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
+ let vnodeHook;
+ if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
+ invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ }
+ if (shapeFlag & 6) {
+ unmountComponent(vnode.component, parentSuspense, doRemove);
+ } else {
+ if (shapeFlag & 128) {
+ vnode.suspense.unmount(parentSuspense, doRemove);
+ return;
+ }
+ if (shouldInvokeDirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
+ }
+ if (shapeFlag & 64) {
+ vnode.type.remove(
+ vnode,
+ parentComponent,
+ parentSuspense,
+ optimized,
+ internals,
+ doRemove
+ );
+ } else if (dynamicChildren && // #1153: fast path should not be taken for non-stable (v-for) fragments
+ (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
+ unmountChildren(
+ dynamicChildren,
+ parentComponent,
+ parentSuspense,
+ false,
+ true
+ );
+ } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
+ unmountChildren(children, parentComponent, parentSuspense);
+ }
+ if (doRemove) {
+ remove(vnode);
+ }
+ }
+ if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
+ queuePostRenderEffect(() => {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
+ }, parentSuspense);
+ }
+ };
+ const remove = (vnode) => {
+ const { type, el, anchor, transition } = vnode;
+ if (type === Fragment) {
+ if (vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) {
+ vnode.children.forEach((child) => {
+ if (child.type === Comment) {
+ hostRemove(child.el);
+ } else {
+ remove(child);
+ }
+ });
+ } else {
+ removeFragment(el, anchor);
+ }
+ return;
+ }
+ if (type === Static) {
+ removeStaticNode(vnode);
+ return;
+ }
+ const performRemove = () => {
+ hostRemove(el);
+ if (transition && !transition.persisted && transition.afterLeave) {
+ transition.afterLeave();
+ }
+ };
+ if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
+ const { leave, delayLeave } = transition;
+ const performLeave = () => leave(el, performRemove);
+ if (delayLeave) {
+ delayLeave(vnode.el, performRemove, performLeave);
+ } else {
+ performLeave();
+ }
+ } else {
+ performRemove();
+ }
+ };
+ const removeFragment = (cur, end) => {
+ let next;
+ while (cur !== end) {
+ next = hostNextSibling(cur);
+ hostRemove(cur);
+ cur = next;
+ }
+ hostRemove(end);
+ };
+ const unmountComponent = (instance, parentSuspense, doRemove) => {
+ if (instance.type.__hmrId) {
+ unregisterHMR(instance);
+ }
+ const { bum, scope, update, subTree, um } = instance;
+ if (bum) {
+ shared.invokeArrayFns(bum);
+ }
+ scope.stop();
+ if (update) {
+ update.active = false;
+ unmount(subTree, instance, parentSuspense, doRemove);
+ }
+ if (um) {
+ queuePostRenderEffect(um, parentSuspense);
+ }
+ queuePostRenderEffect(() => {
+ instance.isUnmounted = true;
+ }, parentSuspense);
+ if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
+ parentSuspense.deps--;
+ if (parentSuspense.deps === 0) {
+ parentSuspense.resolve();
+ }
+ }
+ {
+ devtoolsComponentRemoved(instance);
+ }
+ };
+ const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
+ for (let i = start; i < children.length; i++) {
+ unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
+ }
+ };
+ const getNextHostNode = (vnode) => {
+ if (vnode.shapeFlag & 6) {
+ return getNextHostNode(vnode.component.subTree);
+ }
+ if (vnode.shapeFlag & 128) {
+ return vnode.suspense.next();
+ }
+ return hostNextSibling(vnode.anchor || vnode.el);
+ };
+ const render = (vnode, container, isSVG) => {
+ if (vnode == null) {
+ if (container._vnode) {
+ unmount(container._vnode, null, null, true);
+ }
+ } else {
+ patch(container._vnode || null, vnode, container, null, null, null, isSVG);
+ }
+ flushPreFlushCbs();
+ flushPostFlushCbs();
+ container._vnode = vnode;
+ };
+ const internals = {
+ p: patch,
+ um: unmount,
+ m: move,
+ r: remove,
+ mt: mountComponent,
+ mc: mountChildren,
+ pc: patchChildren,
+ pbc: patchBlockChildren,
+ n: getNextHostNode,
+ o: options
+ };
+ let hydrate;
+ let hydrateNode;
+ if (createHydrationFns) {
+ [hydrate, hydrateNode] = createHydrationFns(
+ internals
+ );
+ }
+ return {
+ render,
+ hydrate,
+ createApp: createAppAPI(render, hydrate)
+ };
+}
+function toggleRecurse({ effect, update }, allowed) {
+ effect.allowRecurse = update.allowRecurse = allowed;
+}
+function needTransition(parentSuspense, transition) {
+ return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
+}
+function traverseStaticChildren(n1, n2, shallow = false) {
+ const ch1 = n1.children;
+ const ch2 = n2.children;
+ if (shared.isArray(ch1) && shared.isArray(ch2)) {
+ for (let i = 0; i < ch1.length; i++) {
+ const c1 = ch1[i];
+ let c2 = ch2[i];
+ if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
+ if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
+ c2 = ch2[i] = cloneIfMounted(ch2[i]);
+ c2.el = c1.el;
+ }
+ if (!shallow)
+ traverseStaticChildren(c1, c2);
+ }
+ if (c2.type === Text) {
+ c2.el = c1.el;
+ }
+ if (c2.type === Comment && !c2.el) {
+ c2.el = c1.el;
+ }
+ }
+ }
+}
+function getSequence(arr) {
+ const p = arr.slice();
+ const result = [0];
+ let i, j, u, v, c;
+ const len = arr.length;
+ for (i = 0; i < len; i++) {
+ const arrI = arr[i];
+ if (arrI !== 0) {
+ j = result[result.length - 1];
+ if (arr[j] < arrI) {
+ p[i] = j;
+ result.push(i);
+ continue;
+ }
+ u = 0;
+ v = result.length - 1;
+ while (u < v) {
+ c = u + v >> 1;
+ if (arr[result[c]] < arrI) {
+ u = c + 1;
+ } else {
+ v = c;
+ }
+ }
+ if (arrI < arr[result[u]]) {
+ if (u > 0) {
+ p[i] = result[u - 1];
+ }
+ result[u] = i;
+ }
+ }
+ }
+ u = result.length;
+ v = result[u - 1];
+ while (u-- > 0) {
+ result[u] = v;
+ v = p[v];
+ }
+ return result;
+}
+
+const isTeleport = (type) => type.__isTeleport;
+const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
+const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
+const resolveTarget = (props, select) => {
+ const targetSelector = props && props.to;
+ if (shared.isString(targetSelector)) {
+ if (!select) {
+ warn(
+ `Current renderer does not support string target for Teleports. (missing querySelector renderer option)`
+ );
+ return null;
+ } else {
+ const target = select(targetSelector);
+ if (!target) {
+ warn(
+ `Failed to locate Teleport target with selector "${targetSelector}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.`
+ );
+ }
+ return target;
+ }
+ } else {
+ if (!targetSelector && !isTeleportDisabled(props)) {
+ warn(`Invalid Teleport target: ${targetSelector}`);
+ }
+ return targetSelector;
+ }
+};
+const TeleportImpl = {
+ name: "Teleport",
+ __isTeleport: true,
+ process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals) {
+ const {
+ mc: mountChildren,
+ pc: patchChildren,
+ pbc: patchBlockChildren,
+ o: { insert, querySelector, createText, createComment }
+ } = internals;
+ const disabled = isTeleportDisabled(n2.props);
+ let { shapeFlag, children, dynamicChildren } = n2;
+ if (isHmrUpdating) {
+ optimized = false;
+ dynamicChildren = null;
+ }
+ if (n1 == null) {
+ const placeholder = n2.el = createComment("teleport start") ;
+ const mainAnchor = n2.anchor = createComment("teleport end") ;
+ insert(placeholder, container, anchor);
+ insert(mainAnchor, container, anchor);
+ const target = n2.target = resolveTarget(n2.props, querySelector);
+ const targetAnchor = n2.targetAnchor = createText("");
+ if (target) {
+ insert(targetAnchor, target);
+ isSVG = isSVG || isTargetSVG(target);
+ } else if (!disabled) {
+ warn("Invalid Teleport target on mount:", target, `(${typeof target})`);
+ }
+ const mount = (container2, anchor2) => {
+ if (shapeFlag & 16) {
+ mountChildren(
+ children,
+ container2,
+ anchor2,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ if (disabled) {
+ mount(container, mainAnchor);
+ } else if (target) {
+ mount(target, targetAnchor);
+ }
+ } else {
+ n2.el = n1.el;
+ const mainAnchor = n2.anchor = n1.anchor;
+ const target = n2.target = n1.target;
+ const targetAnchor = n2.targetAnchor = n1.targetAnchor;
+ const wasDisabled = isTeleportDisabled(n1.props);
+ const currentContainer = wasDisabled ? container : target;
+ const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
+ isSVG = isSVG || isTargetSVG(target);
+ if (dynamicChildren) {
+ patchBlockChildren(
+ n1.dynamicChildren,
+ dynamicChildren,
+ currentContainer,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds
+ );
+ traverseStaticChildren(n1, n2, true);
+ } else if (!optimized) {
+ patchChildren(
+ n1,
+ n2,
+ currentContainer,
+ currentAnchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ false
+ );
+ }
+ if (disabled) {
+ if (!wasDisabled) {
+ moveTeleport(
+ n2,
+ container,
+ mainAnchor,
+ internals,
+ 1
+ );
+ } else {
+ if (n2.props && n1.props && n2.props.to !== n1.props.to) {
+ n2.props.to = n1.props.to;
+ }
+ }
+ } else {
+ if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
+ const nextTarget = n2.target = resolveTarget(
+ n2.props,
+ querySelector
+ );
+ if (nextTarget) {
+ moveTeleport(
+ n2,
+ nextTarget,
+ null,
+ internals,
+ 0
+ );
+ } else {
+ warn(
+ "Invalid Teleport target on update:",
+ target,
+ `(${typeof target})`
+ );
+ }
+ } else if (wasDisabled) {
+ moveTeleport(
+ n2,
+ target,
+ targetAnchor,
+ internals,
+ 1
+ );
+ }
+ }
+ }
+ updateCssVars(n2);
+ },
+ remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {
+ const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;
+ if (target) {
+ hostRemove(targetAnchor);
+ }
+ doRemove && hostRemove(anchor);
+ if (shapeFlag & 16) {
+ const shouldRemove = doRemove || !isTeleportDisabled(props);
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ unmount(
+ child,
+ parentComponent,
+ parentSuspense,
+ shouldRemove,
+ !!child.dynamicChildren
+ );
+ }
+ }
+ },
+ move: moveTeleport,
+ hydrate: hydrateTeleport
+};
+function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
+ if (moveType === 0) {
+ insert(vnode.targetAnchor, container, parentAnchor);
+ }
+ const { el, anchor, shapeFlag, children, props } = vnode;
+ const isReorder = moveType === 2;
+ if (isReorder) {
+ insert(el, container, parentAnchor);
+ }
+ if (!isReorder || isTeleportDisabled(props)) {
+ if (shapeFlag & 16) {
+ for (let i = 0; i < children.length; i++) {
+ move(
+ children[i],
+ container,
+ parentAnchor,
+ 2
+ );
+ }
+ }
+ }
+ if (isReorder) {
+ insert(anchor, container, parentAnchor);
+ }
+}
+function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
+ o: { nextSibling, parentNode, querySelector }
+}, hydrateChildren) {
+ const target = vnode.target = resolveTarget(
+ vnode.props,
+ querySelector
+ );
+ if (target) {
+ const targetNode = target._lpa || target.firstChild;
+ if (vnode.shapeFlag & 16) {
+ if (isTeleportDisabled(vnode.props)) {
+ vnode.anchor = hydrateChildren(
+ nextSibling(node),
+ vnode,
+ parentNode(node),
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ vnode.targetAnchor = targetNode;
+ } else {
+ vnode.anchor = nextSibling(node);
+ let targetAnchor = targetNode;
+ while (targetAnchor) {
+ targetAnchor = nextSibling(targetAnchor);
+ if (targetAnchor && targetAnchor.nodeType === 8 && targetAnchor.data === "teleport anchor") {
+ vnode.targetAnchor = targetAnchor;
+ target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
+ break;
+ }
+ }
+ hydrateChildren(
+ targetNode,
+ vnode,
+ target,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ }
+ }
+ updateCssVars(vnode);
+ }
+ return vnode.anchor && nextSibling(vnode.anchor);
+}
+const Teleport = TeleportImpl;
+function updateCssVars(vnode) {
+ const ctx = vnode.ctx;
+ if (ctx && ctx.ut) {
+ let node = vnode.children[0].el;
+ while (node && node !== vnode.targetAnchor) {
+ if (node.nodeType === 1)
+ node.setAttribute("data-v-owner", ctx.uid);
+ node = node.nextSibling;
+ }
+ ctx.ut();
+ }
+}
+
+const Fragment = Symbol.for("v-fgt");
+const Text = Symbol.for("v-txt");
+const Comment = Symbol.for("v-cmt");
+const Static = Symbol.for("v-stc");
+const blockStack = [];
+let currentBlock = null;
+function openBlock(disableTracking = false) {
+ blockStack.push(currentBlock = disableTracking ? null : []);
+}
+function closeBlock() {
+ blockStack.pop();
+ currentBlock = blockStack[blockStack.length - 1] || null;
+}
+let isBlockTreeEnabled = 1;
+function setBlockTracking(value) {
+ isBlockTreeEnabled += value;
+}
+function setupBlock(vnode) {
+ vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || shared.EMPTY_ARR : null;
+ closeBlock();
+ if (isBlockTreeEnabled > 0 && currentBlock) {
+ currentBlock.push(vnode);
+ }
+ return vnode;
+}
+function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
+ return setupBlock(
+ createBaseVNode(
+ type,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ shapeFlag,
+ true
+ /* isBlock */
+ )
+ );
+}
+function createBlock(type, props, children, patchFlag, dynamicProps) {
+ return setupBlock(
+ createVNode(
+ type,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ true
+ /* isBlock: prevent a block from tracking itself */
+ )
+ );
+}
+function isVNode(value) {
+ return value ? value.__v_isVNode === true : false;
+}
+function isSameVNodeType(n1, n2) {
+ if (n2.shapeFlag & 6 && hmrDirtyComponents.has(n2.type)) {
+ n1.shapeFlag &= ~256;
+ n2.shapeFlag &= ~512;
+ return false;
+ }
+ return n1.type === n2.type && n1.key === n2.key;
+}
+let vnodeArgsTransformer;
+function transformVNodeArgs(transformer) {
+ vnodeArgsTransformer = transformer;
+}
+const createVNodeWithArgsTransform = (...args) => {
+ return _createVNode(
+ ...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args
+ );
+};
+const InternalObjectKey = `__vInternal`;
+const normalizeKey = ({ key }) => key != null ? key : null;
+const normalizeRef = ({
+ ref,
+ ref_key,
+ ref_for
+}) => {
+ if (typeof ref === "number") {
+ ref = "" + ref;
+ }
+ return ref != null ? shared.isString(ref) || reactivity.isRef(ref) || shared.isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+};
+function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+ const vnode = {
+ __v_isVNode: true,
+ __v_skip: true,
+ type,
+ props,
+ key: props && normalizeKey(props),
+ ref: props && normalizeRef(props),
+ scopeId: currentScopeId,
+ slotScopeIds: null,
+ children,
+ component: null,
+ suspense: null,
+ ssContent: null,
+ ssFallback: null,
+ dirs: null,
+ transition: null,
+ el: null,
+ anchor: null,
+ target: null,
+ targetAnchor: null,
+ staticCount: 0,
+ shapeFlag,
+ patchFlag,
+ dynamicProps,
+ dynamicChildren: null,
+ appContext: null,
+ ctx: currentRenderingInstance
+ };
+ if (needFullChildrenNormalization) {
+ normalizeChildren(vnode, children);
+ if (shapeFlag & 128) {
+ type.normalize(vnode);
+ }
+ } else if (children) {
+ vnode.shapeFlag |= shared.isString(children) ? 8 : 16;
+ }
+ if (vnode.key !== vnode.key) {
+ warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+ }
+ if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
+ !isBlockNode && // has current parent block
+ currentBlock && // presence of a patch flag indicates this node needs patching on updates.
+ // component nodes also should always be patched, because even if the
+ // component doesn't need to update, it needs to persist the instance on to
+ // the next vnode so that it can be properly unmounted later.
+ (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
+ // vnode should not be considered dynamic due to handler caching.
+ vnode.patchFlag !== 32) {
+ currentBlock.push(vnode);
+ }
+ return vnode;
+}
+const createVNode = createVNodeWithArgsTransform ;
+function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+ if (!type || type === NULL_DYNAMIC_COMPONENT) {
+ if (!type) {
+ warn(`Invalid vnode type when creating vnode: ${type}.`);
+ }
+ type = Comment;
+ }
+ if (isVNode(type)) {
+ const cloned = cloneVNode(
+ type,
+ props,
+ true
+ /* mergeRef: true */
+ );
+ if (children) {
+ normalizeChildren(cloned, children);
+ }
+ if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
+ if (cloned.shapeFlag & 6) {
+ currentBlock[currentBlock.indexOf(type)] = cloned;
+ } else {
+ currentBlock.push(cloned);
+ }
+ }
+ cloned.patchFlag |= -2;
+ return cloned;
+ }
+ if (isClassComponent(type)) {
+ type = type.__vccOpts;
+ }
+ if (props) {
+ props = guardReactiveProps(props);
+ let { class: klass, style } = props;
+ if (klass && !shared.isString(klass)) {
+ props.class = shared.normalizeClass(klass);
+ }
+ if (shared.isObject(style)) {
+ if (reactivity.isProxy(style) && !shared.isArray(style)) {
+ style = shared.extend({}, style);
+ }
+ props.style = shared.normalizeStyle(style);
+ }
+ }
+ const shapeFlag = shared.isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : shared.isObject(type) ? 4 : shared.isFunction(type) ? 2 : 0;
+ if (shapeFlag & 4 && reactivity.isProxy(type)) {
+ type = reactivity.toRaw(type);
+ warn(
+ `Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
+ `
+Component that was made reactive: `,
+ type
+ );
+ }
+ return createBaseVNode(
+ type,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ shapeFlag,
+ isBlockNode,
+ true
+ );
+}
+function guardReactiveProps(props) {
+ if (!props)
+ return null;
+ return reactivity.isProxy(props) || InternalObjectKey in props ? shared.extend({}, props) : props;
+}
+function cloneVNode(vnode, extraProps, mergeRef = false) {
+ const { props, ref, patchFlag, children } = vnode;
+ const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+ const cloned = {
+ __v_isVNode: true,
+ __v_skip: true,
+ type: vnode.type,
+ props: mergedProps,
+ key: mergedProps && normalizeKey(mergedProps),
+ ref: extraProps && extraProps.ref ? (
+ // #2078 in the case of <component :is="vnode" ref="extra"/>
+ // if the vnode itself already has a ref, cloneVNode will need to merge
+ // the refs so the single vnode can be set on multiple refs
+ mergeRef && ref ? shared.isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
+ ) : ref,
+ scopeId: vnode.scopeId,
+ slotScopeIds: vnode.slotScopeIds,
+ children: patchFlag === -1 && shared.isArray(children) ? children.map(deepCloneVNode) : children,
+ target: vnode.target,
+ targetAnchor: vnode.targetAnchor,
+ staticCount: vnode.staticCount,
+ shapeFlag: vnode.shapeFlag,
+ // if the vnode is cloned with extra props, we can no longer assume its
+ // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+ // note: preserve flag for fragments since they use the flag for children
+ // fast paths only.
+ patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+ dynamicProps: vnode.dynamicProps,
+ dynamicChildren: vnode.dynamicChildren,
+ appContext: vnode.appContext,
+ dirs: vnode.dirs,
+ transition: vnode.transition,
+ // These should technically only be non-null on mounted VNodes. However,
+ // they *should* be copied for kept-alive vnodes. So we just always copy
+ // them since them being non-null during a mount doesn't affect the logic as
+ // they will simply be overwritten.
+ component: vnode.component,
+ suspense: vnode.suspense,
+ ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+ ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+ el: vnode.el,
+ anchor: vnode.anchor,
+ ctx: vnode.ctx,
+ ce: vnode.ce
+ };
+ return cloned;
+}
+function deepCloneVNode(vnode) {
+ const cloned = cloneVNode(vnode);
+ if (shared.isArray(vnode.children)) {
+ cloned.children = vnode.children.map(deepCloneVNode);
+ }
+ return cloned;
+}
+function createTextVNode(text = " ", flag = 0) {
+ return createVNode(Text, null, text, flag);
+}
+function createStaticVNode(content, numberOfNodes) {
+ const vnode = createVNode(Static, null, content);
+ vnode.staticCount = numberOfNodes;
+ return vnode;
+}
+function createCommentVNode(text = "", asBlock = false) {
+ return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
+}
+function normalizeVNode(child) {
+ if (child == null || typeof child === "boolean") {
+ return createVNode(Comment);
+ } else if (shared.isArray(child)) {
+ return createVNode(
+ Fragment,
+ null,
+ // #3666, avoid reference pollution when reusing vnode
+ child.slice()
+ );
+ } else if (typeof child === "object") {
+ return cloneIfMounted(child);
+ } else {
+ return createVNode(Text, null, String(child));
+ }
+}
+function cloneIfMounted(child) {
+ return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
+}
+function normalizeChildren(vnode, children) {
+ let type = 0;
+ const { shapeFlag } = vnode;
+ if (children == null) {
+ children = null;
+ } else if (shared.isArray(children)) {
+ type = 16;
+ } else if (typeof children === "object") {
+ if (shapeFlag & (1 | 64)) {
+ const slot = children.default;
+ if (slot) {
+ slot._c && (slot._d = false);
+ normalizeChildren(vnode, slot());
+ slot._c && (slot._d = true);
+ }
+ return;
+ } else {
+ type = 32;
+ const slotFlag = children._;
+ if (!slotFlag && !(InternalObjectKey in children)) {
+ children._ctx = currentRenderingInstance;
+ } else if (slotFlag === 3 && currentRenderingInstance) {
+ if (currentRenderingInstance.slots._ === 1) {
+ children._ = 1;
+ } else {
+ children._ = 2;
+ vnode.patchFlag |= 1024;
+ }
+ }
+ }
+ } else if (shared.isFunction(children)) {
+ children = { default: children, _ctx: currentRenderingInstance };
+ type = 32;
+ } else {
+ children = String(children);
+ if (shapeFlag & 64) {
+ type = 16;
+ children = [createTextVNode(children)];
+ } else {
+ type = 8;
+ }
+ }
+ vnode.children = children;
+ vnode.shapeFlag |= type;
+}
+function mergeProps(...args) {
+ const ret = {};
+ for (let i = 0; i < args.length; i++) {
+ const toMerge = args[i];
+ for (const key in toMerge) {
+ if (key === "class") {
+ if (ret.class !== toMerge.class) {
+ ret.class = shared.normalizeClass([ret.class, toMerge.class]);
+ }
+ } else if (key === "style") {
+ ret.style = shared.normalizeStyle([ret.style, toMerge.style]);
+ } else if (shared.isOn(key)) {
+ const existing = ret[key];
+ const incoming = toMerge[key];
+ if (incoming && existing !== incoming && !(shared.isArray(existing) && existing.includes(incoming))) {
+ ret[key] = existing ? [].concat(existing, incoming) : incoming;
+ }
+ } else if (key !== "") {
+ ret[key] = toMerge[key];
+ }
+ }
+ }
+ return ret;
+}
+function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
+ callWithAsyncErrorHandling(hook, instance, 7, [
+ vnode,
+ prevVNode
+ ]);
+}
+
+const emptyAppContext = createAppContext();
+let uid = 0;
+function createComponentInstance(vnode, parent, suspense) {
+ const type = vnode.type;
+ const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
+ const instance = {
+ uid: uid++,
+ vnode,
+ type,
+ parent,
+ appContext,
+ root: null,
+ // to be immediately set
+ next: null,
+ subTree: null,
+ // will be set synchronously right after creation
+ effect: null,
+ update: null,
+ // will be set synchronously right after creation
+ scope: new reactivity.EffectScope(
+ true
+ /* detached */
+ ),
+ render: null,
+ proxy: null,
+ exposed: null,
+ exposeProxy: null,
+ withProxy: null,
+ provides: parent ? parent.provides : Object.create(appContext.provides),
+ accessCache: null,
+ renderCache: [],
+ // local resolved assets
+ components: null,
+ directives: null,
+ // resolved props and emits options
+ propsOptions: normalizePropsOptions(type, appContext),
+ emitsOptions: normalizeEmitsOptions(type, appContext),
+ // emit
+ emit: null,
+ // to be set immediately
+ emitted: null,
+ // props default value
+ propsDefaults: shared.EMPTY_OBJ,
+ // inheritAttrs
+ inheritAttrs: type.inheritAttrs,
+ // state
+ ctx: shared.EMPTY_OBJ,
+ data: shared.EMPTY_OBJ,
+ props: shared.EMPTY_OBJ,
+ attrs: shared.EMPTY_OBJ,
+ slots: shared.EMPTY_OBJ,
+ refs: shared.EMPTY_OBJ,
+ setupState: shared.EMPTY_OBJ,
+ setupContext: null,
+ attrsProxy: null,
+ slotsProxy: null,
+ // suspense related
+ suspense,
+ suspenseId: suspense ? suspense.pendingId : 0,
+ asyncDep: null,
+ asyncResolved: false,
+ // lifecycle hooks
+ // not using enums here because it results in computed properties
+ isMounted: false,
+ isUnmounted: false,
+ isDeactivated: false,
+ bc: null,
+ c: null,
+ bm: null,
+ m: null,
+ bu: null,
+ u: null,
+ um: null,
+ bum: null,
+ da: null,
+ a: null,
+ rtg: null,
+ rtc: null,
+ ec: null,
+ sp: null
+ };
+ {
+ instance.ctx = createDevRenderContext(instance);
+ }
+ instance.root = parent ? parent.root : instance;
+ instance.emit = emit.bind(null, instance);
+ if (vnode.ce) {
+ vnode.ce(instance);
+ }
+ return instance;
+}
+let currentInstance = null;
+const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+let internalSetCurrentInstance;
+let globalCurrentInstanceSetters;
+let settersKey = "__VUE_INSTANCE_SETTERS__";
+{
+ if (!(globalCurrentInstanceSetters = shared.getGlobalThis()[settersKey])) {
+ globalCurrentInstanceSetters = shared.getGlobalThis()[settersKey] = [];
+ }
+ globalCurrentInstanceSetters.push((i) => currentInstance = i);
+ internalSetCurrentInstance = (instance) => {
+ if (globalCurrentInstanceSetters.length > 1) {
+ globalCurrentInstanceSetters.forEach((s) => s(instance));
+ } else {
+ globalCurrentInstanceSetters[0](instance);
+ }
+ };
+}
+const setCurrentInstance = (instance) => {
+ internalSetCurrentInstance(instance);
+ instance.scope.on();
+};
+const unsetCurrentInstance = () => {
+ currentInstance && currentInstance.scope.off();
+ internalSetCurrentInstance(null);
+};
+const isBuiltInTag = /* @__PURE__ */ shared.makeMap("slot,component");
+function validateComponentName(name, config) {
+ const appIsNativeTag = config.isNativeTag || shared.NO;
+ if (isBuiltInTag(name) || appIsNativeTag(name)) {
+ warn(
+ "Do not use built-in or reserved HTML elements as component id: " + name
+ );
+ }
+}
+function isStatefulComponent(instance) {
+ return instance.vnode.shapeFlag & 4;
+}
+let isInSSRComponentSetup = false;
+function setupComponent(instance, isSSR = false) {
+ isInSSRComponentSetup = isSSR;
+ const { props, children } = instance.vnode;
+ const isStateful = isStatefulComponent(instance);
+ initProps(instance, props, isStateful, isSSR);
+ initSlots(instance, children);
+ const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
+ isInSSRComponentSetup = false;
+ return setupResult;
+}
+function setupStatefulComponent(instance, isSSR) {
+ var _a;
+ const Component = instance.type;
+ {
+ if (Component.name) {
+ validateComponentName(Component.name, instance.appContext.config);
+ }
+ if (Component.components) {
+ const names = Object.keys(Component.components);
+ for (let i = 0; i < names.length; i++) {
+ validateComponentName(names[i], instance.appContext.config);
+ }
+ }
+ if (Component.directives) {
+ const names = Object.keys(Component.directives);
+ for (let i = 0; i < names.length; i++) {
+ validateDirectiveName(names[i]);
+ }
+ }
+ if (Component.compilerOptions && isRuntimeOnly()) {
+ warn(
+ `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
+ );
+ }
+ }
+ instance.accessCache = /* @__PURE__ */ Object.create(null);
+ instance.proxy = reactivity.markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
+ {
+ exposePropsOnRenderContext(instance);
+ }
+ const { setup } = Component;
+ if (setup) {
+ const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
+ setCurrentInstance(instance);
+ reactivity.pauseTracking();
+ const setupResult = callWithErrorHandling(
+ setup,
+ instance,
+ 0,
+ [reactivity.shallowReadonly(instance.props) , setupContext]
+ );
+ reactivity.resetTracking();
+ unsetCurrentInstance();
+ if (shared.isPromise(setupResult)) {
+ setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
+ if (isSSR) {
+ return setupResult.then((resolvedResult) => {
+ handleSetupResult(instance, resolvedResult, isSSR);
+ }).catch((e) => {
+ handleError(e, instance, 0);
+ });
+ } else {
+ instance.asyncDep = setupResult;
+ if (!instance.suspense) {
+ const name = (_a = Component.name) != null ? _a : "Anonymous";
+ warn(
+ `Component <${name}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`
+ );
+ }
+ }
+ } else {
+ handleSetupResult(instance, setupResult, isSSR);
+ }
+ } else {
+ finishComponentSetup(instance, isSSR);
+ }
+}
+function handleSetupResult(instance, setupResult, isSSR) {
+ if (shared.isFunction(setupResult)) {
+ if (instance.type.__ssrInlineRender) {
+ instance.ssrRender = setupResult;
+ } else {
+ instance.render = setupResult;
+ }
+ } else if (shared.isObject(setupResult)) {
+ if (isVNode(setupResult)) {
+ warn(
+ `setup() should not return VNodes directly - return a render function instead.`
+ );
+ }
+ {
+ instance.devtoolsRawSetupState = setupResult;
+ }
+ instance.setupState = reactivity.proxyRefs(setupResult);
+ {
+ exposeSetupStateOnRenderContext(instance);
+ }
+ } else if (setupResult !== void 0) {
+ warn(
+ `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
+ );
+ }
+ finishComponentSetup(instance, isSSR);
+}
+let compile;
+let installWithProxy;
+function registerRuntimeCompiler(_compile) {
+ compile = _compile;
+ installWithProxy = (i) => {
+ if (i.render._rc) {
+ i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
+ }
+ };
+}
+const isRuntimeOnly = () => !compile;
+function finishComponentSetup(instance, isSSR, skipOptions) {
+ const Component = instance.type;
+ if (!instance.render) {
+ if (!isSSR && compile && !Component.render) {
+ const template = Component.template || resolveMergedOptions(instance).template;
+ if (template) {
+ {
+ startMeasure(instance, `compile`);
+ }
+ const { isCustomElement, compilerOptions } = instance.appContext.config;
+ const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+ const finalCompilerOptions = shared.extend(
+ shared.extend(
+ {
+ isCustomElement,
+ delimiters
+ },
+ compilerOptions
+ ),
+ componentCompilerOptions
+ );
+ Component.render = compile(template, finalCompilerOptions);
+ {
+ endMeasure(instance, `compile`);
+ }
+ }
+ }
+ instance.render = Component.render || shared.NOOP;
+ if (installWithProxy) {
+ installWithProxy(instance);
+ }
+ }
+ {
+ setCurrentInstance(instance);
+ reactivity.pauseTracking();
+ try {
+ applyOptions(instance);
+ } finally {
+ reactivity.resetTracking();
+ unsetCurrentInstance();
+ }
+ }
+ if (!Component.render && instance.render === shared.NOOP && !isSSR) {
+ if (!compile && Component.template) {
+ warn(
+ `Component provided template option but runtime compilation is not supported in this build of Vue.` + (``)
+ /* should not happen */
+ );
+ } else {
+ warn(`Component is missing template or render function.`);
+ }
+ }
+}
+function getAttrsProxy(instance) {
+ return instance.attrsProxy || (instance.attrsProxy = new Proxy(
+ instance.attrs,
+ {
+ get(target, key) {
+ markAttrsAccessed();
+ reactivity.track(instance, "get", "$attrs");
+ return target[key];
+ },
+ set() {
+ warn(`setupContext.attrs is readonly.`);
+ return false;
+ },
+ deleteProperty() {
+ warn(`setupContext.attrs is readonly.`);
+ return false;
+ }
+ }
+ ));
+}
+function getSlotsProxy(instance) {
+ return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
+ get(target, key) {
+ reactivity.track(instance, "get", "$slots");
+ return target[key];
+ }
+ }));
+}
+function createSetupContext(instance) {
+ const expose = (exposed) => {
+ {
+ if (instance.exposed) {
+ warn(`expose() should be called only once per setup().`);
+ }
+ if (exposed != null) {
+ let exposedType = typeof exposed;
+ if (exposedType === "object") {
+ if (shared.isArray(exposed)) {
+ exposedType = "array";
+ } else if (reactivity.isRef(exposed)) {
+ exposedType = "ref";
+ }
+ }
+ if (exposedType !== "object") {
+ warn(
+ `expose() should be passed a plain object, received ${exposedType}.`
+ );
+ }
+ }
+ }
+ instance.exposed = exposed || {};
+ };
+ {
+ return Object.freeze({
+ get attrs() {
+ return getAttrsProxy(instance);
+ },
+ get slots() {
+ return getSlotsProxy(instance);
+ },
+ get emit() {
+ return (event, ...args) => instance.emit(event, ...args);
+ },
+ expose
+ });
+ }
+}
+function getExposeProxy(instance) {
+ if (instance.exposed) {
+ return instance.exposeProxy || (instance.exposeProxy = new Proxy(reactivity.proxyRefs(reactivity.markRaw(instance.exposed)), {
+ get(target, key) {
+ if (key in target) {
+ return target[key];
+ } else if (key in publicPropertiesMap) {
+ return publicPropertiesMap[key](instance);
+ }
+ },
+ has(target, key) {
+ return key in target || key in publicPropertiesMap;
+ }
+ }));
+ }
+}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+ return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+ let name = getComponentName(Component);
+ if (!name && Component.__file) {
+ const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+ if (match) {
+ name = match[1];
+ }
+ }
+ if (!name && instance && instance.parent) {
+ const inferFromRegistry = (registry) => {
+ for (const key in registry) {
+ if (registry[key] === Component) {
+ return key;
+ }
+ }
+ };
+ name = inferFromRegistry(
+ instance.components || instance.parent.type.components
+ ) || inferFromRegistry(instance.appContext.components);
+ }
+ return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent(value) {
+ return shared.isFunction(value) && "__vccOpts" in value;
+}
+
+const computed = (getterOrOptions, debugOptions) => {
+ return reactivity.computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
+};
+
+function h(type, propsOrChildren, children) {
+ const l = arguments.length;
+ if (l === 2) {
+ if (shared.isObject(propsOrChildren) && !shared.isArray(propsOrChildren)) {
+ if (isVNode(propsOrChildren)) {
+ return createVNode(type, null, [propsOrChildren]);
+ }
+ return createVNode(type, propsOrChildren);
+ } else {
+ return createVNode(type, null, propsOrChildren);
+ }
+ } else {
+ if (l > 3) {
+ children = Array.prototype.slice.call(arguments, 2);
+ } else if (l === 3 && isVNode(children)) {
+ children = [children];
+ }
+ return createVNode(type, propsOrChildren, children);
+ }
+}
+
+const ssrContextKey = Symbol.for("v-scx");
+const useSSRContext = () => {
+ {
+ const ctx = inject(ssrContextKey);
+ if (!ctx) {
+ warn(
+ `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
+ );
+ }
+ return ctx;
+ }
+};
+
+function isShallow(value) {
+ return !!(value && value["__v_isShallow"]);
+}
+
+function initCustomFormatter() {
+ if (typeof window === "undefined") {
+ return;
+ }
+ const vueStyle = { style: "color:#3ba776" };
+ const numberStyle = { style: "color:#0b1bc9" };
+ const stringStyle = { style: "color:#b62e24" };
+ const keywordStyle = { style: "color:#9d288c" };
+ const formatter = {
+ header(obj) {
+ if (!shared.isObject(obj)) {
+ return null;
+ }
+ if (obj.__isVue) {
+ return ["div", vueStyle, `VueInstance`];
+ } else if (reactivity.isRef(obj)) {
+ return [
+ "div",
+ {},
+ ["span", vueStyle, genRefFlag(obj)],
+ "<",
+ formatValue(obj.value),
+ `>`
+ ];
+ } else if (reactivity.isReactive(obj)) {
+ return [
+ "div",
+ {},
+ ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
+ "<",
+ formatValue(obj),
+ `>${reactivity.isReadonly(obj) ? ` (readonly)` : ``}`
+ ];
+ } else if (reactivity.isReadonly(obj)) {
+ return [
+ "div",
+ {},
+ ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
+ "<",
+ formatValue(obj),
+ ">"
+ ];
+ }
+ return null;
+ },
+ hasBody(obj) {
+ return obj && obj.__isVue;
+ },
+ body(obj) {
+ if (obj && obj.__isVue) {
+ return [
+ "div",
+ {},
+ ...formatInstance(obj.$)
+ ];
+ }
+ }
+ };
+ function formatInstance(instance) {
+ const blocks = [];
+ if (instance.type.props && instance.props) {
+ blocks.push(createInstanceBlock("props", reactivity.toRaw(instance.props)));
+ }
+ if (instance.setupState !== shared.EMPTY_OBJ) {
+ blocks.push(createInstanceBlock("setup", instance.setupState));
+ }
+ if (instance.data !== shared.EMPTY_OBJ) {
+ blocks.push(createInstanceBlock("data", reactivity.toRaw(instance.data)));
+ }
+ const computed = extractKeys(instance, "computed");
+ if (computed) {
+ blocks.push(createInstanceBlock("computed", computed));
+ }
+ const injected = extractKeys(instance, "inject");
+ if (injected) {
+ blocks.push(createInstanceBlock("injected", injected));
+ }
+ blocks.push([
+ "div",
+ {},
+ [
+ "span",
+ {
+ style: keywordStyle.style + ";opacity:0.66"
+ },
+ "$ (internal): "
+ ],
+ ["object", { object: instance }]
+ ]);
+ return blocks;
+ }
+ function createInstanceBlock(type, target) {
+ target = shared.extend({}, target);
+ if (!Object.keys(target).length) {
+ return ["span", {}];
+ }
+ return [
+ "div",
+ { style: "line-height:1.25em;margin-bottom:0.6em" },
+ [
+ "div",
+ {
+ style: "color:#476582"
+ },
+ type
+ ],
+ [
+ "div",
+ {
+ style: "padding-left:1.25em"
+ },
+ ...Object.keys(target).map((key) => {
+ return [
+ "div",
+ {},
+ ["span", keywordStyle, key + ": "],
+ formatValue(target[key], false)
+ ];
+ })
+ ]
+ ];
+ }
+ function formatValue(v, asRaw = true) {
+ if (typeof v === "number") {
+ return ["span", numberStyle, v];
+ } else if (typeof v === "string") {
+ return ["span", stringStyle, JSON.stringify(v)];
+ } else if (typeof v === "boolean") {
+ return ["span", keywordStyle, v];
+ } else if (shared.isObject(v)) {
+ return ["object", { object: asRaw ? reactivity.toRaw(v) : v }];
+ } else {
+ return ["span", stringStyle, String(v)];
+ }
+ }
+ function extractKeys(instance, type) {
+ const Comp = instance.type;
+ if (shared.isFunction(Comp)) {
+ return;
+ }
+ const extracted = {};
+ for (const key in instance.ctx) {
+ if (isKeyOfType(Comp, key, type)) {
+ extracted[key] = instance.ctx[key];
+ }
+ }
+ return extracted;
+ }
+ function isKeyOfType(Comp, key, type) {
+ const opts = Comp[type];
+ if (shared.isArray(opts) && opts.includes(key) || shared.isObject(opts) && key in opts) {
+ return true;
+ }
+ if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+ return true;
+ }
+ if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
+ return true;
+ }
+ }
+ function genRefFlag(v) {
+ if (isShallow(v)) {
+ return `ShallowRef`;
+ }
+ if (v.effect) {
+ return `ComputedRef`;
+ }
+ return `Ref`;
+ }
+ if (window.devtoolsFormatters) {
+ window.devtoolsFormatters.push(formatter);
+ } else {
+ window.devtoolsFormatters = [formatter];
+ }
+}
+
+function withMemo(memo, render, cache, index) {
+ const cached = cache[index];
+ if (cached && isMemoSame(cached, memo)) {
+ return cached;
+ }
+ const ret = render();
+ ret.memo = memo.slice();
+ return cache[index] = ret;
+}
+function isMemoSame(cached, memo) {
+ const prev = cached.memo;
+ if (prev.length != memo.length) {
+ return false;
+ }
+ for (let i = 0; i < prev.length; i++) {
+ if (shared.hasChanged(prev[i], memo[i])) {
+ return false;
+ }
+ }
+ if (isBlockTreeEnabled > 0 && currentBlock) {
+ currentBlock.push(cached);
+ }
+ return true;
+}
+
+const version = "3.3.9";
+const _ssrUtils = {
+ createComponentInstance,
+ setupComponent,
+ renderComponentRoot,
+ setCurrentRenderingInstance,
+ isVNode: isVNode,
+ normalizeVNode
+};
+const ssrUtils = _ssrUtils ;
+const resolveFilter = null;
+const compatUtils = null;
+
+exports.EffectScope = reactivity.EffectScope;
+exports.ReactiveEffect = reactivity.ReactiveEffect;
+exports.customRef = reactivity.customRef;
+exports.effect = reactivity.effect;
+exports.effectScope = reactivity.effectScope;
+exports.getCurrentScope = reactivity.getCurrentScope;
+exports.isProxy = reactivity.isProxy;
+exports.isReactive = reactivity.isReactive;
+exports.isReadonly = reactivity.isReadonly;
+exports.isRef = reactivity.isRef;
+exports.isShallow = reactivity.isShallow;
+exports.markRaw = reactivity.markRaw;
+exports.onScopeDispose = reactivity.onScopeDispose;
+exports.proxyRefs = reactivity.proxyRefs;
+exports.reactive = reactivity.reactive;
+exports.readonly = reactivity.readonly;
+exports.ref = reactivity.ref;
+exports.shallowReactive = reactivity.shallowReactive;
+exports.shallowReadonly = reactivity.shallowReadonly;
+exports.shallowRef = reactivity.shallowRef;
+exports.stop = reactivity.stop;
+exports.toRaw = reactivity.toRaw;
+exports.toRef = reactivity.toRef;
+exports.toRefs = reactivity.toRefs;
+exports.toValue = reactivity.toValue;
+exports.triggerRef = reactivity.triggerRef;
+exports.unref = reactivity.unref;
+exports.camelize = shared.camelize;
+exports.capitalize = shared.capitalize;
+exports.normalizeClass = shared.normalizeClass;
+exports.normalizeProps = shared.normalizeProps;
+exports.normalizeStyle = shared.normalizeStyle;
+exports.toDisplayString = shared.toDisplayString;
+exports.toHandlerKey = shared.toHandlerKey;
+exports.BaseTransition = BaseTransition;
+exports.BaseTransitionPropsValidators = BaseTransitionPropsValidators;
+exports.Comment = Comment;
+exports.Fragment = Fragment;
+exports.KeepAlive = KeepAlive;
+exports.Static = Static;
+exports.Suspense = Suspense;
+exports.Teleport = Teleport;
+exports.Text = Text;
+exports.assertNumber = assertNumber;
+exports.callWithAsyncErrorHandling = callWithAsyncErrorHandling;
+exports.callWithErrorHandling = callWithErrorHandling;
+exports.cloneVNode = cloneVNode;
+exports.compatUtils = compatUtils;
+exports.computed = computed;
+exports.createBlock = createBlock;
+exports.createCommentVNode = createCommentVNode;
+exports.createElementBlock = createElementBlock;
+exports.createElementVNode = createBaseVNode;
+exports.createHydrationRenderer = createHydrationRenderer;
+exports.createPropsRestProxy = createPropsRestProxy;
+exports.createRenderer = createRenderer;
+exports.createSlots = createSlots;
+exports.createStaticVNode = createStaticVNode;
+exports.createTextVNode = createTextVNode;
+exports.createVNode = createVNode;
+exports.defineAsyncComponent = defineAsyncComponent;
+exports.defineComponent = defineComponent;
+exports.defineEmits = defineEmits;
+exports.defineExpose = defineExpose;
+exports.defineModel = defineModel;
+exports.defineOptions = defineOptions;
+exports.defineProps = defineProps;
+exports.defineSlots = defineSlots;
+exports.getCurrentInstance = getCurrentInstance;
+exports.getTransitionRawChildren = getTransitionRawChildren;
+exports.guardReactiveProps = guardReactiveProps;
+exports.h = h;
+exports.handleError = handleError;
+exports.hasInjectionContext = hasInjectionContext;
+exports.initCustomFormatter = initCustomFormatter;
+exports.inject = inject;
+exports.isMemoSame = isMemoSame;
+exports.isRuntimeOnly = isRuntimeOnly;
+exports.isVNode = isVNode;
+exports.mergeDefaults = mergeDefaults;
+exports.mergeModels = mergeModels;
+exports.mergeProps = mergeProps;
+exports.nextTick = nextTick;
+exports.onActivated = onActivated;
+exports.onBeforeMount = onBeforeMount;
+exports.onBeforeUnmount = onBeforeUnmount;
+exports.onBeforeUpdate = onBeforeUpdate;
+exports.onDeactivated = onDeactivated;
+exports.onErrorCaptured = onErrorCaptured;
+exports.onMounted = onMounted;
+exports.onRenderTracked = onRenderTracked;
+exports.onRenderTriggered = onRenderTriggered;
+exports.onServerPrefetch = onServerPrefetch;
+exports.onUnmounted = onUnmounted;
+exports.onUpdated = onUpdated;
+exports.openBlock = openBlock;
+exports.popScopeId = popScopeId;
+exports.provide = provide;
+exports.pushScopeId = pushScopeId;
+exports.queuePostFlushCb = queuePostFlushCb;
+exports.registerRuntimeCompiler = registerRuntimeCompiler;
+exports.renderList = renderList;
+exports.renderSlot = renderSlot;
+exports.resolveComponent = resolveComponent;
+exports.resolveDirective = resolveDirective;
+exports.resolveDynamicComponent = resolveDynamicComponent;
+exports.resolveFilter = resolveFilter;
+exports.resolveTransitionHooks = resolveTransitionHooks;
+exports.setBlockTracking = setBlockTracking;
+exports.setDevtoolsHook = setDevtoolsHook;
+exports.setTransitionHooks = setTransitionHooks;
+exports.ssrContextKey = ssrContextKey;
+exports.ssrUtils = ssrUtils;
+exports.toHandlers = toHandlers;
+exports.transformVNodeArgs = transformVNodeArgs;
+exports.useAttrs = useAttrs;
+exports.useModel = useModel;
+exports.useSSRContext = useSSRContext;
+exports.useSlots = useSlots;
+exports.useTransitionState = useTransitionState;
+exports.version = version;
+exports.warn = warn;
+exports.watch = watch;
+exports.watchEffect = watchEffect;
+exports.watchPostEffect = watchPostEffect;
+exports.watchSyncEffect = watchSyncEffect;
+exports.withAsyncContext = withAsyncContext;
+exports.withCtx = withCtx;
+exports.withDefaults = withDefaults;
+exports.withDirectives = withDirectives;
+exports.withMemo = withMemo;
+exports.withScopeId = withScopeId;
diff --git a/.output/server/node_modules/@vue/runtime-core/dist/runtime-core.cjs.prod.js b/.output/server/node_modules/@vue/runtime-core/dist/runtime-core.cjs.prod.js
new file mode 100644
index 0000000..ac48f58
--- /dev/null
+++ b/.output/server/node_modules/@vue/runtime-core/dist/runtime-core.cjs.prod.js
@@ -0,0 +1,6233 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactivity = require('@vue/reactivity');
+var shared = require('@vue/shared');
+
+function warn$1(msg, ...args) {
+ return;
+}
+function assertNumber(val, type) {
+ return;
+}
+
+function callWithErrorHandling(fn, instance, type, args) {
+ let res;
+ try {
+ res = args ? fn(...args) : fn();
+ } catch (err) {
+ handleError(err, instance, type);
+ }
+ return res;
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+ if (shared.isFunction(fn)) {
+ const res = callWithErrorHandling(fn, instance, type, args);
+ if (res && shared.isPromise(res)) {
+ res.catch((err) => {
+ handleError(err, instance, type);
+ });
+ }
+ return res;
+ }
+ const values = [];
+ for (let i = 0; i < fn.length; i++) {
+ values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+ }
+ return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+ const contextVNode = instance ? instance.vnode : null;
+ if (instance) {
+ let cur = instance.parent;
+ const exposedInstance = instance.proxy;
+ const errorInfo = type;
+ while (cur) {
+ const errorCapturedHooks = cur.ec;
+ if (errorCapturedHooks) {
+ for (let i = 0; i < errorCapturedHooks.length; i++) {
+ if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+ return;
+ }
+ }
+ }
+ cur = cur.parent;
+ }
+ const appErrorHandler = instance.appContext.config.errorHandler;
+ if (appErrorHandler) {
+ callWithErrorHandling(
+ appErrorHandler,
+ null,
+ 10,
+ [err, exposedInstance, errorInfo]
+ );
+ return;
+ }
+ }
+ logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+ {
+ console.error(err);
+ }
+}
+
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+function nextTick(fn) {
+ const p = currentFlushPromise || resolvedPromise;
+ return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(id) {
+ let start = flushIndex + 1;
+ let end = queue.length;
+ while (start < end) {
+ const middle = start + end >>> 1;
+ const middleJob = queue[middle];
+ const middleJobId = getId(middleJob);
+ if (middleJobId < id || middleJobId === id && middleJob.pre) {
+ start = middle + 1;
+ } else {
+ end = middle;
+ }
+ }
+ return start;
+}
+function queueJob(job) {
+ if (!queue.length || !queue.includes(
+ job,
+ isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
+ )) {
+ if (job.id == null) {
+ queue.push(job);
+ } else {
+ queue.splice(findInsertionIndex(job.id), 0, job);
+ }
+ queueFlush();
+ }
+}
+function queueFlush() {
+ if (!isFlushing && !isFlushPending) {
+ isFlushPending = true;
+ currentFlushPromise = resolvedPromise.then(flushJobs);
+ }
+}
+function invalidateJob(job) {
+ const i = queue.indexOf(job);
+ if (i > flushIndex) {
+ queue.splice(i, 1);
+ }
+}
+function queuePostFlushCb(cb) {
+ if (!shared.isArray(cb)) {
+ if (!activePostFlushCbs || !activePostFlushCbs.includes(
+ cb,
+ cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
+ )) {
+ pendingPostFlushCbs.push(cb);
+ }
+ } else {
+ pendingPostFlushCbs.push(...cb);
+ }
+ queueFlush();
+}
+function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
+ for (; i < queue.length; i++) {
+ const cb = queue[i];
+ if (cb && cb.pre) {
+ queue.splice(i, 1);
+ i--;
+ cb();
+ }
+ }
+}
+function flushPostFlushCbs(seen) {
+ if (pendingPostFlushCbs.length) {
+ const deduped = [...new Set(pendingPostFlushCbs)];
+ pendingPostFlushCbs.length = 0;
+ if (activePostFlushCbs) {
+ activePostFlushCbs.push(...deduped);
+ return;
+ }
+ activePostFlushCbs = deduped;
+ activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+ for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+ activePostFlushCbs[postFlushIndex]();
+ }
+ activePostFlushCbs = null;
+ postFlushIndex = 0;
+ }
+}
+const getId = (job) => job.id == null ? Infinity : job.id;
+const comparator = (a, b) => {
+ const diff = getId(a) - getId(b);
+ if (diff === 0) {
+ if (a.pre && !b.pre)
+ return -1;
+ if (b.pre && !a.pre)
+ return 1;
+ }
+ return diff;
+};
+function flushJobs(seen) {
+ isFlushPending = false;
+ isFlushing = true;
+ queue.sort(comparator);
+ try {
+ for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+ const job = queue[flushIndex];
+ if (job && job.active !== false) {
+ if (false) ;
+ callWithErrorHandling(job, null, 14);
+ }
+ }
+ } finally {
+ flushIndex = 0;
+ queue.length = 0;
+ flushPostFlushCbs();
+ isFlushing = false;
+ currentFlushPromise = null;
+ if (queue.length || pendingPostFlushCbs.length) {
+ flushJobs();
+ }
+ }
+}
+
+exports.devtools = void 0;
+let buffer = [];
+function setDevtoolsHook(hook, target) {
+ var _a, _b;
+ exports.devtools = hook;
+ if (exports.devtools) {
+ exports.devtools.enabled = true;
+ buffer.forEach(({ event, args }) => exports.devtools.emit(event, ...args));
+ buffer = [];
+ } else if (
+ // handle late devtools injection - only do this if we are in an actual
+ // browser environment to avoid the timer handle stalling test runner exit
+ // (#4815)
+ typeof window !== "undefined" && // some envs mock window but not fully
+ window.HTMLElement && // also exclude jsdom
+ !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
+ ) {
+ const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+ replay.push((newHook) => {
+ setDevtoolsHook(newHook, target);
+ });
+ setTimeout(() => {
+ if (!exports.devtools) {
+ target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+ buffer = [];
+ }
+ }, 3e3);
+ } else {
+ buffer = [];
+ }
+}
+
+function emit(instance, event, ...rawArgs) {
+ if (instance.isUnmounted)
+ return;
+ const props = instance.vnode.props || shared.EMPTY_OBJ;
+ let args = rawArgs;
+ const isModelListener = event.startsWith("update:");
+ const modelArg = isModelListener && event.slice(7);
+ if (modelArg && modelArg in props) {
+ const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
+ const { number, trim } = props[modifiersKey] || shared.EMPTY_OBJ;
+ if (trim) {
+ args = rawArgs.map((a) => shared.isString(a) ? a.trim() : a);
+ }
+ if (number) {
+ args = rawArgs.map(shared.looseToNumber);
+ }
+ }
+ let handlerName;
+ let handler = props[handlerName = shared.toHandlerKey(event)] || // also try camelCase event handler (#2249)
+ props[handlerName = shared.toHandlerKey(shared.camelize(event))];
+ if (!handler && isModelListener) {
+ handler = props[handlerName = shared.toHandlerKey(shared.hyphenate(event))];
+ }
+ if (handler) {
+ callWithAsyncErrorHandling(
+ handler,
+ instance,
+ 6,
+ args
+ );
+ }
+ const onceHandler = props[handlerName + `Once`];
+ if (onceHandler) {
+ if (!instance.emitted) {
+ instance.emitted = {};
+ } else if (instance.emitted[handlerName]) {
+ return;
+ }
+ instance.emitted[handlerName] = true;
+ callWithAsyncErrorHandling(
+ onceHandler,
+ instance,
+ 6,
+ args
+ );
+ }
+}
+function normalizeEmitsOptions(comp, appContext, asMixin = false) {
+ const cache = appContext.emitsCache;
+ const cached = cache.get(comp);
+ if (cached !== void 0) {
+ return cached;
+ }
+ const raw = comp.emits;
+ let normalized = {};
+ let hasExtends = false;
+ if (!shared.isFunction(comp)) {
+ const extendEmits = (raw2) => {
+ const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+ if (normalizedFromExtend) {
+ hasExtends = true;
+ shared.extend(normalized, normalizedFromExtend);
+ }
+ };
+ if (!asMixin && appContext.mixins.length) {
+ appContext.mixins.forEach(extendEmits);
+ }
+ if (comp.extends) {
+ extendEmits(comp.extends);
+ }
+ if (comp.mixins) {
+ comp.mixins.forEach(extendEmits);
+ }
+ }
+ if (!raw && !hasExtends) {
+ if (shared.isObject(comp)) {
+ cache.set(comp, null);
+ }
+ return null;
+ }
+ if (shared.isArray(raw)) {
+ raw.forEach((key) => normalized[key] = null);
+ } else {
+ shared.extend(normalized, raw);
+ }
+ if (shared.isObject(comp)) {
+ cache.set(comp, normalized);
+ }
+ return normalized;
+}
+function isEmitListener(options, key) {
+ if (!options || !shared.isOn(key)) {
+ return false;
+ }
+ key = key.slice(2).replace(/Once$/, "");
+ return shared.hasOwn(options, key[0].toLowerCase() + key.slice(1)) || shared.hasOwn(options, shared.hyphenate(key)) || shared.hasOwn(options, key);
+}
+
+let currentRenderingInstance = null;
+let currentScopeId = null;
+function setCurrentRenderingInstance(instance) {
+ const prev = currentRenderingInstance;
+ currentRenderingInstance = instance;
+ currentScopeId = instance && instance.type.__scopeId || null;
+ return prev;
+}
+function pushScopeId(id) {
+ currentScopeId = id;
+}
+function popScopeId() {
+ currentScopeId = null;
+}
+const withScopeId = (_id) => withCtx;
+function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
+ if (!ctx)
+ return fn;
+ if (fn._n) {
+ return fn;
+ }
+ const renderFnWithContext = (...args) => {
+ if (renderFnWithContext._d) {
+ setBlockTracking(-1);
+ }
+ const prevInstance = setCurrentRenderingInstance(ctx);
+ let res;
+ try {
+ res = fn(...args);
+ } finally {
+ setCurrentRenderingInstance(prevInstance);
+ if (renderFnWithContext._d) {
+ setBlockTracking(1);
+ }
+ }
+ return res;
+ };
+ renderFnWithContext._n = true;
+ renderFnWithContext._c = true;
+ renderFnWithContext._d = true;
+ return renderFnWithContext;
+}
+
+function markAttrsAccessed() {
+}
+function renderComponentRoot(instance) {
+ const {
+ type: Component,
+ vnode,
+ proxy,
+ withProxy,
+ props,
+ propsOptions: [propsOptions],
+ slots,
+ attrs,
+ emit,
+ render,
+ renderCache,
+ data,
+ setupState,
+ ctx,
+ inheritAttrs
+ } = instance;
+ let result;
+ let fallthroughAttrs;
+ const prev = setCurrentRenderingInstance(instance);
+ try {
+ if (vnode.shapeFlag & 4) {
+ const proxyToUse = withProxy || proxy;
+ const thisProxy = false ? new Proxy(proxyToUse, {
+ get(target, key, receiver) {
+ warn(
+ `Property '${String(
+ key
+ )}' was accessed via 'this'. Avoid using 'this' in templates.`
+ );
+ return Reflect.get(target, key, receiver);
+ }
+ }) : proxyToUse;
+ result = normalizeVNode(
+ render.call(
+ thisProxy,
+ proxyToUse,
+ renderCache,
+ props,
+ setupState,
+ data,
+ ctx
+ )
+ );
+ fallthroughAttrs = attrs;
+ } else {
+ const render2 = Component;
+ if (false) ;
+ result = normalizeVNode(
+ render2.length > 1 ? render2(
+ props,
+ false ? {
+ get attrs() {
+ markAttrsAccessed();
+ return attrs;
+ },
+ slots,
+ emit
+ } : { attrs, slots, emit }
+ ) : render2(
+ props,
+ null
+ /* we know it doesn't need it */
+ )
+ );
+ fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
+ }
+ } catch (err) {
+ blockStack.length = 0;
+ handleError(err, instance, 1);
+ result = createVNode(Comment);
+ }
+ let root = result;
+ if (fallthroughAttrs && inheritAttrs !== false) {
+ const keys = Object.keys(fallthroughAttrs);
+ const { shapeFlag } = root;
+ if (keys.length) {
+ if (shapeFlag & (1 | 6)) {
+ if (propsOptions && keys.some(shared.isModelListener)) {
+ fallthroughAttrs = filterModelListeners(
+ fallthroughAttrs,
+ propsOptions
+ );
+ }
+ root = cloneVNode(root, fallthroughAttrs);
+ }
+ }
+ }
+ if (vnode.dirs) {
+ root = cloneVNode(root);
+ root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+ }
+ if (vnode.transition) {
+ root.transition = vnode.transition;
+ }
+ {
+ result = root;
+ }
+ setCurrentRenderingInstance(prev);
+ return result;
+}
+function filterSingleRoot(children) {
+ let singleRoot;
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (isVNode(child)) {
+ if (child.type !== Comment || child.children === "v-if") {
+ if (singleRoot) {
+ return;
+ } else {
+ singleRoot = child;
+ }
+ }
+ } else {
+ return;
+ }
+ }
+ return singleRoot;
+}
+const getFunctionalFallthrough = (attrs) => {
+ let res;
+ for (const key in attrs) {
+ if (key === "class" || key === "style" || shared.isOn(key)) {
+ (res || (res = {}))[key] = attrs[key];
+ }
+ }
+ return res;
+};
+const filterModelListeners = (attrs, props) => {
+ const res = {};
+ for (const key in attrs) {
+ if (!shared.isModelListener(key) || !(key.slice(9) in props)) {
+ res[key] = attrs[key];
+ }
+ }
+ return res;
+};
+function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+ const { props: prevProps, children: prevChildren, component } = prevVNode;
+ const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+ const emits = component.emitsOptions;
+ if (nextVNode.dirs || nextVNode.transition) {
+ return true;
+ }
+ if (optimized && patchFlag >= 0) {
+ if (patchFlag & 1024) {
+ return true;
+ }
+ if (patchFlag & 16) {
+ if (!prevProps) {
+ return !!nextProps;
+ }
+ return hasPropsChanged(prevProps, nextProps, emits);
+ } else if (patchFlag & 8) {
+ const dynamicProps = nextVNode.dynamicProps;
+ for (let i = 0; i < dynamicProps.length; i++) {
+ const key = dynamicProps[i];
+ if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
+ return true;
+ }
+ }
+ }
+ } else {
+ if (prevChildren || nextChildren) {
+ if (!nextChildren || !nextChildren.$stable) {
+ return true;
+ }
+ }
+ if (prevProps === nextProps) {
+ return false;
+ }
+ if (!prevProps) {
+ return !!nextProps;
+ }
+ if (!nextProps) {
+ return true;
+ }
+ return hasPropsChanged(prevProps, nextProps, emits);
+ }
+ return false;
+}
+function hasPropsChanged(prevProps, nextProps, emitsOptions) {
+ const nextKeys = Object.keys(nextProps);
+ if (nextKeys.length !== Object.keys(prevProps).length) {
+ return true;
+ }
+ for (let i = 0; i < nextKeys.length; i++) {
+ const key = nextKeys[i];
+ if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
+ return true;
+ }
+ }
+ return false;
+}
+function updateHOCHostEl({ vnode, parent }, el) {
+ while (parent && parent.subTree === vnode) {
+ (vnode = parent.vnode).el = el;
+ parent = parent.parent;
+ }
+}
+
+const COMPONENTS = "components";
+const DIRECTIVES = "directives";
+function resolveComponent(name, maybeSelfReference) {
+ return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+}
+const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+function resolveDynamicComponent(component) {
+ if (shared.isString(component)) {
+ return resolveAsset(COMPONENTS, component, false) || component;
+ } else {
+ return component || NULL_DYNAMIC_COMPONENT;
+ }
+}
+function resolveDirective(name) {
+ return resolveAsset(DIRECTIVES, name);
+}
+function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+ const instance = currentRenderingInstance || currentInstance;
+ if (instance) {
+ const Component = instance.type;
+ if (type === COMPONENTS) {
+ const selfName = getComponentName(
+ Component,
+ false
+ /* do not include inferred name to avoid breaking existing code */
+ );
+ if (selfName && (selfName === name || selfName === shared.camelize(name) || selfName === shared.capitalize(shared.camelize(name)))) {
+ return Component;
+ }
+ }
+ const res = (
+ // local registration
+ // check instance[type] first which is resolved for options API
+ resolve(instance[type] || Component[type], name) || // global registration
+ resolve(instance.appContext[type], name)
+ );
+ if (!res && maybeSelfReference) {
+ return Component;
+ }
+ return res;
+ }
+}
+function resolve(registry, name) {
+ return registry && (registry[name] || registry[shared.camelize(name)] || registry[shared.capitalize(shared.camelize(name))]);
+}
+
+const isSuspense = (type) => type.__isSuspense;
+const SuspenseImpl = {
+ name: "Suspense",
+ // In order to make Suspense tree-shakable, we need to avoid importing it
+ // directly in the renderer. The renderer checks for the __isSuspense flag
+ // on a vnode's type and calls the `process` method, passing in renderer
+ // internals.
+ __isSuspense: true,
+ process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+ if (n1 == null) {
+ mountSuspense(
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals
+ );
+ } else {
+ patchSuspense(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals
+ );
+ }
+ },
+ hydrate: hydrateSuspense,
+ create: createSuspenseBoundary,
+ normalize: normalizeSuspenseChildren
+};
+const Suspense = SuspenseImpl ;
+function triggerEvent(vnode, name) {
+ const eventListener = vnode.props && vnode.props[name];
+ if (shared.isFunction(eventListener)) {
+ eventListener();
+ }
+}
+function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
+ const {
+ p: patch,
+ o: { createElement }
+ } = rendererInternals;
+ const hiddenContainer = createElement("div");
+ const suspense = vnode.suspense = createSuspenseBoundary(
+ vnode,
+ parentSuspense,
+ parentComponent,
+ container,
+ hiddenContainer,
+ anchor,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals
+ );
+ patch(
+ null,
+ suspense.pendingBranch = vnode.ssContent,
+ hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds
+ );
+ if (suspense.deps > 0) {
+ triggerEvent(vnode, "onPending");
+ triggerEvent(vnode, "onFallback");
+ patch(
+ null,
+ vnode.ssFallback,
+ container,
+ anchor,
+ parentComponent,
+ null,
+ // fallback tree will not have suspense context
+ isSVG,
+ slotScopeIds
+ );
+ setActiveBranch(suspense, vnode.ssFallback);
+ } else {
+ suspense.resolve(false, true);
+ }
+}
+function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+ const suspense = n2.suspense = n1.suspense;
+ suspense.vnode = n2;
+ n2.el = n1.el;
+ const newBranch = n2.ssContent;
+ const newFallback = n2.ssFallback;
+ const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+ if (pendingBranch) {
+ suspense.pendingBranch = newBranch;
+ if (isSameVNodeType(newBranch, pendingBranch)) {
+ patch(
+ pendingBranch,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ } else if (isInFallback) {
+ patch(
+ activeBranch,
+ newFallback,
+ container,
+ anchor,
+ parentComponent,
+ null,
+ // fallback tree will not have suspense context
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, newFallback);
+ }
+ } else {
+ suspense.pendingId++;
+ if (isHydrating) {
+ suspense.isHydrating = false;
+ suspense.activeBranch = pendingBranch;
+ } else {
+ unmount(pendingBranch, parentComponent, suspense);
+ }
+ suspense.deps = 0;
+ suspense.effects.length = 0;
+ suspense.hiddenContainer = createElement("div");
+ if (isInFallback) {
+ patch(
+ null,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ } else {
+ patch(
+ activeBranch,
+ newFallback,
+ container,
+ anchor,
+ parentComponent,
+ null,
+ // fallback tree will not have suspense context
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, newFallback);
+ }
+ } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+ patch(
+ activeBranch,
+ newBranch,
+ container,
+ anchor,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ suspense.resolve(true);
+ } else {
+ patch(
+ null,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ }
+ }
+ }
+ } else {
+ if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+ patch(
+ activeBranch,
+ newBranch,
+ container,
+ anchor,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, newBranch);
+ } else {
+ triggerEvent(n2, "onPending");
+ suspense.pendingBranch = newBranch;
+ suspense.pendingId++;
+ patch(
+ null,
+ newBranch,
+ suspense.hiddenContainer,
+ null,
+ parentComponent,
+ suspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps <= 0) {
+ suspense.resolve();
+ } else {
+ const { timeout, pendingId } = suspense;
+ if (timeout > 0) {
+ setTimeout(() => {
+ if (suspense.pendingId === pendingId) {
+ suspense.fallback(newFallback);
+ }
+ }, timeout);
+ } else if (timeout === 0) {
+ suspense.fallback(newFallback);
+ }
+ }
+ }
+ }
+}
+function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+ const {
+ p: patch,
+ m: move,
+ um: unmount,
+ n: next,
+ o: { parentNode, remove }
+ } = rendererInternals;
+ let parentSuspenseId;
+ const isSuspensible = isVNodeSuspensible(vnode);
+ if (isSuspensible) {
+ if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
+ parentSuspenseId = parentSuspense.pendingId;
+ parentSuspense.deps++;
+ }
+ }
+ const timeout = vnode.props ? shared.toNumber(vnode.props.timeout) : void 0;
+ const suspense = {
+ vnode,
+ parent: parentSuspense,
+ parentComponent,
+ isSVG,
+ container,
+ hiddenContainer,
+ anchor,
+ deps: 0,
+ pendingId: 0,
+ timeout: typeof timeout === "number" ? timeout : -1,
+ activeBranch: null,
+ pendingBranch: null,
+ isInFallback: true,
+ isHydrating,
+ isUnmounted: false,
+ effects: [],
+ resolve(resume = false, sync = false) {
+ const {
+ vnode: vnode2,
+ activeBranch,
+ pendingBranch,
+ pendingId,
+ effects,
+ parentComponent: parentComponent2,
+ container: container2
+ } = suspense;
+ let delayEnter = false;
+ if (suspense.isHydrating) {
+ suspense.isHydrating = false;
+ } else if (!resume) {
+ delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
+ if (delayEnter) {
+ activeBranch.transition.afterLeave = () => {
+ if (pendingId === suspense.pendingId) {
+ move(pendingBranch, container2, anchor2, 0);
+ queuePostFlushCb(effects);
+ }
+ };
+ }
+ let { anchor: anchor2 } = suspense;
+ if (activeBranch) {
+ anchor2 = next(activeBranch);
+ unmount(activeBranch, parentComponent2, suspense, true);
+ }
+ if (!delayEnter) {
+ move(pendingBranch, container2, anchor2, 0);
+ }
+ }
+ setActiveBranch(suspense, pendingBranch);
+ suspense.pendingBranch = null;
+ suspense.isInFallback = false;
+ let parent = suspense.parent;
+ let hasUnresolvedAncestor = false;
+ while (parent) {
+ if (parent.pendingBranch) {
+ parent.effects.push(...effects);
+ hasUnresolvedAncestor = true;
+ break;
+ }
+ parent = parent.parent;
+ }
+ if (!hasUnresolvedAncestor && !delayEnter) {
+ queuePostFlushCb(effects);
+ }
+ suspense.effects = [];
+ if (isSuspensible) {
+ if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+ parentSuspense.deps--;
+ if (parentSuspense.deps === 0 && !sync) {
+ parentSuspense.resolve();
+ }
+ }
+ }
+ triggerEvent(vnode2, "onResolve");
+ },
+ fallback(fallbackVNode) {
+ if (!suspense.pendingBranch) {
+ return;
+ }
+ const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG2 } = suspense;
+ triggerEvent(vnode2, "onFallback");
+ const anchor2 = next(activeBranch);
+ const mountFallback = () => {
+ if (!suspense.isInFallback) {
+ return;
+ }
+ patch(
+ null,
+ fallbackVNode,
+ container2,
+ anchor2,
+ parentComponent2,
+ null,
+ // fallback tree will not have suspense context
+ isSVG2,
+ slotScopeIds,
+ optimized
+ );
+ setActiveBranch(suspense, fallbackVNode);
+ };
+ const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
+ if (delayEnter) {
+ activeBranch.transition.afterLeave = mountFallback;
+ }
+ suspense.isInFallback = true;
+ unmount(
+ activeBranch,
+ parentComponent2,
+ null,
+ // no suspense so unmount hooks fire now
+ true
+ // shouldRemove
+ );
+ if (!delayEnter) {
+ mountFallback();
+ }
+ },
+ move(container2, anchor2, type) {
+ suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+ suspense.container = container2;
+ },
+ next() {
+ return suspense.activeBranch && next(suspense.activeBranch);
+ },
+ registerDep(instance, setupRenderEffect) {
+ const isInPendingSuspense = !!suspense.pendingBranch;
+ if (isInPendingSuspense) {
+ suspense.deps++;
+ }
+ const hydratedEl = instance.vnode.el;
+ instance.asyncDep.catch((err) => {
+ handleError(err, instance, 0);
+ }).then((asyncSetupResult) => {
+ if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
+ return;
+ }
+ instance.asyncResolved = true;
+ const { vnode: vnode2 } = instance;
+ handleSetupResult(instance, asyncSetupResult, false);
+ if (hydratedEl) {
+ vnode2.el = hydratedEl;
+ }
+ const placeholder = !hydratedEl && instance.subTree.el;
+ setupRenderEffect(
+ instance,
+ vnode2,
+ // component may have been moved before resolve.
+ // if this is not a hydration, instance.subTree will be the comment
+ // placeholder.
+ parentNode(hydratedEl || instance.subTree.el),
+ // anchor will not be used if this is hydration, so only need to
+ // consider the comment placeholder case.
+ hydratedEl ? null : next(instance.subTree),
+ suspense,
+ isSVG,
+ optimized
+ );
+ if (placeholder) {
+ remove(placeholder);
+ }
+ updateHOCHostEl(instance, vnode2.el);
+ if (isInPendingSuspense && --suspense.deps === 0) {
+ suspense.resolve();
+ }
+ });
+ },
+ unmount(parentSuspense2, doRemove) {
+ suspense.isUnmounted = true;
+ if (suspense.activeBranch) {
+ unmount(
+ suspense.activeBranch,
+ parentComponent,
+ parentSuspense2,
+ doRemove
+ );
+ }
+ if (suspense.pendingBranch) {
+ unmount(
+ suspense.pendingBranch,
+ parentComponent,
+ parentSuspense2,
+ doRemove
+ );
+ }
+ }
+ };
+ return suspense;
+}
+function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+ const suspense = vnode.suspense = createSuspenseBoundary(
+ vnode,
+ parentSuspense,
+ parentComponent,
+ node.parentNode,
+ document.createElement("div"),
+ null,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ rendererInternals,
+ true
+ /* hydrating */
+ );
+ const result = hydrateNode(
+ node,
+ suspense.pendingBranch = vnode.ssContent,
+ parentComponent,
+ suspense,
+ slotScopeIds,
+ optimized
+ );
+ if (suspense.deps === 0) {
+ suspense.resolve(false, true);
+ }
+ return result;
+}
+function normalizeSuspenseChildren(vnode) {
+ const { shapeFlag, children } = vnode;
+ const isSlotChildren = shapeFlag & 32;
+ vnode.ssContent = normalizeSuspenseSlot(
+ isSlotChildren ? children.default : children
+ );
+ vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
+}
+function normalizeSuspenseSlot(s) {
+ let block;
+ if (shared.isFunction(s)) {
+ const trackBlock = isBlockTreeEnabled && s._c;
+ if (trackBlock) {
+ s._d = false;
+ openBlock();
+ }
+ s = s();
+ if (trackBlock) {
+ s._d = true;
+ block = currentBlock;
+ closeBlock();
+ }
+ }
+ if (shared.isArray(s)) {
+ const singleChild = filterSingleRoot(s);
+ s = singleChild;
+ }
+ s = normalizeVNode(s);
+ if (block && !s.dynamicChildren) {
+ s.dynamicChildren = block.filter((c) => c !== s);
+ }
+ return s;
+}
+function queueEffectWithSuspense(fn, suspense) {
+ if (suspense && suspense.pendingBranch) {
+ if (shared.isArray(fn)) {
+ suspense.effects.push(...fn);
+ } else {
+ suspense.effects.push(fn);
+ }
+ } else {
+ queuePostFlushCb(fn);
+ }
+}
+function setActiveBranch(suspense, branch) {
+ suspense.activeBranch = branch;
+ const { vnode, parentComponent } = suspense;
+ const el = vnode.el = branch.el;
+ if (parentComponent && parentComponent.subTree === vnode) {
+ parentComponent.vnode.el = el;
+ updateHOCHostEl(parentComponent, el);
+ }
+}
+function isVNodeSuspensible(vnode) {
+ var _a;
+ return ((_a = vnode.props) == null ? void 0 : _a.suspensible) != null && vnode.props.suspensible !== false;
+}
+
+function watchEffect(effect, options) {
+ return doWatch(effect, null, options);
+}
+function watchPostEffect(effect, options) {
+ return doWatch(
+ effect,
+ null,
+ { flush: "post" }
+ );
+}
+function watchSyncEffect(effect, options) {
+ return doWatch(
+ effect,
+ null,
+ { flush: "sync" }
+ );
+}
+const INITIAL_WATCHER_VALUE = {};
+function watch(source, cb, options) {
+ return doWatch(source, cb, options);
+}
+function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = shared.EMPTY_OBJ) {
+ var _a;
+ const instance = reactivity.getCurrentScope() === ((_a = currentInstance) == null ? void 0 : _a.scope) ? currentInstance : null;
+ let getter;
+ let forceTrigger = false;
+ let isMultiSource = false;
+ if (reactivity.isRef(source)) {
+ getter = () => source.value;
+ forceTrigger = reactivity.isShallow(source);
+ } else if (reactivity.isReactive(source)) {
+ getter = () => source;
+ deep = true;
+ } else if (shared.isArray(source)) {
+ isMultiSource = true;
+ forceTrigger = source.some((s) => reactivity.isReactive(s) || reactivity.isShallow(s));
+ getter = () => source.map((s) => {
+ if (reactivity.isRef(s)) {
+ return s.value;
+ } else if (reactivity.isReactive(s)) {
+ return traverse(s);
+ } else if (shared.isFunction(s)) {
+ return callWithErrorHandling(s, instance, 2);
+ } else ;
+ });
+ } else if (shared.isFunction(source)) {
+ if (cb) {
+ getter = () => callWithErrorHandling(source, instance, 2);
+ } else {
+ getter = () => {
+ if (instance && instance.isUnmounted) {
+ return;
+ }
+ if (cleanup) {
+ cleanup();
+ }
+ return callWithAsyncErrorHandling(
+ source,
+ instance,
+ 3,
+ [onCleanup]
+ );
+ };
+ }
+ } else {
+ getter = shared.NOOP;
+ }
+ if (cb && deep) {
+ const baseGetter = getter;
+ getter = () => traverse(baseGetter());
+ }
+ let cleanup;
+ let onCleanup = (fn) => {
+ cleanup = effect.onStop = () => {
+ callWithErrorHandling(fn, instance, 4);
+ cleanup = effect.onStop = void 0;
+ };
+ };
+ let ssrCleanup;
+ if (isInSSRComponentSetup) {
+ onCleanup = shared.NOOP;
+ if (!cb) {
+ getter();
+ } else if (immediate) {
+ callWithAsyncErrorHandling(cb, instance, 3, [
+ getter(),
+ isMultiSource ? [] : void 0,
+ onCleanup
+ ]);
+ }
+ if (flush === "sync") {
+ const ctx = useSSRContext();
+ ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+ } else {
+ return shared.NOOP;
+ }
+ }
+ let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+ const job = () => {
+ if (!effect.active) {
+ return;
+ }
+ if (cb) {
+ const newValue = effect.run();
+ if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => shared.hasChanged(v, oldValue[i])) : shared.hasChanged(newValue, oldValue)) || false) {
+ if (cleanup) {
+ cleanup();
+ }
+ callWithAsyncErrorHandling(cb, instance, 3, [
+ newValue,
+ // pass undefined as the old value when it's changed for the first time
+ oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+ onCleanup
+ ]);
+ oldValue = newValue;
+ }
+ } else {
+ effect.run();
+ }
+ };
+ job.allowRecurse = !!cb;
+ let scheduler;
+ if (flush === "sync") {
+ scheduler = job;
+ } else if (flush === "post") {
+ scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+ } else {
+ job.pre = true;
+ if (instance)
+ job.id = instance.uid;
+ scheduler = () => queueJob(job);
+ }
+ const effect = new reactivity.ReactiveEffect(getter, scheduler);
+ if (cb) {
+ if (immediate) {
+ job();
+ } else {
+ oldValue = effect.run();
+ }
+ } else if (flush === "post") {
+ queuePostRenderEffect(
+ effect.run.bind(effect),
+ instance && instance.suspense
+ );
+ } else {
+ effect.run();
+ }
+ const unwatch = () => {
+ effect.stop();
+ if (instance && instance.scope) {
+ shared.remove(instance.scope.effects, effect);
+ }
+ };
+ if (ssrCleanup)
+ ssrCleanup.push(unwatch);
+ return unwatch;
+}
+function instanceWatch(source, value, options) {
+ const publicThis = this.proxy;
+ const getter = shared.isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+ let cb;
+ if (shared.isFunction(value)) {
+ cb = value;
+ } else {
+ cb = value.handler;
+ options = value;
+ }
+ const cur = currentInstance;
+ setCurrentInstance(this);
+ const res = doWatch(getter, cb.bind(publicThis), options);
+ if (cur) {
+ setCurrentInstance(cur);
+ } else {
+ unsetCurrentInstance();
+ }
+ return res;
+}
+function createPathGetter(ctx, path) {
+ const segments = path.split(".");
+ return () => {
+ let cur = ctx;
+ for (let i = 0; i < segments.length && cur; i++) {
+ cur = cur[segments[i]];
+ }
+ return cur;
+ };
+}
+function traverse(value, seen) {
+ if (!shared.isObject(value) || value["__v_skip"]) {
+ return value;
+ }
+ seen = seen || /* @__PURE__ */ new Set();
+ if (seen.has(value)) {
+ return value;
+ }
+ seen.add(value);
+ if (reactivity.isRef(value)) {
+ traverse(value.value, seen);
+ } else if (shared.isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ traverse(value[i], seen);
+ }
+ } else if (shared.isSet(value) || shared.isMap(value)) {
+ value.forEach((v) => {
+ traverse(v, seen);
+ });
+ } else if (shared.isPlainObject(value)) {
+ for (const key in value) {
+ traverse(value[key], seen);
+ }
+ }
+ return value;
+}
+
+function withDirectives(vnode, directives) {
+ const internalInstance = currentRenderingInstance;
+ if (internalInstance === null) {
+ return vnode;
+ }
+ const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
+ const bindings = vnode.dirs || (vnode.dirs = []);
+ for (let i = 0; i < directives.length; i++) {
+ let [dir, value, arg, modifiers = shared.EMPTY_OBJ] = directives[i];
+ if (dir) {
+ if (shared.isFunction(dir)) {
+ dir = {
+ mounted: dir,
+ updated: dir
+ };
+ }
+ if (dir.deep) {
+ traverse(value);
+ }
+ bindings.push({
+ dir,
+ instance,
+ value,
+ oldValue: void 0,
+ arg,
+ modifiers
+ });
+ }
+ }
+ return vnode;
+}
+function invokeDirectiveHook(vnode, prevVNode, instance, name) {
+ const bindings = vnode.dirs;
+ const oldBindings = prevVNode && prevVNode.dirs;
+ for (let i = 0; i < bindings.length; i++) {
+ const binding = bindings[i];
+ if (oldBindings) {
+ binding.oldValue = oldBindings[i].value;
+ }
+ let hook = binding.dir[name];
+ if (hook) {
+ reactivity.pauseTracking();
+ callWithAsyncErrorHandling(hook, instance, 8, [
+ vnode.el,
+ binding,
+ vnode,
+ prevVNode
+ ]);
+ reactivity.resetTracking();
+ }
+ }
+}
+
+const leaveCbKey = Symbol("_leaveCb");
+const enterCbKey = Symbol("_enterCb");
+function useTransitionState() {
+ const state = {
+ isMounted: false,
+ isLeaving: false,
+ isUnmounting: false,
+ leavingVNodes: /* @__PURE__ */ new Map()
+ };
+ onMounted(() => {
+ state.isMounted = true;
+ });
+ onBeforeUnmount(() => {
+ state.isUnmounting = true;
+ });
+ return state;
+}
+const TransitionHookValidator = [Function, Array];
+const BaseTransitionPropsValidators = {
+ mode: String,
+ appear: Boolean,
+ persisted: Boolean,
+ // enter
+ onBeforeEnter: TransitionHookValidator,
+ onEnter: TransitionHookValidator,
+ onAfterEnter: TransitionHookValidator,
+ onEnterCancelled: TransitionHookValidator,
+ // leave
+ onBeforeLeave: TransitionHookValidator,
+ onLeave: TransitionHookValidator,
+ onAfterLeave: TransitionHookValidator,
+ onLeaveCancelled: TransitionHookValidator,
+ // appear
+ onBeforeAppear: TransitionHookValidator,
+ onAppear: TransitionHookValidator,
+ onAfterAppear: TransitionHookValidator,
+ onAppearCancelled: TransitionHookValidator
+};
+const BaseTransitionImpl = {
+ name: `BaseTransition`,
+ props: BaseTransitionPropsValidators,
+ setup(props, { slots }) {
+ const instance = getCurrentInstance();
+ const state = useTransitionState();
+ let prevTransitionKey;
+ return () => {
+ const children = slots.default && getTransitionRawChildren(slots.default(), true);
+ if (!children || !children.length) {
+ return;
+ }
+ let child = children[0];
+ if (children.length > 1) {
+ for (const c of children) {
+ if (c.type !== Comment) {
+ child = c;
+ break;
+ }
+ }
+ }
+ const rawProps = reactivity.toRaw(props);
+ const { mode } = rawProps;
+ if (state.isLeaving) {
+ return emptyPlaceholder(child);
+ }
+ const innerChild = getKeepAliveChild(child);
+ if (!innerChild) {
+ return emptyPlaceholder(child);
+ }
+ const enterHooks = resolveTransitionHooks(
+ innerChild,
+ rawProps,
+ state,
+ instance
+ );
+ setTransitionHooks(innerChild, enterHooks);
+ const oldChild = instance.subTree;
+ const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
+ let transitionKeyChanged = false;
+ const { getTransitionKey } = innerChild.type;
+ if (getTransitionKey) {
+ const key = getTransitionKey();
+ if (prevTransitionKey === void 0) {
+ prevTransitionKey = key;
+ } else if (key !== prevTransitionKey) {
+ prevTransitionKey = key;
+ transitionKeyChanged = true;
+ }
+ }
+ if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
+ const leavingHooks = resolveTransitionHooks(
+ oldInnerChild,
+ rawProps,
+ state,
+ instance
+ );
+ setTransitionHooks(oldInnerChild, leavingHooks);
+ if (mode === "out-in") {
+ state.isLeaving = true;
+ leavingHooks.afterLeave = () => {
+ state.isLeaving = false;
+ if (instance.update.active !== false) {
+ instance.update();
+ }
+ };
+ return emptyPlaceholder(child);
+ } else if (mode === "in-out" && innerChild.type !== Comment) {
+ leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
+ const leavingVNodesCache = getLeavingNodesForType(
+ state,
+ oldInnerChild
+ );
+ leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
+ el[leaveCbKey] = () => {
+ earlyRemove();
+ el[leaveCbKey] = void 0;
+ delete enterHooks.delayedLeave;
+ };
+ enterHooks.delayedLeave = delayedLeave;
+ };
+ }
+ }
+ return child;
+ };
+ }
+};
+const BaseTransition = BaseTransitionImpl;
+function getLeavingNodesForType(state, vnode) {
+ const { leavingVNodes } = state;
+ let leavingVNodesCache = leavingVNodes.get(vnode.type);
+ if (!leavingVNodesCache) {
+ leavingVNodesCache = /* @__PURE__ */ Object.create(null);
+ leavingVNodes.set(vnode.type, leavingVNodesCache);
+ }
+ return leavingVNodesCache;
+}
+function resolveTransitionHooks(vnode, props, state, instance) {
+ const {
+ appear,
+ mode,
+ persisted = false,
+ onBeforeEnter,
+ onEnter,
+ onAfterEnter,
+ onEnterCancelled,
+ onBeforeLeave,
+ onLeave,
+ onAfterLeave,
+ onLeaveCancelled,
+ onBeforeAppear,
+ onAppear,
+ onAfterAppear,
+ onAppearCancelled
+ } = props;
+ const key = String(vnode.key);
+ const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+ const callHook = (hook, args) => {
+ hook && callWithAsyncErrorHandling(
+ hook,
+ instance,
+ 9,
+ args
+ );
+ };
+ const callAsyncHook = (hook, args) => {
+ const done = args[1];
+ callHook(hook, args);
+ if (shared.isArray(hook)) {
+ if (hook.every((hook2) => hook2.length <= 1))
+ done();
+ } else if (hook.length <= 1) {
+ done();
+ }
+ };
+ const hooks = {
+ mode,
+ persisted,
+ beforeEnter(el) {
+ let hook = onBeforeEnter;
+ if (!state.isMounted) {
+ if (appear) {
+ hook = onBeforeAppear || onBeforeEnter;
+ } else {
+ return;
+ }
+ }
+ if (el[leaveCbKey]) {
+ el[leaveCbKey](
+ true
+ /* cancelled */
+ );
+ }
+ const leavingVNode = leavingVNodesCache[key];
+ if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
+ leavingVNode.el[leaveCbKey]();
+ }
+ callHook(hook, [el]);
+ },
+ enter(el) {
+ let hook = onEnter;
+ let afterHook = onAfterEnter;
+ let cancelHook = onEnterCancelled;
+ if (!state.isMounted) {
+ if (appear) {
+ hook = onAppear || onEnter;
+ afterHook = onAfterAppear || onAfterEnter;
+ cancelHook = onAppearCancelled || onEnterCancelled;
+ } else {
+ return;
+ }
+ }
+ let called = false;
+ const done = el[enterCbKey] = (cancelled) => {
+ if (called)
+ return;
+ called = true;
+ if (cancelled) {
+ callHook(cancelHook, [el]);
+ } else {
+ callHook(afterHook, [el]);
+ }
+ if (hooks.delayedLeave) {
+ hooks.delayedLeave();
+ }
+ el[enterCbKey] = void 0;
+ };
+ if (hook) {
+ callAsyncHook(hook, [el, done]);
+ } else {
+ done();
+ }
+ },
+ leave(el, remove) {
+ const key2 = String(vnode.key);
+ if (el[enterCbKey]) {
+ el[enterCbKey](
+ true
+ /* cancelled */
+ );
+ }
+ if (state.isUnmounting) {
+ return remove();
+ }
+ callHook(onBeforeLeave, [el]);
+ let called = false;
+ const done = el[leaveCbKey] = (cancelled) => {
+ if (called)
+ return;
+ called = true;
+ remove();
+ if (cancelled) {
+ callHook(onLeaveCancelled, [el]);
+ } else {
+ callHook(onAfterLeave, [el]);
+ }
+ el[leaveCbKey] = void 0;
+ if (leavingVNodesCache[key2] === vnode) {
+ delete leavingVNodesCache[key2];
+ }
+ };
+ leavingVNodesCache[key2] = vnode;
+ if (onLeave) {
+ callAsyncHook(onLeave, [el, done]);
+ } else {
+ done();
+ }
+ },
+ clone(vnode2) {
+ return resolveTransitionHooks(vnode2, props, state, instance);
+ }
+ };
+ return hooks;
+}
+function emptyPlaceholder(vnode) {
+ if (isKeepAlive(vnode)) {
+ vnode = cloneVNode(vnode);
+ vnode.children = null;
+ return vnode;
+ }
+}
+function getKeepAliveChild(vnode) {
+ return isKeepAlive(vnode) ? (
+ // #7121 ensure get the child component subtree in case
+ // it's been replaced during HMR
+ vnode.children ? vnode.children[0] : void 0
+ ) : vnode;
+}
+function setTransitionHooks(vnode, hooks) {
+ if (vnode.shapeFlag & 6 && vnode.component) {
+ setTransitionHooks(vnode.component.subTree, hooks);
+ } else if (vnode.shapeFlag & 128) {
+ vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+ vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+ } else {
+ vnode.transition = hooks;
+ }
+}
+function getTransitionRawChildren(children, keepComment = false, parentKey) {
+ let ret = [];
+ let keyedFragmentCount = 0;
+ for (let i = 0; i < children.length; i++) {
+ let child = children[i];
+ const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
+ if (child.type === Fragment) {
+ if (child.patchFlag & 128)
+ keyedFragmentCount++;
+ ret = ret.concat(
+ getTransitionRawChildren(child.children, keepComment, key)
+ );
+ } else if (keepComment || child.type !== Comment) {
+ ret.push(key != null ? cloneVNode(child, { key }) : child);
+ }
+ }
+ if (keyedFragmentCount > 1) {
+ for (let i = 0; i < ret.length; i++) {
+ ret[i].patchFlag = -2;
+ }
+ }
+ return ret;
+}
+
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineComponent(options, extraOptions) {
+ return shared.isFunction(options) ? (
+ // #8326: extend call and options.name access are considered side-effects
+ // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+ /* @__PURE__ */ (() => shared.extend({ name: options.name }, extraOptions, { setup: options }))()
+ ) : options;
+}
+
+const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineAsyncComponent(source) {
+ if (shared.isFunction(source)) {
+ source = { loader: source };
+ }
+ const {
+ loader,
+ loadingComponent,
+ errorComponent,
+ delay = 200,
+ timeout,
+ // undefined = never times out
+ suspensible = true,
+ onError: userOnError
+ } = source;
+ let pendingRequest = null;
+ let resolvedComp;
+ let retries = 0;
+ const retry = () => {
+ retries++;
+ pendingRequest = null;
+ return load();
+ };
+ const load = () => {
+ let thisRequest;
+ return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+ err = err instanceof Error ? err : new Error(String(err));
+ if (userOnError) {
+ return new Promise((resolve, reject) => {
+ const userRetry = () => resolve(retry());
+ const userFail = () => reject(err);
+ userOnError(err, userRetry, userFail, retries + 1);
+ });
+ } else {
+ throw err;
+ }
+ }).then((comp) => {
+ if (thisRequest !== pendingRequest && pendingRequest) {
+ return pendingRequest;
+ }
+ if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+ comp = comp.default;
+ }
+ resolvedComp = comp;
+ return comp;
+ }));
+ };
+ return defineComponent({
+ name: "AsyncComponentWrapper",
+ __asyncLoader: load,
+ get __asyncResolved() {
+ return resolvedComp;
+ },
+ setup() {
+ const instance = currentInstance;
+ if (resolvedComp) {
+ return () => createInnerComp(resolvedComp, instance);
+ }
+ const onError = (err) => {
+ pendingRequest = null;
+ handleError(
+ err,
+ instance,
+ 13,
+ !errorComponent
+ /* do not throw in dev if user provided error component */
+ );
+ };
+ if (suspensible && instance.suspense || isInSSRComponentSetup) {
+ return load().then((comp) => {
+ return () => createInnerComp(comp, instance);
+ }).catch((err) => {
+ onError(err);
+ return () => errorComponent ? createVNode(errorComponent, {
+ error: err
+ }) : null;
+ });
+ }
+ const loaded = reactivity.ref(false);
+ const error = reactivity.ref();
+ const delayed = reactivity.ref(!!delay);
+ if (delay) {
+ setTimeout(() => {
+ delayed.value = false;
+ }, delay);
+ }
+ if (timeout != null) {
+ setTimeout(() => {
+ if (!loaded.value && !error.value) {
+ const err = new Error(
+ `Async component timed out after ${timeout}ms.`
+ );
+ onError(err);
+ error.value = err;
+ }
+ }, timeout);
+ }
+ load().then(() => {
+ loaded.value = true;
+ if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+ queueJob(instance.parent.update);
+ }
+ }).catch((err) => {
+ onError(err);
+ error.value = err;
+ });
+ return () => {
+ if (loaded.value && resolvedComp) {
+ return createInnerComp(resolvedComp, instance);
+ } else if (error.value && errorComponent) {
+ return createVNode(errorComponent, {
+ error: error.value
+ });
+ } else if (loadingComponent && !delayed.value) {
+ return createVNode(loadingComponent);
+ }
+ };
+ }
+ });
+}
+function createInnerComp(comp, parent) {
+ const { ref: ref2, props, children, ce } = parent.vnode;
+ const vnode = createVNode(comp, props, children);
+ vnode.ref = ref2;
+ vnode.ce = ce;
+ delete parent.vnode.ce;
+ return vnode;
+}
+
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+const KeepAliveImpl = {
+ name: `KeepAlive`,
+ // Marker for special handling inside the renderer. We are not using a ===
+ // check directly on KeepAlive in the renderer, because importing it directly
+ // would prevent it from being tree-shaken.
+ __isKeepAlive: true,
+ props: {
+ include: [String, RegExp, Array],
+ exclude: [String, RegExp, Array],
+ max: [String, Number]
+ },
+ setup(props, { slots }) {
+ const instance = getCurrentInstance();
+ const sharedContext = instance.ctx;
+ if (!sharedContext.renderer) {
+ return () => {
+ const children = slots.default && slots.default();
+ return children && children.length === 1 ? children[0] : children;
+ };
+ }
+ const cache = /* @__PURE__ */ new Map();
+ const keys = /* @__PURE__ */ new Set();
+ let current = null;
+ const parentSuspense = instance.suspense;
+ const {
+ renderer: {
+ p: patch,
+ m: move,
+ um: _unmount,
+ o: { createElement }
+ }
+ } = sharedContext;
+ const storageContainer = createElement("div");
+ sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
+ const instance2 = vnode.component;
+ move(vnode, container, anchor, 0, parentSuspense);
+ patch(
+ instance2.vnode,
+ vnode,
+ container,
+ anchor,
+ instance2,
+ parentSuspense,
+ isSVG,
+ vnode.slotScopeIds,
+ optimized
+ );
+ queuePostRenderEffect(() => {
+ instance2.isDeactivated = false;
+ if (instance2.a) {
+ shared.invokeArrayFns(instance2.a);
+ }
+ const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+ if (vnodeHook) {
+ invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+ }
+ }, parentSuspense);
+ };
+ sharedContext.deactivate = (vnode) => {
+ const instance2 = vnode.component;
+ move(vnode, storageContainer, null, 1, parentSuspense);
+ queuePostRenderEffect(() => {
+ if (instance2.da) {
+ shared.invokeArrayFns(instance2.da);
+ }
+ const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+ if (vnodeHook) {
+ invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+ }
+ instance2.isDeactivated = true;
+ }, parentSuspense);
+ };
+ function unmount(vnode) {
+ resetShapeFlag(vnode);
+ _unmount(vnode, instance, parentSuspense, true);
+ }
+ function pruneCache(filter) {
+ cache.forEach((vnode, key) => {
+ const name = getComponentName(vnode.type);
+ if (name && (!filter || !filter(name))) {
+ pruneCacheEntry(key);
+ }
+ });
+ }
+ function pruneCacheEntry(key) {
+ const cached = cache.get(key);
+ if (!current || !isSameVNodeType(cached, current)) {
+ unmount(cached);
+ } else if (current) {
+ resetShapeFlag(current);
+ }
+ cache.delete(key);
+ keys.delete(key);
+ }
+ watch(
+ () => [props.include, props.exclude],
+ ([include, exclude]) => {
+ include && pruneCache((name) => matches(include, name));
+ exclude && pruneCache((name) => !matches(exclude, name));
+ },
+ // prune post-render after `current` has been updated
+ { flush: "post", deep: true }
+ );
+ let pendingCacheKey = null;
+ const cacheSubtree = () => {
+ if (pendingCacheKey != null) {
+ cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+ }
+ };
+ onMounted(cacheSubtree);
+ onUpdated(cacheSubtree);
+ onBeforeUnmount(() => {
+ cache.forEach((cached) => {
+ const { subTree, suspense } = instance;
+ const vnode = getInnerChild(subTree);
+ if (cached.type === vnode.type && cached.key === vnode.key) {
+ resetShapeFlag(vnode);
+ const da = vnode.component.da;
+ da && queuePostRenderEffect(da, suspense);
+ return;
+ }
+ unmount(cached);
+ });
+ });
+ return () => {
+ pendingCacheKey = null;
+ if (!slots.default) {
+ return null;
+ }
+ const children = slots.default();
+ const rawVNode = children[0];
+ if (children.length > 1) {
+ current = null;
+ return children;
+ } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
+ current = null;
+ return rawVNode;
+ }
+ let vnode = getInnerChild(rawVNode);
+ const comp = vnode.type;
+ const name = getComponentName(
+ isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
+ );
+ const { include, exclude, max } = props;
+ if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+ current = vnode;
+ return rawVNode;
+ }
+ const key = vnode.key == null ? comp : vnode.key;
+ const cachedVNode = cache.get(key);
+ if (vnode.el) {
+ vnode = cloneVNode(vnode);
+ if (rawVNode.shapeFlag & 128) {
+ rawVNode.ssContent = vnode;
+ }
+ }
+ pendingCacheKey = key;
+ if (cachedVNode) {
+ vnode.el = cachedVNode.el;
+ vnode.component = cachedVNode.component;
+ if (vnode.transition) {
+ setTransitionHooks(vnode, vnode.transition);
+ }
+ vnode.shapeFlag |= 512;
+ keys.delete(key);
+ keys.add(key);
+ } else {
+ keys.add(key);
+ if (max && keys.size > parseInt(max, 10)) {
+ pruneCacheEntry(keys.values().next().value);
+ }
+ }
+ vnode.shapeFlag |= 256;
+ current = vnode;
+ return isSuspense(rawVNode.type) ? rawVNode : vnode;
+ };
+ }
+};
+const KeepAlive = KeepAliveImpl;
+function matches(pattern, name) {
+ if (shared.isArray(pattern)) {
+ return pattern.some((p) => matches(p, name));
+ } else if (shared.isString(pattern)) {
+ return pattern.split(",").includes(name);
+ } else if (shared.isRegExp(pattern)) {
+ return pattern.test(name);
+ }
+ return false;
+}
+function onActivated(hook, target) {
+ registerKeepAliveHook(hook, "a", target);
+}
+function onDeactivated(hook, target) {
+ registerKeepAliveHook(hook, "da", target);
+}
+function registerKeepAliveHook(hook, type, target = currentInstance) {
+ const wrappedHook = hook.__wdc || (hook.__wdc = () => {
+ let current = target;
+ while (current) {
+ if (current.isDeactivated) {
+ return;
+ }
+ current = current.parent;
+ }
+ return hook();
+ });
+ injectHook(type, wrappedHook, target);
+ if (target) {
+ let current = target.parent;
+ while (current && current.parent) {
+ if (isKeepAlive(current.parent.vnode)) {
+ injectToKeepAliveRoot(wrappedHook, type, target, current);
+ }
+ current = current.parent;
+ }
+ }
+}
+function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+ const injected = injectHook(
+ type,
+ hook,
+ keepAliveRoot,
+ true
+ /* prepend */
+ );
+ onUnmounted(() => {
+ shared.remove(keepAliveRoot[type], injected);
+ }, target);
+}
+function resetShapeFlag(vnode) {
+ vnode.shapeFlag &= ~256;
+ vnode.shapeFlag &= ~512;
+}
+function getInnerChild(vnode) {
+ return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
+}
+
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+ if (target) {
+ const hooks = target[type] || (target[type] = []);
+ const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+ if (target.isUnmounted) {
+ return;
+ }
+ reactivity.pauseTracking();
+ setCurrentInstance(target);
+ const res = callWithAsyncErrorHandling(hook, target, type, args);
+ unsetCurrentInstance();
+ reactivity.resetTracking();
+ return res;
+ });
+ if (prepend) {
+ hooks.unshift(wrappedHook);
+ } else {
+ hooks.push(wrappedHook);
+ }
+ return wrappedHook;
+ }
+}
+const createHook = (lifecycle) => (hook, target = currentInstance) => (
+ // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
+ (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
+);
+const onBeforeMount = createHook("bm");
+const onMounted = createHook("m");
+const onBeforeUpdate = createHook("bu");
+const onUpdated = createHook("u");
+const onBeforeUnmount = createHook("bum");
+const onUnmounted = createHook("um");
+const onServerPrefetch = createHook("sp");
+const onRenderTriggered = createHook(
+ "rtg"
+);
+const onRenderTracked = createHook(
+ "rtc"
+);
+function onErrorCaptured(hook, target = currentInstance) {
+ injectHook("ec", hook, target);
+}
+
+function renderList(source, renderItem, cache, index) {
+ let ret;
+ const cached = cache && cache[index];
+ if (shared.isArray(source) || shared.isString(source)) {
+ ret = new Array(source.length);
+ for (let i = 0, l = source.length; i < l; i++) {
+ ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
+ }
+ } else if (typeof source === "number") {
+ ret = new Array(source);
+ for (let i = 0; i < source; i++) {
+ ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
+ }
+ } else if (shared.isObject(source)) {
+ if (source[Symbol.iterator]) {
+ ret = Array.from(
+ source,
+ (item, i) => renderItem(item, i, void 0, cached && cached[i])
+ );
+ } else {
+ const keys = Object.keys(source);
+ ret = new Array(keys.length);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ const key = keys[i];
+ ret[i] = renderItem(source[key], key, i, cached && cached[i]);
+ }
+ }
+ } else {
+ ret = [];
+ }
+ if (cache) {
+ cache[index] = ret;
+ }
+ return ret;
+}
+
+function createSlots(slots, dynamicSlots) {
+ for (let i = 0; i < dynamicSlots.length; i++) {
+ const slot = dynamicSlots[i];
+ if (shared.isArray(slot)) {
+ for (let j = 0; j < slot.length; j++) {
+ slots[slot[j].name] = slot[j].fn;
+ }
+ } else if (slot) {
+ slots[slot.name] = slot.key ? (...args) => {
+ const res = slot.fn(...args);
+ if (res)
+ res.key = slot.key;
+ return res;
+ } : slot.fn;
+ }
+ }
+ return slots;
+}
+
+function renderSlot(slots, name, props = {}, fallback, noSlotted) {
+ if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
+ if (name !== "default")
+ props.name = name;
+ return createVNode("slot", props, fallback && fallback());
+ }
+ let slot = slots[name];
+ if (slot && slot._c) {
+ slot._d = false;
+ }
+ openBlock();
+ const validSlotContent = slot && ensureValidVNode(slot(props));
+ const rendered = createBlock(
+ Fragment,
+ {
+ key: props.key || // slot content array of a dynamic conditional slot may have a branch
+ // key attached in the `createSlots` helper, respect that
+ validSlotContent && validSlotContent.key || `_${name}`
+ },
+ validSlotContent || (fallback ? fallback() : []),
+ validSlotContent && slots._ === 1 ? 64 : -2
+ );
+ if (!noSlotted && rendered.scopeId) {
+ rendered.slotScopeIds = [rendered.scopeId + "-s"];
+ }
+ if (slot && slot._c) {
+ slot._d = true;
+ }
+ return rendered;
+}
+function ensureValidVNode(vnodes) {
+ return vnodes.some((child) => {
+ if (!isVNode(child))
+ return true;
+ if (child.type === Comment)
+ return false;
+ if (child.type === Fragment && !ensureValidVNode(child.children))
+ return false;
+ return true;
+ }) ? vnodes : null;
+}
+
+function toHandlers(obj, preserveCaseIfNecessary) {
+ const ret = {};
+ for (const key in obj) {
+ ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : shared.toHandlerKey(key)] = obj[key];
+ }
+ return ret;
+}
+
+const getPublicInstance = (i) => {
+ if (!i)
+ return null;
+ if (isStatefulComponent(i))
+ return getExposeProxy(i) || i.proxy;
+ return getPublicInstance(i.parent);
+};
+const publicPropertiesMap = (
+ // Move PURE marker to new line to workaround compiler discarding it
+ // due to type annotation
+ /* @__PURE__ */ shared.extend(/* @__PURE__ */ Object.create(null), {
+ $: (i) => i,
+ $el: (i) => i.vnode.el,
+ $data: (i) => i.data,
+ $props: (i) => i.props,
+ $attrs: (i) => i.attrs,
+ $slots: (i) => i.slots,
+ $refs: (i) => i.refs,
+ $parent: (i) => getPublicInstance(i.parent),
+ $root: (i) => getPublicInstance(i.root),
+ $emit: (i) => i.emit,
+ $options: (i) => resolveMergedOptions(i) ,
+ $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
+ $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+ $watch: (i) => instanceWatch.bind(i)
+ })
+);
+const hasSetupBinding = (state, key) => state !== shared.EMPTY_OBJ && !state.__isScriptSetup && shared.hasOwn(state, key);
+const PublicInstanceProxyHandlers = {
+ get({ _: instance }, key) {
+ const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+ let normalizedProps;
+ if (key[0] !== "$") {
+ const n = accessCache[key];
+ if (n !== void 0) {
+ switch (n) {
+ case 1 /* SETUP */:
+ return setupState[key];
+ case 2 /* DATA */:
+ return data[key];
+ case 4 /* CONTEXT */:
+ return ctx[key];
+ case 3 /* PROPS */:
+ return props[key];
+ }
+ } else if (hasSetupBinding(setupState, key)) {
+ accessCache[key] = 1 /* SETUP */;
+ return setupState[key];
+ } else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
+ accessCache[key] = 2 /* DATA */;
+ return data[key];
+ } else if (
+ // only cache other properties when instance has declared (thus stable)
+ // props
+ (normalizedProps = instance.propsOptions[0]) && shared.hasOwn(normalizedProps, key)
+ ) {
+ accessCache[key] = 3 /* PROPS */;
+ return props[key];
+ } else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
+ accessCache[key] = 4 /* CONTEXT */;
+ return ctx[key];
+ } else if (shouldCacheAccess) {
+ accessCache[key] = 0 /* OTHER */;
+ }
+ }
+ const publicGetter = publicPropertiesMap[key];
+ let cssModule, globalProperties;
+ if (publicGetter) {
+ if (key === "$attrs") {
+ reactivity.track(instance, "get", key);
+ }
+ return publicGetter(instance);
+ } else if (
+ // css module (injected by vue-loader)
+ (cssModule = type.__cssModules) && (cssModule = cssModule[key])
+ ) {
+ return cssModule;
+ } else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
+ accessCache[key] = 4 /* CONTEXT */;
+ return ctx[key];
+ } else if (
+ // global properties
+ globalProperties = appContext.config.globalProperties, shared.hasOwn(globalProperties, key)
+ ) {
+ {
+ return globalProperties[key];
+ }
+ } else ;
+ },
+ set({ _: instance }, key, value) {
+ const { data, setupState, ctx } = instance;
+ if (hasSetupBinding(setupState, key)) {
+ setupState[key] = value;
+ return true;
+ } else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
+ data[key] = value;
+ return true;
+ } else if (shared.hasOwn(instance.props, key)) {
+ return false;
+ }
+ if (key[0] === "$" && key.slice(1) in instance) {
+ return false;
+ } else {
+ {
+ ctx[key] = value;
+ }
+ }
+ return true;
+ },
+ has({
+ _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+ }, key) {
+ let normalizedProps;
+ return !!accessCache[key] || data !== shared.EMPTY_OBJ && shared.hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && shared.hasOwn(normalizedProps, key) || shared.hasOwn(ctx, key) || shared.hasOwn(publicPropertiesMap, key) || shared.hasOwn(appContext.config.globalProperties, key);
+ },
+ defineProperty(target, key, descriptor) {
+ if (descriptor.get != null) {
+ target._.accessCache[key] = 0;
+ } else if (shared.hasOwn(descriptor, "value")) {
+ this.set(target, key, descriptor.value, null);
+ }
+ return Reflect.defineProperty(target, key, descriptor);
+ }
+};
+const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ shared.extend(
+ {},
+ PublicInstanceProxyHandlers,
+ {
+ get(target, key) {
+ if (key === Symbol.unscopables) {
+ return;
+ }
+ return PublicInstanceProxyHandlers.get(target, key, target);
+ },
+ has(_, key) {
+ const has = key[0] !== "_" && !shared.isGloballyAllowed(key);
+ return has;
+ }
+ }
+);
+
+function defineProps() {
+ return null;
+}
+function defineEmits() {
+ return null;
+}
+function defineExpose(exposed) {
+}
+function defineOptions(options) {
+}
+function defineSlots() {
+ return null;
+}
+function defineModel() {
+}
+function withDefaults(props, defaults) {
+ return null;
+}
+function useSlots() {
+ return getContext().slots;
+}
+function useAttrs() {
+ return getContext().attrs;
+}
+function useModel(props, name, options) {
+ const i = getCurrentInstance();
+ if (options && options.local) {
+ const proxy = reactivity.ref(props[name]);
+ watch(
+ () => props[name],
+ (v) => proxy.value = v
+ );
+ watch(proxy, (value) => {
+ if (value !== props[name]) {
+ i.emit(`update:${name}`, value);
+ }
+ });
+ return proxy;
+ } else {
+ return {
+ __v_isRef: true,
+ get value() {
+ return props[name];
+ },
+ set value(value) {
+ i.emit(`update:${name}`, value);
+ }
+ };
+ }
+}
+function getContext() {
+ const i = getCurrentInstance();
+ return i.setupContext || (i.setupContext = createSetupContext(i));
+}
+function normalizePropsOrEmits(props) {
+ return shared.isArray(props) ? props.reduce(
+ (normalized, p) => (normalized[p] = null, normalized),
+ {}
+ ) : props;
+}
+function mergeDefaults(raw, defaults) {
+ const props = normalizePropsOrEmits(raw);
+ for (const key in defaults) {
+ if (key.startsWith("__skip"))
+ continue;
+ let opt = props[key];
+ if (opt) {
+ if (shared.isArray(opt) || shared.isFunction(opt)) {
+ opt = props[key] = { type: opt, default: defaults[key] };
+ } else {
+ opt.default = defaults[key];
+ }
+ } else if (opt === null) {
+ opt = props[key] = { default: defaults[key] };
+ } else ;
+ if (opt && defaults[`__skip_${key}`]) {
+ opt.skipFactory = true;
+ }
+ }
+ return props;
+}
+function mergeModels(a, b) {
+ if (!a || !b)
+ return a || b;
+ if (shared.isArray(a) && shared.isArray(b))
+ return a.concat(b);
+ return shared.extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+}
+function createPropsRestProxy(props, excludedKeys) {
+ const ret = {};
+ for (const key in props) {
+ if (!excludedKeys.includes(key)) {
+ Object.defineProperty(ret, key, {
+ enumerable: true,
+ get: () => props[key]
+ });
+ }
+ }
+ return ret;
+}
+function withAsyncContext(getAwaitable) {
+ const ctx = getCurrentInstance();
+ let awaitable = getAwaitable();
+ unsetCurrentInstance();
+ if (shared.isPromise(awaitable)) {
+ awaitable = awaitable.catch((e) => {
+ setCurrentInstance(ctx);
+ throw e;
+ });
+ }
+ return [awaitable, () => setCurrentInstance(ctx)];
+}
+
+let shouldCacheAccess = true;
+function applyOptions(instance) {
+ const options = resolveMergedOptions(instance);
+ const publicThis = instance.proxy;
+ const ctx = instance.ctx;
+ shouldCacheAccess = false;
+ if (options.beforeCreate) {
+ callHook(options.beforeCreate, instance, "bc");
+ }
+ const {
+ // state
+ data: dataOptions,
+ computed: computedOptions,
+ methods,
+ watch: watchOptions,
+ provide: provideOptions,
+ inject: injectOptions,
+ // lifecycle
+ created,
+ beforeMount,
+ mounted,
+ beforeUpdate,
+ updated,
+ activated,
+ deactivated,
+ beforeDestroy,
+ beforeUnmount,
+ destroyed,
+ unmounted,
+ render,
+ renderTracked,
+ renderTriggered,
+ errorCaptured,
+ serverPrefetch,
+ // public API
+ expose,
+ inheritAttrs,
+ // assets
+ components,
+ directives,
+ filters
+ } = options;
+ const checkDuplicateProperties = null;
+ if (injectOptions) {
+ resolveInjections(injectOptions, ctx, checkDuplicateProperties);
+ }
+ if (methods) {
+ for (const key in methods) {
+ const methodHandler = methods[key];
+ if (shared.isFunction(methodHandler)) {
+ {
+ ctx[key] = methodHandler.bind(publicThis);
+ }
+ }
+ }
+ }
+ if (dataOptions) {
+ const data = dataOptions.call(publicThis, publicThis);
+ if (!shared.isObject(data)) ; else {
+ instance.data = reactivity.reactive(data);
+ }
+ }
+ shouldCacheAccess = true;
+ if (computedOptions) {
+ for (const key in computedOptions) {
+ const opt = computedOptions[key];
+ const get = shared.isFunction(opt) ? opt.bind(publicThis, publicThis) : shared.isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : shared.NOOP;
+ const set = !shared.isFunction(opt) && shared.isFunction(opt.set) ? opt.set.bind(publicThis) : shared.NOOP;
+ const c = computed({
+ get,
+ set
+ });
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => c.value,
+ set: (v) => c.value = v
+ });
+ }
+ }
+ if (watchOptions) {
+ for (const key in watchOptions) {
+ createWatcher(watchOptions[key], ctx, publicThis, key);
+ }
+ }
+ if (provideOptions) {
+ const provides = shared.isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
+ Reflect.ownKeys(provides).forEach((key) => {
+ provide(key, provides[key]);
+ });
+ }
+ if (created) {
+ callHook(created, instance, "c");
+ }
+ function registerLifecycleHook(register, hook) {
+ if (shared.isArray(hook)) {
+ hook.forEach((_hook) => register(_hook.bind(publicThis)));
+ } else if (hook) {
+ register(hook.bind(publicThis));
+ }
+ }
+ registerLifecycleHook(onBeforeMount, beforeMount);
+ registerLifecycleHook(onMounted, mounted);
+ registerLifecycleHook(onBeforeUpdate, beforeUpdate);
+ registerLifecycleHook(onUpdated, updated);
+ registerLifecycleHook(onActivated, activated);
+ registerLifecycleHook(onDeactivated, deactivated);
+ registerLifecycleHook(onErrorCaptured, errorCaptured);
+ registerLifecycleHook(onRenderTracked, renderTracked);
+ registerLifecycleHook(onRenderTriggered, renderTriggered);
+ registerLifecycleHook(onBeforeUnmount, beforeUnmount);
+ registerLifecycleHook(onUnmounted, unmounted);
+ registerLifecycleHook(onServerPrefetch, serverPrefetch);
+ if (shared.isArray(expose)) {
+ if (expose.length) {
+ const exposed = instance.exposed || (instance.exposed = {});
+ expose.forEach((key) => {
+ Object.defineProperty(exposed, key, {
+ get: () => publicThis[key],
+ set: (val) => publicThis[key] = val
+ });
+ });
+ } else if (!instance.exposed) {
+ instance.exposed = {};
+ }
+ }
+ if (render && instance.render === shared.NOOP) {
+ instance.render = render;
+ }
+ if (inheritAttrs != null) {
+ instance.inheritAttrs = inheritAttrs;
+ }
+ if (components)
+ instance.components = components;
+ if (directives)
+ instance.directives = directives;
+}
+function resolveInjections(injectOptions, ctx, checkDuplicateProperties = shared.NOOP) {
+ if (shared.isArray(injectOptions)) {
+ injectOptions = normalizeInject(injectOptions);
+ }
+ for (const key in injectOptions) {
+ const opt = injectOptions[key];
+ let injected;
+ if (shared.isObject(opt)) {
+ if ("default" in opt) {
+ injected = inject(
+ opt.from || key,
+ opt.default,
+ true
+ /* treat default function as factory */
+ );
+ } else {
+ injected = inject(opt.from || key);
+ }
+ } else {
+ injected = inject(opt);
+ }
+ if (reactivity.isRef(injected)) {
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => injected.value,
+ set: (v) => injected.value = v
+ });
+ } else {
+ ctx[key] = injected;
+ }
+ }
+}
+function callHook(hook, instance, type) {
+ callWithAsyncErrorHandling(
+ shared.isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
+ instance,
+ type
+ );
+}
+function createWatcher(raw, ctx, publicThis, key) {
+ const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+ if (shared.isString(raw)) {
+ const handler = ctx[raw];
+ if (shared.isFunction(handler)) {
+ watch(getter, handler);
+ }
+ } else if (shared.isFunction(raw)) {
+ watch(getter, raw.bind(publicThis));
+ } else if (shared.isObject(raw)) {
+ if (shared.isArray(raw)) {
+ raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
+ } else {
+ const handler = shared.isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
+ if (shared.isFunction(handler)) {
+ watch(getter, handler, raw);
+ }
+ }
+ } else ;
+}
+function resolveMergedOptions(instance) {
+ const base = instance.type;
+ const { mixins, extends: extendsOptions } = base;
+ const {
+ mixins: globalMixins,
+ optionsCache: cache,
+ config: { optionMergeStrategies }
+ } = instance.appContext;
+ const cached = cache.get(base);
+ let resolved;
+ if (cached) {
+ resolved = cached;
+ } else if (!globalMixins.length && !mixins && !extendsOptions) {
+ {
+ resolved = base;
+ }
+ } else {
+ resolved = {};
+ if (globalMixins.length) {
+ globalMixins.forEach(
+ (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
+ );
+ }
+ mergeOptions(resolved, base, optionMergeStrategies);
+ }
+ if (shared.isObject(base)) {
+ cache.set(base, resolved);
+ }
+ return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+ const { mixins, extends: extendsOptions } = from;
+ if (extendsOptions) {
+ mergeOptions(to, extendsOptions, strats, true);
+ }
+ if (mixins) {
+ mixins.forEach(
+ (m) => mergeOptions(to, m, strats, true)
+ );
+ }
+ for (const key in from) {
+ if (asMixin && key === "expose") ; else {
+ const strat = internalOptionMergeStrats[key] || strats && strats[key];
+ to[key] = strat ? strat(to[key], from[key]) : from[key];
+ }
+ }
+ return to;
+}
+const internalOptionMergeStrats = {
+ data: mergeDataFn,
+ props: mergeEmitsOrPropsOptions,
+ emits: mergeEmitsOrPropsOptions,
+ // objects
+ methods: mergeObjectOptions,
+ computed: mergeObjectOptions,
+ // lifecycle
+ beforeCreate: mergeAsArray,
+ created: mergeAsArray,
+ beforeMount: mergeAsArray,
+ mounted: mergeAsArray,
+ beforeUpdate: mergeAsArray,
+ updated: mergeAsArray,
+ beforeDestroy: mergeAsArray,
+ beforeUnmount: mergeAsArray,
+ destroyed: mergeAsArray,
+ unmounted: mergeAsArray,
+ activated: mergeAsArray,
+ deactivated: mergeAsArray,
+ errorCaptured: mergeAsArray,
+ serverPrefetch: mergeAsArray,
+ // assets
+ components: mergeObjectOptions,
+ directives: mergeObjectOptions,
+ // watch
+ watch: mergeWatchOptions,
+ // provide / inject
+ provide: mergeDataFn,
+ inject: mergeInject
+};
+function mergeDataFn(to, from) {
+ if (!from) {
+ return to;
+ }
+ if (!to) {
+ return from;
+ }
+ return function mergedDataFn() {
+ return (shared.extend)(
+ shared.isFunction(to) ? to.call(this, this) : to,
+ shared.isFunction(from) ? from.call(this, this) : from
+ );
+ };
+}
+function mergeInject(to, from) {
+ return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+ if (shared.isArray(raw)) {
+ const res = {};
+ for (let i = 0; i < raw.length; i++) {
+ res[raw[i]] = raw[i];
+ }
+ return res;
+ }
+ return raw;
+}
+function mergeAsArray(to, from) {
+ return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+ return to ? shared.extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+}
+function mergeEmitsOrPropsOptions(to, from) {
+ if (to) {
+ if (shared.isArray(to) && shared.isArray(from)) {
+ return [.../* @__PURE__ */ new Set([...to, ...from])];
+ }
+ return shared.extend(
+ /* @__PURE__ */ Object.create(null),
+ normalizePropsOrEmits(to),
+ normalizePropsOrEmits(from != null ? from : {})
+ );
+ } else {
+ return from;
+ }
+}
+function mergeWatchOptions(to, from) {
+ if (!to)
+ return from;
+ if (!from)
+ return to;
+ const merged = shared.extend(/* @__PURE__ */ Object.create(null), to);
+ for (const key in from) {
+ merged[key] = mergeAsArray(to[key], from[key]);
+ }
+ return merged;
+}
+
+function createAppContext() {
+ return {
+ app: null,
+ config: {
+ isNativeTag: shared.NO,
+ performance: false,
+ globalProperties: {},
+ optionMergeStrategies: {},
+ errorHandler: void 0,
+ warnHandler: void 0,
+ compilerOptions: {}
+ },
+ mixins: [],
+ components: {},
+ directives: {},
+ provides: /* @__PURE__ */ Object.create(null),
+ optionsCache: /* @__PURE__ */ new WeakMap(),
+ propsCache: /* @__PURE__ */ new WeakMap(),
+ emitsCache: /* @__PURE__ */ new WeakMap()
+ };
+}
+let uid$1 = 0;
+function createAppAPI(render, hydrate) {
+ return function createApp(rootComponent, rootProps = null) {
+ if (!shared.isFunction(rootComponent)) {
+ rootComponent = shared.extend({}, rootComponent);
+ }
+ if (rootProps != null && !shared.isObject(rootProps)) {
+ rootProps = null;
+ }
+ const context = createAppContext();
+ const installedPlugins = /* @__PURE__ */ new WeakSet();
+ let isMounted = false;
+ const app = context.app = {
+ _uid: uid$1++,
+ _component: rootComponent,
+ _props: rootProps,
+ _container: null,
+ _context: context,
+ _instance: null,
+ version,
+ get config() {
+ return context.config;
+ },
+ set config(v) {
+ },
+ use(plugin, ...options) {
+ if (installedPlugins.has(plugin)) ; else if (plugin && shared.isFunction(plugin.install)) {
+ installedPlugins.add(plugin);
+ plugin.install(app, ...options);
+ } else if (shared.isFunction(plugin)) {
+ installedPlugins.add(plugin);
+ plugin(app, ...options);
+ } else ;
+ return app;
+ },
+ mixin(mixin) {
+ {
+ if (!context.mixins.includes(mixin)) {
+ context.mixins.push(mixin);
+ }
+ }
+ return app;
+ },
+ component(name, component) {
+ if (!component) {
+ return context.components[name];
+ }
+ context.components[name] = component;
+ return app;
+ },
+ directive(name, directive) {
+ if (!directive) {
+ return context.directives[name];
+ }
+ context.directives[name] = directive;
+ return app;
+ },
+ mount(rootContainer, isHydrate, isSVG) {
+ if (!isMounted) {
+ const vnode = createVNode(rootComponent, rootProps);
+ vnode.appContext = context;
+ if (isHydrate && hydrate) {
+ hydrate(vnode, rootContainer);
+ } else {
+ render(vnode, rootContainer, isSVG);
+ }
+ isMounted = true;
+ app._container = rootContainer;
+ rootContainer.__vue_app__ = app;
+ return getExposeProxy(vnode.component) || vnode.component.proxy;
+ }
+ },
+ unmount() {
+ if (isMounted) {
+ render(null, app._container);
+ delete app._container.__vue_app__;
+ }
+ },
+ provide(key, value) {
+ context.provides[key] = value;
+ return app;
+ },
+ runWithContext(fn) {
+ currentApp = app;
+ try {
+ return fn();
+ } finally {
+ currentApp = null;
+ }
+ }
+ };
+ return app;
+ };
+}
+let currentApp = null;
+
+function provide(key, value) {
+ if (!currentInstance) ; else {
+ let provides = currentInstance.provides;
+ const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+ if (parentProvides === provides) {
+ provides = currentInstance.provides = Object.create(parentProvides);
+ }
+ provides[key] = value;
+ }
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+ const instance = currentInstance || currentRenderingInstance;
+ if (instance || currentApp) {
+ const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+ if (provides && key in provides) {
+ return provides[key];
+ } else if (arguments.length > 1) {
+ return treatDefaultAsFactory && shared.isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+ } else ;
+ }
+}
+function hasInjectionContext() {
+ return !!(currentInstance || currentRenderingInstance || currentApp);
+}
+
+function initProps(instance, rawProps, isStateful, isSSR = false) {
+ const props = {};
+ const attrs = {};
+ shared.def(attrs, InternalObjectKey, 1);
+ instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+ setFullProps(instance, rawProps, props, attrs);
+ for (const key in instance.propsOptions[0]) {
+ if (!(key in props)) {
+ props[key] = void 0;
+ }
+ }
+ if (isStateful) {
+ instance.props = isSSR ? props : reactivity.shallowReactive(props);
+ } else {
+ if (!instance.type.props) {
+ instance.props = attrs;
+ } else {
+ instance.props = props;
+ }
+ }
+ instance.attrs = attrs;
+}
+function updateProps(instance, rawProps, rawPrevProps, optimized) {
+ const {
+ props,
+ attrs,
+ vnode: { patchFlag }
+ } = instance;
+ const rawCurrentProps = reactivity.toRaw(props);
+ const [options] = instance.propsOptions;
+ let hasAttrsChanged = false;
+ if (
+ // always force full diff in dev
+ // - #1942 if hmr is enabled with sfc component
+ // - vite#872 non-sfc component used by sfc component
+ (optimized || patchFlag > 0) && !(patchFlag & 16)
+ ) {
+ if (patchFlag & 8) {
+ const propsToUpdate = instance.vnode.dynamicProps;
+ for (let i = 0; i < propsToUpdate.length; i++) {
+ let key = propsToUpdate[i];
+ if (isEmitListener(instance.emitsOptions, key)) {
+ continue;
+ }
+ const value = rawProps[key];
+ if (options) {
+ if (shared.hasOwn(attrs, key)) {
+ if (value !== attrs[key]) {
+ attrs[key] = value;
+ hasAttrsChanged = true;
+ }
+ } else {
+ const camelizedKey = shared.camelize(key);
+ props[camelizedKey] = resolvePropValue(
+ options,
+ rawCurrentProps,
+ camelizedKey,
+ value,
+ instance,
+ false
+ /* isAbsent */
+ );
+ }
+ } else {
+ if (value !== attrs[key]) {
+ attrs[key] = value;
+ hasAttrsChanged = true;
+ }
+ }
+ }
+ }
+ } else {
+ if (setFullProps(instance, rawProps, props, attrs)) {
+ hasAttrsChanged = true;
+ }
+ let kebabKey;
+ for (const key in rawCurrentProps) {
+ if (!rawProps || // for camelCase
+ !shared.hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+ // and converted to camelCase (#955)
+ ((kebabKey = shared.hyphenate(key)) === key || !shared.hasOwn(rawProps, kebabKey))) {
+ if (options) {
+ if (rawPrevProps && // for camelCase
+ (rawPrevProps[key] !== void 0 || // for kebab-case
+ rawPrevProps[kebabKey] !== void 0)) {
+ props[key] = resolvePropValue(
+ options,
+ rawCurrentProps,
+ key,
+ void 0,
+ instance,
+ true
+ /* isAbsent */
+ );
+ }
+ } else {
+ delete props[key];
+ }
+ }
+ }
+ if (attrs !== rawCurrentProps) {
+ for (const key in attrs) {
+ if (!rawProps || !shared.hasOwn(rawProps, key) && true) {
+ delete attrs[key];
+ hasAttrsChanged = true;
+ }
+ }
+ }
+ }
+ if (hasAttrsChanged) {
+ reactivity.trigger(instance, "set", "$attrs");
+ }
+}
+function setFullProps(instance, rawProps, props, attrs) {
+ const [options, needCastKeys] = instance.propsOptions;
+ let hasAttrsChanged = false;
+ let rawCastValues;
+ if (rawProps) {
+ for (let key in rawProps) {
+ if (shared.isReservedProp(key)) {
+ continue;
+ }
+ const value = rawProps[key];
+ let camelKey;
+ if (options && shared.hasOwn(options, camelKey = shared.camelize(key))) {
+ if (!needCastKeys || !needCastKeys.includes(camelKey)) {
+ props[camelKey] = value;
+ } else {
+ (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+ }
+ } else if (!isEmitListener(instance.emitsOptions, key)) {
+ if (!(key in attrs) || value !== attrs[key]) {
+ attrs[key] = value;
+ hasAttrsChanged = true;
+ }
+ }
+ }
+ }
+ if (needCastKeys) {
+ const rawCurrentProps = reactivity.toRaw(props);
+ const castValues = rawCastValues || shared.EMPTY_OBJ;
+ for (let i = 0; i < needCastKeys.length; i++) {
+ const key = needCastKeys[i];
+ props[key] = resolvePropValue(
+ options,
+ rawCurrentProps,
+ key,
+ castValues[key],
+ instance,
+ !shared.hasOwn(castValues, key)
+ );
+ }
+ }
+ return hasAttrsChanged;
+}
+function resolvePropValue(options, props, key, value, instance, isAbsent) {
+ const opt = options[key];
+ if (opt != null) {
+ const hasDefault = shared.hasOwn(opt, "default");
+ if (hasDefault && value === void 0) {
+ const defaultValue = opt.default;
+ if (opt.type !== Function && !opt.skipFactory && shared.isFunction(defaultValue)) {
+ const { propsDefaults } = instance;
+ if (key in propsDefaults) {
+ value = propsDefaults[key];
+ } else {
+ setCurrentInstance(instance);
+ value = propsDefaults[key] = defaultValue.call(
+ null,
+ props
+ );
+ unsetCurrentInstance();
+ }
+ } else {
+ value = defaultValue;
+ }
+ }
+ if (opt[0 /* shouldCast */]) {
+ if (isAbsent && !hasDefault) {
+ value = false;
+ } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === shared.hyphenate(key))) {
+ value = true;
+ }
+ }
+ }
+ return value;
+}
+function normalizePropsOptions(comp, appContext, asMixin = false) {
+ const cache = appContext.propsCache;
+ const cached = cache.get(comp);
+ if (cached) {
+ return cached;
+ }
+ const raw = comp.props;
+ const normalized = {};
+ const needCastKeys = [];
+ let hasExtends = false;
+ if (!shared.isFunction(comp)) {
+ const extendProps = (raw2) => {
+ hasExtends = true;
+ const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+ shared.extend(normalized, props);
+ if (keys)
+ needCastKeys.push(...keys);
+ };
+ if (!asMixin && appContext.mixins.length) {
+ appContext.mixins.forEach(extendProps);
+ }
+ if (comp.extends) {
+ extendProps(comp.extends);
+ }
+ if (comp.mixins) {
+ comp.mixins.forEach(extendProps);
+ }
+ }
+ if (!raw && !hasExtends) {
+ if (shared.isObject(comp)) {
+ cache.set(comp, shared.EMPTY_ARR);
+ }
+ return shared.EMPTY_ARR;
+ }
+ if (shared.isArray(raw)) {
+ for (let i = 0; i < raw.length; i++) {
+ const normalizedKey = shared.camelize(raw[i]);
+ if (validatePropName(normalizedKey)) {
+ normalized[normalizedKey] = shared.EMPTY_OBJ;
+ }
+ }
+ } else if (raw) {
+ for (const key in raw) {
+ const normalizedKey = shared.camelize(key);
+ if (validatePropName(normalizedKey)) {
+ const opt = raw[key];
+ const prop = normalized[normalizedKey] = shared.isArray(opt) || shared.isFunction(opt) ? { type: opt } : shared.extend({}, opt);
+ if (prop) {
+ const booleanIndex = getTypeIndex(Boolean, prop.type);
+ const stringIndex = getTypeIndex(String, prop.type);
+ prop[0 /* shouldCast */] = booleanIndex > -1;
+ prop[1 /* shouldCastTrue */] = stringIndex < 0 || booleanIndex < stringIndex;
+ if (booleanIndex > -1 || shared.hasOwn(prop, "default")) {
+ needCastKeys.push(normalizedKey);
+ }
+ }
+ }
+ }
+ }
+ const res = [normalized, needCastKeys];
+ if (shared.isObject(comp)) {
+ cache.set(comp, res);
+ }
+ return res;
+}
+function validatePropName(key) {
+ if (key[0] !== "$") {
+ return true;
+ }
+ return false;
+}
+function getType(ctor) {
+ const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
+ return match ? match[2] : ctor === null ? "null" : "";
+}
+function isSameType(a, b) {
+ return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+ if (shared.isArray(expectedTypes)) {
+ return expectedTypes.findIndex((t) => isSameType(t, type));
+ } else if (shared.isFunction(expectedTypes)) {
+ return isSameType(expectedTypes, type) ? 0 : -1;
+ }
+ return -1;
+}
+
+const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+const normalizeSlotValue = (value) => shared.isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+const normalizeSlot = (key, rawSlot, ctx) => {
+ if (rawSlot._n) {
+ return rawSlot;
+ }
+ const normalized = withCtx((...args) => {
+ if (false) ;
+ return normalizeSlotValue(rawSlot(...args));
+ }, ctx);
+ normalized._c = false;
+ return normalized;
+};
+const normalizeObjectSlots = (rawSlots, slots, instance) => {
+ const ctx = rawSlots._ctx;
+ for (const key in rawSlots) {
+ if (isInternalKey(key))
+ continue;
+ const value = rawSlots[key];
+ if (shared.isFunction(value)) {
+ slots[key] = normalizeSlot(key, value, ctx);
+ } else if (value != null) {
+ const normalized = normalizeSlotValue(value);
+ slots[key] = () => normalized;
+ }
+ }
+};
+const normalizeVNodeSlots = (instance, children) => {
+ const normalized = normalizeSlotValue(children);
+ instance.slots.default = () => normalized;
+};
+const initSlots = (instance, children) => {
+ if (instance.vnode.shapeFlag & 32) {
+ const type = children._;
+ if (type) {
+ instance.slots = reactivity.toRaw(children);
+ shared.def(children, "_", type);
+ } else {
+ normalizeObjectSlots(
+ children,
+ instance.slots = {});
+ }
+ } else {
+ instance.slots = {};
+ if (children) {
+ normalizeVNodeSlots(instance, children);
+ }
+ }
+ shared.def(instance.slots, InternalObjectKey, 1);
+};
+const updateSlots = (instance, children, optimized) => {
+ const { vnode, slots } = instance;
+ let needDeletionCheck = true;
+ let deletionComparisonTarget = shared.EMPTY_OBJ;
+ if (vnode.shapeFlag & 32) {
+ const type = children._;
+ if (type) {
+ if (optimized && type === 1) {
+ needDeletionCheck = false;
+ } else {
+ shared.extend(slots, children);
+ if (!optimized && type === 1) {
+ delete slots._;
+ }
+ }
+ } else {
+ needDeletionCheck = !children.$stable;
+ normalizeObjectSlots(children, slots);
+ }
+ deletionComparisonTarget = children;
+ } else if (children) {
+ normalizeVNodeSlots(instance, children);
+ deletionComparisonTarget = { default: 1 };
+ }
+ if (needDeletionCheck) {
+ for (const key in slots) {
+ if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
+ delete slots[key];
+ }
+ }
+ }
+};
+
+function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
+ if (shared.isArray(rawRef)) {
+ rawRef.forEach(
+ (r, i) => setRef(
+ r,
+ oldRawRef && (shared.isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
+ parentSuspense,
+ vnode,
+ isUnmount
+ )
+ );
+ return;
+ }
+ if (isAsyncWrapper(vnode) && !isUnmount) {
+ return;
+ }
+ const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
+ const value = isUnmount ? null : refValue;
+ const { i: owner, r: ref } = rawRef;
+ const oldRef = oldRawRef && oldRawRef.r;
+ const refs = owner.refs === shared.EMPTY_OBJ ? owner.refs = {} : owner.refs;
+ const setupState = owner.setupState;
+ if (oldRef != null && oldRef !== ref) {
+ if (shared.isString(oldRef)) {
+ refs[oldRef] = null;
+ if (shared.hasOwn(setupState, oldRef)) {
+ setupState[oldRef] = null;
+ }
+ } else if (reactivity.isRef(oldRef)) {
+ oldRef.value = null;
+ }
+ }
+ if (shared.isFunction(ref)) {
+ callWithErrorHandling(ref, owner, 12, [value, refs]);
+ } else {
+ const _isString = shared.isString(ref);
+ const _isRef = reactivity.isRef(ref);
+ if (_isString || _isRef) {
+ const doSet = () => {
+ if (rawRef.f) {
+ const existing = _isString ? shared.hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
+ if (isUnmount) {
+ shared.isArray(existing) && shared.remove(existing, refValue);
+ } else {
+ if (!shared.isArray(existing)) {
+ if (_isString) {
+ refs[ref] = [refValue];
+ if (shared.hasOwn(setupState, ref)) {
+ setupState[ref] = refs[ref];
+ }
+ } else {
+ ref.value = [refValue];
+ if (rawRef.k)
+ refs[rawRef.k] = ref.value;
+ }
+ } else if (!existing.includes(refValue)) {
+ existing.push(refValue);
+ }
+ }
+ } else if (_isString) {
+ refs[ref] = value;
+ if (shared.hasOwn(setupState, ref)) {
+ setupState[ref] = value;
+ }
+ } else if (_isRef) {
+ ref.value = value;
+ if (rawRef.k)
+ refs[rawRef.k] = value;
+ } else ;
+ };
+ if (value) {
+ doSet.id = -1;
+ queuePostRenderEffect(doSet, parentSuspense);
+ } else {
+ doSet();
+ }
+ }
+ }
+}
+
+let hasMismatch = false;
+const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== "foreignObject";
+const isComment = (node) => node.nodeType === 8 /* COMMENT */;
+function createHydrationFunctions(rendererInternals) {
+ const {
+ mt: mountComponent,
+ p: patch,
+ o: {
+ patchProp,
+ createText,
+ nextSibling,
+ parentNode,
+ remove,
+ insert,
+ createComment
+ }
+ } = rendererInternals;
+ const hydrate = (vnode, container) => {
+ if (!container.hasChildNodes()) {
+ patch(null, vnode, container);
+ flushPostFlushCbs();
+ container._vnode = vnode;
+ return;
+ }
+ hasMismatch = false;
+ hydrateNode(container.firstChild, vnode, null, null, null);
+ flushPostFlushCbs();
+ container._vnode = vnode;
+ if (hasMismatch && true) {
+ console.error(`Hydration completed but contains mismatches.`);
+ }
+ };
+ const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
+ const isFragmentStart = isComment(node) && node.data === "[";
+ const onMismatch = () => handleMismatch(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ isFragmentStart
+ );
+ const { type, ref, shapeFlag, patchFlag } = vnode;
+ let domType = node.nodeType;
+ vnode.el = node;
+ if (patchFlag === -2) {
+ optimized = false;
+ vnode.dynamicChildren = null;
+ }
+ let nextNode = null;
+ switch (type) {
+ case Text:
+ if (domType !== 3 /* TEXT */) {
+ if (vnode.children === "") {
+ insert(vnode.el = createText(""), parentNode(node), node);
+ nextNode = node;
+ } else {
+ nextNode = onMismatch();
+ }
+ } else {
+ if (node.data !== vnode.children) {
+ hasMismatch = true;
+ node.data = vnode.children;
+ }
+ nextNode = nextSibling(node);
+ }
+ break;
+ case Comment:
+ if (isTemplateNode(node)) {
+ nextNode = nextSibling(node);
+ replaceNode(
+ vnode.el = node.content.firstChild,
+ node,
+ parentComponent
+ );
+ } else if (domType !== 8 /* COMMENT */ || isFragmentStart) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = nextSibling(node);
+ }
+ break;
+ case Static:
+ if (isFragmentStart) {
+ node = nextSibling(node);
+ domType = node.nodeType;
+ }
+ if (domType === 1 /* ELEMENT */ || domType === 3 /* TEXT */) {
+ nextNode = node;
+ const needToAdoptContent = !vnode.children.length;
+ for (let i = 0; i < vnode.staticCount; i++) {
+ if (needToAdoptContent)
+ vnode.children += nextNode.nodeType === 1 /* ELEMENT */ ? nextNode.outerHTML : nextNode.data;
+ if (i === vnode.staticCount - 1) {
+ vnode.anchor = nextNode;
+ }
+ nextNode = nextSibling(nextNode);
+ }
+ return isFragmentStart ? nextSibling(nextNode) : nextNode;
+ } else {
+ onMismatch();
+ }
+ break;
+ case Fragment:
+ if (!isFragmentStart) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = hydrateFragment(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ }
+ break;
+ default:
+ if (shapeFlag & 1) {
+ if ((domType !== 1 /* ELEMENT */ || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = hydrateElement(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ }
+ } else if (shapeFlag & 6) {
+ vnode.slotScopeIds = slotScopeIds;
+ const container = parentNode(node);
+ if (isFragmentStart) {
+ nextNode = locateClosingAnchor(node);
+ } else if (isComment(node) && node.data === "teleport start") {
+ nextNode = locateClosingAnchor(node, node.data, "teleport end");
+ } else {
+ nextNode = nextSibling(node);
+ }
+ mountComponent(
+ vnode,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(container),
+ optimized
+ );
+ if (isAsyncWrapper(vnode)) {
+ let subTree;
+ if (isFragmentStart) {
+ subTree = createVNode(Fragment);
+ subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
+ } else {
+ subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
+ }
+ subTree.el = node;
+ vnode.component.subTree = subTree;
+ }
+ } else if (shapeFlag & 64) {
+ if (domType !== 8 /* COMMENT */) {
+ nextNode = onMismatch();
+ } else {
+ nextNode = vnode.type.hydrate(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized,
+ rendererInternals,
+ hydrateChildren
+ );
+ }
+ } else if (shapeFlag & 128) {
+ nextNode = vnode.type.hydrate(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(parentNode(node)),
+ slotScopeIds,
+ optimized,
+ rendererInternals,
+ hydrateNode
+ );
+ } else ;
+ }
+ if (ref != null) {
+ setRef(ref, null, parentSuspense, vnode);
+ }
+ return nextNode;
+ };
+ const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+ optimized = optimized || !!vnode.dynamicChildren;
+ const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
+ const forcePatch = type === "input" || type === "option";
+ if (forcePatch || patchFlag !== -1) {
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "created");
+ }
+ if (props) {
+ if (forcePatch || !optimized || patchFlag & (16 | 32)) {
+ for (const key in props) {
+ if (forcePatch && (key.endsWith("value") || key === "indeterminate") || shared.isOn(key) && !shared.isReservedProp(key) || // force hydrate v-bind with .prop modifiers
+ key[0] === ".") {
+ patchProp(
+ el,
+ key,
+ null,
+ props[key],
+ false,
+ void 0,
+ parentComponent
+ );
+ }
+ }
+ } else if (props.onClick) {
+ patchProp(
+ el,
+ "onClick",
+ null,
+ props.onClick,
+ false,
+ void 0,
+ parentComponent
+ );
+ }
+ }
+ let vnodeHooks;
+ if (vnodeHooks = props && props.onVnodeBeforeMount) {
+ invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+ }
+ let needCallTransitionHooks = false;
+ if (isTemplateNode(el)) {
+ needCallTransitionHooks = needTransition(parentSuspense, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
+ const content = el.content.firstChild;
+ if (needCallTransitionHooks) {
+ transition.beforeEnter(content);
+ }
+ replaceNode(content, el, parentComponent);
+ vnode.el = el = content;
+ }
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+ }
+ if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
+ queueEffectWithSuspense(() => {
+ vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+ needCallTransitionHooks && transition.enter(el);
+ dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+ }, parentSuspense);
+ }
+ if (shapeFlag & 16 && // skip if element has innerHTML / textContent
+ !(props && (props.innerHTML || props.textContent))) {
+ let next = hydrateChildren(
+ el.firstChild,
+ vnode,
+ el,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ while (next) {
+ hasMismatch = true;
+ const cur = next;
+ next = next.nextSibling;
+ remove(cur);
+ }
+ } else if (shapeFlag & 8) {
+ if (el.textContent !== vnode.children) {
+ hasMismatch = true;
+ el.textContent = vnode.children;
+ }
+ }
+ }
+ return el.nextSibling;
+ };
+ const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+ optimized = optimized || !!parentVNode.dynamicChildren;
+ const children = parentVNode.children;
+ const l = children.length;
+ for (let i = 0; i < l; i++) {
+ const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
+ if (node) {
+ node = hydrateNode(
+ node,
+ vnode,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ } else if (vnode.type === Text && !vnode.children) {
+ continue;
+ } else {
+ hasMismatch = true;
+ patch(
+ null,
+ vnode,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(container),
+ slotScopeIds
+ );
+ }
+ }
+ return node;
+ };
+ const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+ const { slotScopeIds: fragmentSlotScopeIds } = vnode;
+ if (fragmentSlotScopeIds) {
+ slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+ }
+ const container = parentNode(node);
+ const next = hydrateChildren(
+ nextSibling(node),
+ vnode,
+ container,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ if (next && isComment(next) && next.data === "]") {
+ return nextSibling(vnode.anchor = next);
+ } else {
+ hasMismatch = true;
+ insert(vnode.anchor = createComment(`]`), container, next);
+ return next;
+ }
+ };
+ const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
+ hasMismatch = true;
+ vnode.el = null;
+ if (isFragment) {
+ const end = locateClosingAnchor(node);
+ while (true) {
+ const next2 = nextSibling(node);
+ if (next2 && next2 !== end) {
+ remove(next2);
+ } else {
+ break;
+ }
+ }
+ }
+ const next = nextSibling(node);
+ const container = parentNode(node);
+ remove(node);
+ patch(
+ null,
+ vnode,
+ container,
+ next,
+ parentComponent,
+ parentSuspense,
+ isSVGContainer(container),
+ slotScopeIds
+ );
+ return next;
+ };
+ const locateClosingAnchor = (node, open = "[", close = "]") => {
+ let match = 0;
+ while (node) {
+ node = nextSibling(node);
+ if (node && isComment(node)) {
+ if (node.data === open)
+ match++;
+ if (node.data === close) {
+ if (match === 0) {
+ return nextSibling(node);
+ } else {
+ match--;
+ }
+ }
+ }
+ }
+ return node;
+ };
+ const replaceNode = (newNode, oldNode, parentComponent) => {
+ const parentNode2 = oldNode.parentNode;
+ if (parentNode2) {
+ parentNode2.replaceChild(newNode, oldNode);
+ }
+ let parent = parentComponent;
+ while (parent) {
+ if (parent.vnode.el === oldNode) {
+ parent.vnode.el = parent.subTree.el = newNode;
+ }
+ parent = parent.parent;
+ }
+ };
+ const isTemplateNode = (node) => {
+ return node.nodeType === 1 /* ELEMENT */ && node.tagName.toLowerCase() === "template";
+ };
+ return [hydrate, hydrateNode];
+}
+
+const queuePostRenderEffect = queueEffectWithSuspense ;
+function createRenderer(options) {
+ return baseCreateRenderer(options);
+}
+function createHydrationRenderer(options) {
+ return baseCreateRenderer(options, createHydrationFunctions);
+}
+function baseCreateRenderer(options, createHydrationFns) {
+ const target = shared.getGlobalThis();
+ target.__VUE__ = true;
+ const {
+ insert: hostInsert,
+ remove: hostRemove,
+ patchProp: hostPatchProp,
+ createElement: hostCreateElement,
+ createText: hostCreateText,
+ createComment: hostCreateComment,
+ setText: hostSetText,
+ setElementText: hostSetElementText,
+ parentNode: hostParentNode,
+ nextSibling: hostNextSibling,
+ setScopeId: hostSetScopeId = shared.NOOP,
+ insertStaticContent: hostInsertStaticContent
+ } = options;
+ const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
+ if (n1 === n2) {
+ return;
+ }
+ if (n1 && !isSameVNodeType(n1, n2)) {
+ anchor = getNextHostNode(n1);
+ unmount(n1, parentComponent, parentSuspense, true);
+ n1 = null;
+ }
+ if (n2.patchFlag === -2) {
+ optimized = false;
+ n2.dynamicChildren = null;
+ }
+ const { type, ref, shapeFlag } = n2;
+ switch (type) {
+ case Text:
+ processText(n1, n2, container, anchor);
+ break;
+ case Comment:
+ processCommentNode(n1, n2, container, anchor);
+ break;
+ case Static:
+ if (n1 == null) {
+ mountStaticNode(n2, container, anchor, isSVG);
+ }
+ break;
+ case Fragment:
+ processFragment(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ break;
+ default:
+ if (shapeFlag & 1) {
+ processElement(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else if (shapeFlag & 6) {
+ processComponent(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else if (shapeFlag & 64) {
+ type.process(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ internals
+ );
+ } else if (shapeFlag & 128) {
+ type.process(
+ n1,
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ internals
+ );
+ } else ;
+ }
+ if (ref != null && parentComponent) {
+ setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
+ }
+ };
+ const processText = (n1, n2, container, anchor) => {
+ if (n1 == null) {
+ hostInsert(
+ n2.el = hostCreateText(n2.children),
+ container,
+ anchor
+ );
+ } else {
+ const el = n2.el = n1.el;
+ if (n2.children !== n1.children) {
+ hostSetText(el, n2.children);
+ }
+ }
+ };
+ const processCommentNode = (n1, n2, container, anchor) => {
+ if (n1 == null) {
+ hostInsert(
+ n2.el = hostCreateComment(n2.children || ""),
+ container,
+ anchor
+ );
+ } else {
+ n2.el = n1.el;
+ }
+ };
+ const mountStaticNode = (n2, container, anchor, isSVG) => {
+ [n2.el, n2.anchor] = hostInsertStaticContent(
+ n2.children,
+ container,
+ anchor,
+ isSVG,
+ n2.el,
+ n2.anchor
+ );
+ };
+ const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
+ let next;
+ while (el && el !== anchor) {
+ next = hostNextSibling(el);
+ hostInsert(el, container, nextSibling);
+ el = next;
+ }
+ hostInsert(anchor, container, nextSibling);
+ };
+ const removeStaticNode = ({ el, anchor }) => {
+ let next;
+ while (el && el !== anchor) {
+ next = hostNextSibling(el);
+ hostRemove(el);
+ el = next;
+ }
+ hostRemove(anchor);
+ };
+ const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ isSVG = isSVG || n2.type === "svg";
+ if (n1 == null) {
+ mountElement(
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ patchElement(
+ n1,
+ n2,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ let el;
+ let vnodeHook;
+ const { type, props, shapeFlag, transition, dirs } = vnode;
+ el = vnode.el = hostCreateElement(
+ vnode.type,
+ isSVG,
+ props && props.is,
+ props
+ );
+ if (shapeFlag & 8) {
+ hostSetElementText(el, vnode.children);
+ } else if (shapeFlag & 16) {
+ mountChildren(
+ vnode.children,
+ el,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG && type !== "foreignObject",
+ slotScopeIds,
+ optimized
+ );
+ }
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "created");
+ }
+ setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
+ if (props) {
+ for (const key in props) {
+ if (key !== "value" && !shared.isReservedProp(key)) {
+ hostPatchProp(
+ el,
+ key,
+ null,
+ props[key],
+ isSVG,
+ vnode.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ if ("value" in props) {
+ hostPatchProp(el, "value", null, props.value);
+ }
+ if (vnodeHook = props.onVnodeBeforeMount) {
+ invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ }
+ }
+ if (dirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+ }
+ const needCallTransitionHooks = needTransition(parentSuspense, transition);
+ if (needCallTransitionHooks) {
+ transition.beforeEnter(el);
+ }
+ hostInsert(el, container, anchor);
+ if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
+ queuePostRenderEffect(() => {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ needCallTransitionHooks && transition.enter(el);
+ dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+ }, parentSuspense);
+ }
+ };
+ const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
+ if (scopeId) {
+ hostSetScopeId(el, scopeId);
+ }
+ if (slotScopeIds) {
+ for (let i = 0; i < slotScopeIds.length; i++) {
+ hostSetScopeId(el, slotScopeIds[i]);
+ }
+ }
+ if (parentComponent) {
+ let subTree = parentComponent.subTree;
+ if (vnode === subTree) {
+ const parentVNode = parentComponent.vnode;
+ setScopeId(
+ el,
+ parentVNode,
+ parentVNode.scopeId,
+ parentVNode.slotScopeIds,
+ parentComponent.parent
+ );
+ }
+ }
+ };
+ const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => {
+ for (let i = start; i < children.length; i++) {
+ const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
+ patch(
+ null,
+ child,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ const el = n2.el = n1.el;
+ let { patchFlag, dynamicChildren, dirs } = n2;
+ patchFlag |= n1.patchFlag & 16;
+ const oldProps = n1.props || shared.EMPTY_OBJ;
+ const newProps = n2.props || shared.EMPTY_OBJ;
+ let vnodeHook;
+ parentComponent && toggleRecurse(parentComponent, false);
+ if (vnodeHook = newProps.onVnodeBeforeUpdate) {
+ invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+ }
+ if (dirs) {
+ invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
+ }
+ parentComponent && toggleRecurse(parentComponent, true);
+ const areChildrenSVG = isSVG && n2.type !== "foreignObject";
+ if (dynamicChildren) {
+ patchBlockChildren(
+ n1.dynamicChildren,
+ dynamicChildren,
+ el,
+ parentComponent,
+ parentSuspense,
+ areChildrenSVG,
+ slotScopeIds
+ );
+ } else if (!optimized) {
+ patchChildren(
+ n1,
+ n2,
+ el,
+ null,
+ parentComponent,
+ parentSuspense,
+ areChildrenSVG,
+ slotScopeIds,
+ false
+ );
+ }
+ if (patchFlag > 0) {
+ if (patchFlag & 16) {
+ patchProps(
+ el,
+ n2,
+ oldProps,
+ newProps,
+ parentComponent,
+ parentSuspense,
+ isSVG
+ );
+ } else {
+ if (patchFlag & 2) {
+ if (oldProps.class !== newProps.class) {
+ hostPatchProp(el, "class", null, newProps.class, isSVG);
+ }
+ }
+ if (patchFlag & 4) {
+ hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);
+ }
+ if (patchFlag & 8) {
+ const propsToUpdate = n2.dynamicProps;
+ for (let i = 0; i < propsToUpdate.length; i++) {
+ const key = propsToUpdate[i];
+ const prev = oldProps[key];
+ const next = newProps[key];
+ if (next !== prev || key === "value") {
+ hostPatchProp(
+ el,
+ key,
+ prev,
+ next,
+ isSVG,
+ n1.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ }
+ }
+ if (patchFlag & 1) {
+ if (n1.children !== n2.children) {
+ hostSetElementText(el, n2.children);
+ }
+ }
+ } else if (!optimized && dynamicChildren == null) {
+ patchProps(
+ el,
+ n2,
+ oldProps,
+ newProps,
+ parentComponent,
+ parentSuspense,
+ isSVG
+ );
+ }
+ if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
+ queuePostRenderEffect(() => {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+ dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
+ }, parentSuspense);
+ }
+ };
+ const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {
+ for (let i = 0; i < newChildren.length; i++) {
+ const oldVNode = oldChildren[i];
+ const newVNode = newChildren[i];
+ const container = (
+ // oldVNode may be an errored async setup() component inside Suspense
+ // which will not have a mounted element
+ oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
+ // of the Fragment itself so it can move its children.
+ (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
+ // which also requires the correct parent container
+ !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
+ oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
+ // In other cases, the parent container is not actually used so we
+ // just pass the block element here to avoid a DOM parentNode call.
+ fallbackContainer
+ )
+ );
+ patch(
+ oldVNode,
+ newVNode,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ true
+ );
+ }
+ };
+ const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
+ if (oldProps !== newProps) {
+ if (oldProps !== shared.EMPTY_OBJ) {
+ for (const key in oldProps) {
+ if (!shared.isReservedProp(key) && !(key in newProps)) {
+ hostPatchProp(
+ el,
+ key,
+ oldProps[key],
+ null,
+ isSVG,
+ vnode.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ }
+ for (const key in newProps) {
+ if (shared.isReservedProp(key))
+ continue;
+ const next = newProps[key];
+ const prev = oldProps[key];
+ if (next !== prev && key !== "value") {
+ hostPatchProp(
+ el,
+ key,
+ prev,
+ next,
+ isSVG,
+ vnode.children,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ }
+ }
+ if ("value" in newProps) {
+ hostPatchProp(el, "value", oldProps.value, newProps.value);
+ }
+ }
+ };
+ const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
+ const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
+ let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
+ if (fragmentSlotScopeIds) {
+ slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+ }
+ if (n1 == null) {
+ hostInsert(fragmentStartAnchor, container, anchor);
+ hostInsert(fragmentEndAnchor, container, anchor);
+ mountChildren(
+ n2.children,
+ container,
+ fragmentEndAnchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
+ // of renderSlot() with no valid children
+ n1.dynamicChildren) {
+ patchBlockChildren(
+ n1.dynamicChildren,
+ dynamicChildren,
+ container,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds
+ );
+ if (
+ // #2080 if the stable fragment has a key, it's a <template v-for> that may
+ // get moved around. Make sure all root level vnodes inherit el.
+ // #2134 or if it's a component root, it may also get moved around
+ // as the component is being moved.
+ n2.key != null || parentComponent && n2 === parentComponent.subTree
+ ) {
+ traverseStaticChildren(
+ n1,
+ n2,
+ true
+ /* shallow */
+ );
+ }
+ } else {
+ patchChildren(
+ n1,
+ n2,
+ container,
+ fragmentEndAnchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ }
+ };
+ const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ n2.slotScopeIds = slotScopeIds;
+ if (n1 == null) {
+ if (n2.shapeFlag & 512) {
+ parentComponent.ctx.activate(
+ n2,
+ container,
+ anchor,
+ isSVG,
+ optimized
+ );
+ } else {
+ mountComponent(
+ n2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ optimized
+ );
+ }
+ } else {
+ updateComponent(n1, n2, optimized);
+ }
+ };
+ const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
+ const instance = (initialVNode.component = createComponentInstance(
+ initialVNode,
+ parentComponent,
+ parentSuspense
+ ));
+ if (isKeepAlive(initialVNode)) {
+ instance.ctx.renderer = internals;
+ }
+ {
+ setupComponent(instance);
+ }
+ if (instance.asyncDep) {
+ parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
+ if (!initialVNode.el) {
+ const placeholder = instance.subTree = createVNode(Comment);
+ processCommentNode(null, placeholder, container, anchor);
+ }
+ return;
+ }
+ setupRenderEffect(
+ instance,
+ initialVNode,
+ container,
+ anchor,
+ parentSuspense,
+ isSVG,
+ optimized
+ );
+ };
+ const updateComponent = (n1, n2, optimized) => {
+ const instance = n2.component = n1.component;
+ if (shouldUpdateComponent(n1, n2, optimized)) {
+ if (instance.asyncDep && !instance.asyncResolved) {
+ updateComponentPreRender(instance, n2, optimized);
+ return;
+ } else {
+ instance.next = n2;
+ invalidateJob(instance.update);
+ instance.update();
+ }
+ } else {
+ n2.el = n1.el;
+ instance.vnode = n2;
+ }
+ };
+ const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
+ const componentUpdateFn = () => {
+ if (!instance.isMounted) {
+ let vnodeHook;
+ const { el, props } = initialVNode;
+ const { bm, m, parent } = instance;
+ const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
+ toggleRecurse(instance, false);
+ if (bm) {
+ shared.invokeArrayFns(bm);
+ }
+ if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
+ invokeVNodeHook(vnodeHook, parent, initialVNode);
+ }
+ toggleRecurse(instance, true);
+ if (el && hydrateNode) {
+ const hydrateSubTree = () => {
+ instance.subTree = renderComponentRoot(instance);
+ hydrateNode(
+ el,
+ instance.subTree,
+ instance,
+ parentSuspense,
+ null
+ );
+ };
+ if (isAsyncWrapperVNode) {
+ initialVNode.type.__asyncLoader().then(
+ // note: we are moving the render call into an async callback,
+ // which means it won't track dependencies - but it's ok because
+ // a server-rendered async wrapper is already in resolved state
+ // and it will never need to change.
+ () => !instance.isUnmounted && hydrateSubTree()
+ );
+ } else {
+ hydrateSubTree();
+ }
+ } else {
+ const subTree = instance.subTree = renderComponentRoot(instance);
+ patch(
+ null,
+ subTree,
+ container,
+ anchor,
+ instance,
+ parentSuspense,
+ isSVG
+ );
+ initialVNode.el = subTree.el;
+ }
+ if (m) {
+ queuePostRenderEffect(m, parentSuspense);
+ }
+ if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
+ const scopedInitialVNode = initialVNode;
+ queuePostRenderEffect(
+ () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
+ parentSuspense
+ );
+ }
+ if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
+ instance.a && queuePostRenderEffect(instance.a, parentSuspense);
+ }
+ instance.isMounted = true;
+ initialVNode = container = anchor = null;
+ } else {
+ let { next, bu, u, parent, vnode } = instance;
+ let originNext = next;
+ let vnodeHook;
+ toggleRecurse(instance, false);
+ if (next) {
+ next.el = vnode.el;
+ updateComponentPreRender(instance, next, optimized);
+ } else {
+ next = vnode;
+ }
+ if (bu) {
+ shared.invokeArrayFns(bu);
+ }
+ if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
+ invokeVNodeHook(vnodeHook, parent, next, vnode);
+ }
+ toggleRecurse(instance, true);
+ const nextTree = renderComponentRoot(instance);
+ const prevTree = instance.subTree;
+ instance.subTree = nextTree;
+ patch(
+ prevTree,
+ nextTree,
+ // parent may have changed if it's in a teleport
+ hostParentNode(prevTree.el),
+ // anchor may have changed if it's in a fragment
+ getNextHostNode(prevTree),
+ instance,
+ parentSuspense,
+ isSVG
+ );
+ next.el = nextTree.el;
+ if (originNext === null) {
+ updateHOCHostEl(instance, nextTree.el);
+ }
+ if (u) {
+ queuePostRenderEffect(u, parentSuspense);
+ }
+ if (vnodeHook = next.props && next.props.onVnodeUpdated) {
+ queuePostRenderEffect(
+ () => invokeVNodeHook(vnodeHook, parent, next, vnode),
+ parentSuspense
+ );
+ }
+ }
+ };
+ const effect = instance.effect = new reactivity.ReactiveEffect(
+ componentUpdateFn,
+ () => queueJob(update),
+ instance.scope
+ // track it in component's effect scope
+ );
+ const update = instance.update = () => effect.run();
+ update.id = instance.uid;
+ toggleRecurse(instance, true);
+ update();
+ };
+ const updateComponentPreRender = (instance, nextVNode, optimized) => {
+ nextVNode.component = instance;
+ const prevProps = instance.vnode.props;
+ instance.vnode = nextVNode;
+ instance.next = null;
+ updateProps(instance, nextVNode.props, prevProps, optimized);
+ updateSlots(instance, nextVNode.children, optimized);
+ reactivity.pauseTracking();
+ flushPreFlushCbs();
+ reactivity.resetTracking();
+ };
+ const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {
+ const c1 = n1 && n1.children;
+ const prevShapeFlag = n1 ? n1.shapeFlag : 0;
+ const c2 = n2.children;
+ const { patchFlag, shapeFlag } = n2;
+ if (patchFlag > 0) {
+ if (patchFlag & 128) {
+ patchKeyedChildren(
+ c1,
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ return;
+ } else if (patchFlag & 256) {
+ patchUnkeyedChildren(
+ c1,
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ return;
+ }
+ }
+ if (shapeFlag & 8) {
+ if (prevShapeFlag & 16) {
+ unmountChildren(c1, parentComponent, parentSuspense);
+ }
+ if (c2 !== c1) {
+ hostSetElementText(container, c2);
+ }
+ } else {
+ if (prevShapeFlag & 16) {
+ if (shapeFlag & 16) {
+ patchKeyedChildren(
+ c1,
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ unmountChildren(c1, parentComponent, parentSuspense, true);
+ }
+ } else {
+ if (prevShapeFlag & 8) {
+ hostSetElementText(container, "");
+ }
+ if (shapeFlag & 16) {
+ mountChildren(
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ }
+ }
+ };
+ const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ c1 = c1 || shared.EMPTY_ARR;
+ c2 = c2 || shared.EMPTY_ARR;
+ const oldLength = c1.length;
+ const newLength = c2.length;
+ const commonLength = Math.min(oldLength, newLength);
+ let i;
+ for (i = 0; i < commonLength; i++) {
+ const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+ patch(
+ c1[i],
+ nextChild,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ if (oldLength > newLength) {
+ unmountChildren(
+ c1,
+ parentComponent,
+ parentSuspense,
+ true,
+ false,
+ commonLength
+ );
+ } else {
+ mountChildren(
+ c2,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized,
+ commonLength
+ );
+ }
+ };
+ const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
+ let i = 0;
+ const l2 = c2.length;
+ let e1 = c1.length - 1;
+ let e2 = l2 - 1;
+ while (i <= e1 && i <= e2) {
+ const n1 = c1[i];
+ const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+ if (isSameVNodeType(n1, n2)) {
+ patch(
+ n1,
+ n2,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ break;
+ }
+ i++;
+ }
+ while (i <= e1 && i <= e2) {
+ const n1 = c1[e1];
+ const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
+ if (isSameVNodeType(n1, n2)) {
+ patch(
+ n1,
+ n2,
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else {
+ break;
+ }
+ e1--;
+ e2--;
+ }
+ if (i > e1) {
+ if (i <= e2) {
+ const nextPos = e2 + 1;
+ const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
+ while (i <= e2) {
+ patch(
+ null,
+ c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ i++;
+ }
+ }
+ } else if (i > e2) {
+ while (i <= e1) {
+ unmount(c1[i], parentComponent, parentSuspense, true);
+ i++;
+ }
+ } else {
+ const s1 = i;
+ const s2 = i;
+ const keyToNewIndexMap = /* @__PURE__ */ new Map();
+ for (i = s2; i <= e2; i++) {
+ const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+ if (nextChild.key != null) {
+ keyToNewIndexMap.set(nextChild.key, i);
+ }
+ }
+ let j;
+ let patched = 0;
+ const toBePatched = e2 - s2 + 1;
+ let moved = false;
+ let maxNewIndexSoFar = 0;
+ const newIndexToOldIndexMap = new Array(toBePatched);
+ for (i = 0; i < toBePatched; i++)
+ newIndexToOldIndexMap[i] = 0;
+ for (i = s1; i <= e1; i++) {
+ const prevChild = c1[i];
+ if (patched >= toBePatched) {
+ unmount(prevChild, parentComponent, parentSuspense, true);
+ continue;
+ }
+ let newIndex;
+ if (prevChild.key != null) {
+ newIndex = keyToNewIndexMap.get(prevChild.key);
+ } else {
+ for (j = s2; j <= e2; j++) {
+ if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
+ newIndex = j;
+ break;
+ }
+ }
+ }
+ if (newIndex === void 0) {
+ unmount(prevChild, parentComponent, parentSuspense, true);
+ } else {
+ newIndexToOldIndexMap[newIndex - s2] = i + 1;
+ if (newIndex >= maxNewIndexSoFar) {
+ maxNewIndexSoFar = newIndex;
+ } else {
+ moved = true;
+ }
+ patch(
+ prevChild,
+ c2[newIndex],
+ container,
+ null,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ patched++;
+ }
+ }
+ const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : shared.EMPTY_ARR;
+ j = increasingNewIndexSequence.length - 1;
+ for (i = toBePatched - 1; i >= 0; i--) {
+ const nextIndex = s2 + i;
+ const nextChild = c2[nextIndex];
+ const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
+ if (newIndexToOldIndexMap[i] === 0) {
+ patch(
+ null,
+ nextChild,
+ container,
+ anchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ } else if (moved) {
+ if (j < 0 || i !== increasingNewIndexSequence[j]) {
+ move(nextChild, container, anchor, 2);
+ } else {
+ j--;
+ }
+ }
+ }
+ }
+ };
+ const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
+ const { el, type, transition, children, shapeFlag } = vnode;
+ if (shapeFlag & 6) {
+ move(vnode.component.subTree, container, anchor, moveType);
+ return;
+ }
+ if (shapeFlag & 128) {
+ vnode.suspense.move(container, anchor, moveType);
+ return;
+ }
+ if (shapeFlag & 64) {
+ type.move(vnode, container, anchor, internals);
+ return;
+ }
+ if (type === Fragment) {
+ hostInsert(el, container, anchor);
+ for (let i = 0; i < children.length; i++) {
+ move(children[i], container, anchor, moveType);
+ }
+ hostInsert(vnode.anchor, container, anchor);
+ return;
+ }
+ if (type === Static) {
+ moveStaticNode(vnode, container, anchor);
+ return;
+ }
+ const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
+ if (needTransition2) {
+ if (moveType === 0) {
+ transition.beforeEnter(el);
+ hostInsert(el, container, anchor);
+ queuePostRenderEffect(() => transition.enter(el), parentSuspense);
+ } else {
+ const { leave, delayLeave, afterLeave } = transition;
+ const remove2 = () => hostInsert(el, container, anchor);
+ const performLeave = () => {
+ leave(el, () => {
+ remove2();
+ afterLeave && afterLeave();
+ });
+ };
+ if (delayLeave) {
+ delayLeave(el, remove2, performLeave);
+ } else {
+ performLeave();
+ }
+ }
+ } else {
+ hostInsert(el, container, anchor);
+ }
+ };
+ const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
+ const {
+ type,
+ props,
+ ref,
+ children,
+ dynamicChildren,
+ shapeFlag,
+ patchFlag,
+ dirs
+ } = vnode;
+ if (ref != null) {
+ setRef(ref, null, parentSuspense, vnode, true);
+ }
+ if (shapeFlag & 256) {
+ parentComponent.ctx.deactivate(vnode);
+ return;
+ }
+ const shouldInvokeDirs = shapeFlag & 1 && dirs;
+ const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
+ let vnodeHook;
+ if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
+ invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ }
+ if (shapeFlag & 6) {
+ unmountComponent(vnode.component, parentSuspense, doRemove);
+ } else {
+ if (shapeFlag & 128) {
+ vnode.suspense.unmount(parentSuspense, doRemove);
+ return;
+ }
+ if (shouldInvokeDirs) {
+ invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
+ }
+ if (shapeFlag & 64) {
+ vnode.type.remove(
+ vnode,
+ parentComponent,
+ parentSuspense,
+ optimized,
+ internals,
+ doRemove
+ );
+ } else if (dynamicChildren && // #1153: fast path should not be taken for non-stable (v-for) fragments
+ (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
+ unmountChildren(
+ dynamicChildren,
+ parentComponent,
+ parentSuspense,
+ false,
+ true
+ );
+ } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
+ unmountChildren(children, parentComponent, parentSuspense);
+ }
+ if (doRemove) {
+ remove(vnode);
+ }
+ }
+ if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
+ queuePostRenderEffect(() => {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
+ }, parentSuspense);
+ }
+ };
+ const remove = (vnode) => {
+ const { type, el, anchor, transition } = vnode;
+ if (type === Fragment) {
+ {
+ removeFragment(el, anchor);
+ }
+ return;
+ }
+ if (type === Static) {
+ removeStaticNode(vnode);
+ return;
+ }
+ const performRemove = () => {
+ hostRemove(el);
+ if (transition && !transition.persisted && transition.afterLeave) {
+ transition.afterLeave();
+ }
+ };
+ if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
+ const { leave, delayLeave } = transition;
+ const performLeave = () => leave(el, performRemove);
+ if (delayLeave) {
+ delayLeave(vnode.el, performRemove, performLeave);
+ } else {
+ performLeave();
+ }
+ } else {
+ performRemove();
+ }
+ };
+ const removeFragment = (cur, end) => {
+ let next;
+ while (cur !== end) {
+ next = hostNextSibling(cur);
+ hostRemove(cur);
+ cur = next;
+ }
+ hostRemove(end);
+ };
+ const unmountComponent = (instance, parentSuspense, doRemove) => {
+ const { bum, scope, update, subTree, um } = instance;
+ if (bum) {
+ shared.invokeArrayFns(bum);
+ }
+ scope.stop();
+ if (update) {
+ update.active = false;
+ unmount(subTree, instance, parentSuspense, doRemove);
+ }
+ if (um) {
+ queuePostRenderEffect(um, parentSuspense);
+ }
+ queuePostRenderEffect(() => {
+ instance.isUnmounted = true;
+ }, parentSuspense);
+ if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
+ parentSuspense.deps--;
+ if (parentSuspense.deps === 0) {
+ parentSuspense.resolve();
+ }
+ }
+ };
+ const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
+ for (let i = start; i < children.length; i++) {
+ unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
+ }
+ };
+ const getNextHostNode = (vnode) => {
+ if (vnode.shapeFlag & 6) {
+ return getNextHostNode(vnode.component.subTree);
+ }
+ if (vnode.shapeFlag & 128) {
+ return vnode.suspense.next();
+ }
+ return hostNextSibling(vnode.anchor || vnode.el);
+ };
+ const render = (vnode, container, isSVG) => {
+ if (vnode == null) {
+ if (container._vnode) {
+ unmount(container._vnode, null, null, true);
+ }
+ } else {
+ patch(container._vnode || null, vnode, container, null, null, null, isSVG);
+ }
+ flushPreFlushCbs();
+ flushPostFlushCbs();
+ container._vnode = vnode;
+ };
+ const internals = {
+ p: patch,
+ um: unmount,
+ m: move,
+ r: remove,
+ mt: mountComponent,
+ mc: mountChildren,
+ pc: patchChildren,
+ pbc: patchBlockChildren,
+ n: getNextHostNode,
+ o: options
+ };
+ let hydrate;
+ let hydrateNode;
+ if (createHydrationFns) {
+ [hydrate, hydrateNode] = createHydrationFns(
+ internals
+ );
+ }
+ return {
+ render,
+ hydrate,
+ createApp: createAppAPI(render, hydrate)
+ };
+}
+function toggleRecurse({ effect, update }, allowed) {
+ effect.allowRecurse = update.allowRecurse = allowed;
+}
+function needTransition(parentSuspense, transition) {
+ return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
+}
+function traverseStaticChildren(n1, n2, shallow = false) {
+ const ch1 = n1.children;
+ const ch2 = n2.children;
+ if (shared.isArray(ch1) && shared.isArray(ch2)) {
+ for (let i = 0; i < ch1.length; i++) {
+ const c1 = ch1[i];
+ let c2 = ch2[i];
+ if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
+ if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
+ c2 = ch2[i] = cloneIfMounted(ch2[i]);
+ c2.el = c1.el;
+ }
+ if (!shallow)
+ traverseStaticChildren(c1, c2);
+ }
+ if (c2.type === Text) {
+ c2.el = c1.el;
+ }
+ }
+ }
+}
+function getSequence(arr) {
+ const p = arr.slice();
+ const result = [0];
+ let i, j, u, v, c;
+ const len = arr.length;
+ for (i = 0; i < len; i++) {
+ const arrI = arr[i];
+ if (arrI !== 0) {
+ j = result[result.length - 1];
+ if (arr[j] < arrI) {
+ p[i] = j;
+ result.push(i);
+ continue;
+ }
+ u = 0;
+ v = result.length - 1;
+ while (u < v) {
+ c = u + v >> 1;
+ if (arr[result[c]] < arrI) {
+ u = c + 1;
+ } else {
+ v = c;
+ }
+ }
+ if (arrI < arr[result[u]]) {
+ if (u > 0) {
+ p[i] = result[u - 1];
+ }
+ result[u] = i;
+ }
+ }
+ }
+ u = result.length;
+ v = result[u - 1];
+ while (u-- > 0) {
+ result[u] = v;
+ v = p[v];
+ }
+ return result;
+}
+
+const isTeleport = (type) => type.__isTeleport;
+const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
+const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
+const resolveTarget = (props, select) => {
+ const targetSelector = props && props.to;
+ if (shared.isString(targetSelector)) {
+ if (!select) {
+ return null;
+ } else {
+ const target = select(targetSelector);
+ return target;
+ }
+ } else {
+ return targetSelector;
+ }
+};
+const TeleportImpl = {
+ name: "Teleport",
+ __isTeleport: true,
+ process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals) {
+ const {
+ mc: mountChildren,
+ pc: patchChildren,
+ pbc: patchBlockChildren,
+ o: { insert, querySelector, createText, createComment }
+ } = internals;
+ const disabled = isTeleportDisabled(n2.props);
+ let { shapeFlag, children, dynamicChildren } = n2;
+ if (n1 == null) {
+ const placeholder = n2.el = createText("");
+ const mainAnchor = n2.anchor = createText("");
+ insert(placeholder, container, anchor);
+ insert(mainAnchor, container, anchor);
+ const target = n2.target = resolveTarget(n2.props, querySelector);
+ const targetAnchor = n2.targetAnchor = createText("");
+ if (target) {
+ insert(targetAnchor, target);
+ isSVG = isSVG || isTargetSVG(target);
+ }
+ const mount = (container2, anchor2) => {
+ if (shapeFlag & 16) {
+ mountChildren(
+ children,
+ container2,
+ anchor2,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ if (disabled) {
+ mount(container, mainAnchor);
+ } else if (target) {
+ mount(target, targetAnchor);
+ }
+ } else {
+ n2.el = n1.el;
+ const mainAnchor = n2.anchor = n1.anchor;
+ const target = n2.target = n1.target;
+ const targetAnchor = n2.targetAnchor = n1.targetAnchor;
+ const wasDisabled = isTeleportDisabled(n1.props);
+ const currentContainer = wasDisabled ? container : target;
+ const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
+ isSVG = isSVG || isTargetSVG(target);
+ if (dynamicChildren) {
+ patchBlockChildren(
+ n1.dynamicChildren,
+ dynamicChildren,
+ currentContainer,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds
+ );
+ traverseStaticChildren(n1, n2, true);
+ } else if (!optimized) {
+ patchChildren(
+ n1,
+ n2,
+ currentContainer,
+ currentAnchor,
+ parentComponent,
+ parentSuspense,
+ isSVG,
+ slotScopeIds,
+ false
+ );
+ }
+ if (disabled) {
+ if (!wasDisabled) {
+ moveTeleport(
+ n2,
+ container,
+ mainAnchor,
+ internals,
+ 1
+ );
+ } else {
+ if (n2.props && n1.props && n2.props.to !== n1.props.to) {
+ n2.props.to = n1.props.to;
+ }
+ }
+ } else {
+ if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
+ const nextTarget = n2.target = resolveTarget(
+ n2.props,
+ querySelector
+ );
+ if (nextTarget) {
+ moveTeleport(
+ n2,
+ nextTarget,
+ null,
+ internals,
+ 0
+ );
+ }
+ } else if (wasDisabled) {
+ moveTeleport(
+ n2,
+ target,
+ targetAnchor,
+ internals,
+ 1
+ );
+ }
+ }
+ }
+ updateCssVars(n2);
+ },
+ remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {
+ const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;
+ if (target) {
+ hostRemove(targetAnchor);
+ }
+ doRemove && hostRemove(anchor);
+ if (shapeFlag & 16) {
+ const shouldRemove = doRemove || !isTeleportDisabled(props);
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ unmount(
+ child,
+ parentComponent,
+ parentSuspense,
+ shouldRemove,
+ !!child.dynamicChildren
+ );
+ }
+ }
+ },
+ move: moveTeleport,
+ hydrate: hydrateTeleport
+};
+function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
+ if (moveType === 0) {
+ insert(vnode.targetAnchor, container, parentAnchor);
+ }
+ const { el, anchor, shapeFlag, children, props } = vnode;
+ const isReorder = moveType === 2;
+ if (isReorder) {
+ insert(el, container, parentAnchor);
+ }
+ if (!isReorder || isTeleportDisabled(props)) {
+ if (shapeFlag & 16) {
+ for (let i = 0; i < children.length; i++) {
+ move(
+ children[i],
+ container,
+ parentAnchor,
+ 2
+ );
+ }
+ }
+ }
+ if (isReorder) {
+ insert(anchor, container, parentAnchor);
+ }
+}
+function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
+ o: { nextSibling, parentNode, querySelector }
+}, hydrateChildren) {
+ const target = vnode.target = resolveTarget(
+ vnode.props,
+ querySelector
+ );
+ if (target) {
+ const targetNode = target._lpa || target.firstChild;
+ if (vnode.shapeFlag & 16) {
+ if (isTeleportDisabled(vnode.props)) {
+ vnode.anchor = hydrateChildren(
+ nextSibling(node),
+ vnode,
+ parentNode(node),
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ vnode.targetAnchor = targetNode;
+ } else {
+ vnode.anchor = nextSibling(node);
+ let targetAnchor = targetNode;
+ while (targetAnchor) {
+ targetAnchor = nextSibling(targetAnchor);
+ if (targetAnchor && targetAnchor.nodeType === 8 && targetAnchor.data === "teleport anchor") {
+ vnode.targetAnchor = targetAnchor;
+ target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
+ break;
+ }
+ }
+ hydrateChildren(
+ targetNode,
+ vnode,
+ target,
+ parentComponent,
+ parentSuspense,
+ slotScopeIds,
+ optimized
+ );
+ }
+ }
+ updateCssVars(vnode);
+ }
+ return vnode.anchor && nextSibling(vnode.anchor);
+}
+const Teleport = TeleportImpl;
+function updateCssVars(vnode) {
+ const ctx = vnode.ctx;
+ if (ctx && ctx.ut) {
+ let node = vnode.children[0].el;
+ while (node && node !== vnode.targetAnchor) {
+ if (node.nodeType === 1)
+ node.setAttribute("data-v-owner", ctx.uid);
+ node = node.nextSibling;
+ }
+ ctx.ut();
+ }
+}
+
+const Fragment = Symbol.for("v-fgt");
+const Text = Symbol.for("v-txt");
+const Comment = Symbol.for("v-cmt");
+const Static = Symbol.for("v-stc");
+const blockStack = [];
+let currentBlock = null;
+function openBlock(disableTracking = false) {
+ blockStack.push(currentBlock = disableTracking ? null : []);
+}
+function closeBlock() {
+ blockStack.pop();
+ currentBlock = blockStack[blockStack.length - 1] || null;
+}
+let isBlockTreeEnabled = 1;
+function setBlockTracking(value) {
+ isBlockTreeEnabled += value;
+}
+function setupBlock(vnode) {
+ vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || shared.EMPTY_ARR : null;
+ closeBlock();
+ if (isBlockTreeEnabled > 0 && currentBlock) {
+ currentBlock.push(vnode);
+ }
+ return vnode;
+}
+function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
+ return setupBlock(
+ createBaseVNode(
+ type,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ shapeFlag,
+ true
+ /* isBlock */
+ )
+ );
+}
+function createBlock(type, props, children, patchFlag, dynamicProps) {
+ return setupBlock(
+ createVNode(
+ type,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ true
+ /* isBlock: prevent a block from tracking itself */
+ )
+ );
+}
+function isVNode(value) {
+ return value ? value.__v_isVNode === true : false;
+}
+function isSameVNodeType(n1, n2) {
+ return n1.type === n2.type && n1.key === n2.key;
+}
+function transformVNodeArgs(transformer) {
+}
+const InternalObjectKey = `__vInternal`;
+const normalizeKey = ({ key }) => key != null ? key : null;
+const normalizeRef = ({
+ ref,
+ ref_key,
+ ref_for
+}) => {
+ if (typeof ref === "number") {
+ ref = "" + ref;
+ }
+ return ref != null ? shared.isString(ref) || reactivity.isRef(ref) || shared.isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+};
+function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+ const vnode = {
+ __v_isVNode: true,
+ __v_skip: true,
+ type,
+ props,
+ key: props && normalizeKey(props),
+ ref: props && normalizeRef(props),
+ scopeId: currentScopeId,
+ slotScopeIds: null,
+ children,
+ component: null,
+ suspense: null,
+ ssContent: null,
+ ssFallback: null,
+ dirs: null,
+ transition: null,
+ el: null,
+ anchor: null,
+ target: null,
+ targetAnchor: null,
+ staticCount: 0,
+ shapeFlag,
+ patchFlag,
+ dynamicProps,
+ dynamicChildren: null,
+ appContext: null,
+ ctx: currentRenderingInstance
+ };
+ if (needFullChildrenNormalization) {
+ normalizeChildren(vnode, children);
+ if (shapeFlag & 128) {
+ type.normalize(vnode);
+ }
+ } else if (children) {
+ vnode.shapeFlag |= shared.isString(children) ? 8 : 16;
+ }
+ if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
+ !isBlockNode && // has current parent block
+ currentBlock && // presence of a patch flag indicates this node needs patching on updates.
+ // component nodes also should always be patched, because even if the
+ // component doesn't need to update, it needs to persist the instance on to
+ // the next vnode so that it can be properly unmounted later.
+ (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
+ // vnode should not be considered dynamic due to handler caching.
+ vnode.patchFlag !== 32) {
+ currentBlock.push(vnode);
+ }
+ return vnode;
+}
+const createVNode = _createVNode;
+function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+ if (!type || type === NULL_DYNAMIC_COMPONENT) {
+ type = Comment;
+ }
+ if (isVNode(type)) {
+ const cloned = cloneVNode(
+ type,
+ props,
+ true
+ /* mergeRef: true */
+ );
+ if (children) {
+ normalizeChildren(cloned, children);
+ }
+ if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
+ if (cloned.shapeFlag & 6) {
+ currentBlock[currentBlock.indexOf(type)] = cloned;
+ } else {
+ currentBlock.push(cloned);
+ }
+ }
+ cloned.patchFlag |= -2;
+ return cloned;
+ }
+ if (isClassComponent(type)) {
+ type = type.__vccOpts;
+ }
+ if (props) {
+ props = guardReactiveProps(props);
+ let { class: klass, style } = props;
+ if (klass && !shared.isString(klass)) {
+ props.class = shared.normalizeClass(klass);
+ }
+ if (shared.isObject(style)) {
+ if (reactivity.isProxy(style) && !shared.isArray(style)) {
+ style = shared.extend({}, style);
+ }
+ props.style = shared.normalizeStyle(style);
+ }
+ }
+ const shapeFlag = shared.isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : shared.isObject(type) ? 4 : shared.isFunction(type) ? 2 : 0;
+ return createBaseVNode(
+ type,
+ props,
+ children,
+ patchFlag,
+ dynamicProps,
+ shapeFlag,
+ isBlockNode,
+ true
+ );
+}
+function guardReactiveProps(props) {
+ if (!props)
+ return null;
+ return reactivity.isProxy(props) || InternalObjectKey in props ? shared.extend({}, props) : props;
+}
+function cloneVNode(vnode, extraProps, mergeRef = false) {
+ const { props, ref, patchFlag, children } = vnode;
+ const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+ const cloned = {
+ __v_isVNode: true,
+ __v_skip: true,
+ type: vnode.type,
+ props: mergedProps,
+ key: mergedProps && normalizeKey(mergedProps),
+ ref: extraProps && extraProps.ref ? (
+ // #2078 in the case of <component :is="vnode" ref="extra"/>
+ // if the vnode itself already has a ref, cloneVNode will need to merge
+ // the refs so the single vnode can be set on multiple refs
+ mergeRef && ref ? shared.isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
+ ) : ref,
+ scopeId: vnode.scopeId,
+ slotScopeIds: vnode.slotScopeIds,
+ children: children,
+ target: vnode.target,
+ targetAnchor: vnode.targetAnchor,
+ staticCount: vnode.staticCount,
+ shapeFlag: vnode.shapeFlag,
+ // if the vnode is cloned with extra props, we can no longer assume its
+ // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+ // note: preserve flag for fragments since they use the flag for children
+ // fast paths only.
+ patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+ dynamicProps: vnode.dynamicProps,
+ dynamicChildren: vnode.dynamicChildren,
+ appContext: vnode.appContext,
+ dirs: vnode.dirs,
+ transition: vnode.transition,
+ // These should technically only be non-null on mounted VNodes. However,
+ // they *should* be copied for kept-alive vnodes. So we just always copy
+ // them since them being non-null during a mount doesn't affect the logic as
+ // they will simply be overwritten.
+ component: vnode.component,
+ suspense: vnode.suspense,
+ ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+ ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+ el: vnode.el,
+ anchor: vnode.anchor,
+ ctx: vnode.ctx,
+ ce: vnode.ce
+ };
+ return cloned;
+}
+function createTextVNode(text = " ", flag = 0) {
+ return createVNode(Text, null, text, flag);
+}
+function createStaticVNode(content, numberOfNodes) {
+ const vnode = createVNode(Static, null, content);
+ vnode.staticCount = numberOfNodes;
+ return vnode;
+}
+function createCommentVNode(text = "", asBlock = false) {
+ return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
+}
+function normalizeVNode(child) {
+ if (child == null || typeof child === "boolean") {
+ return createVNode(Comment);
+ } else if (shared.isArray(child)) {
+ return createVNode(
+ Fragment,
+ null,
+ // #3666, avoid reference pollution when reusing vnode
+ child.slice()
+ );
+ } else if (typeof child === "object") {
+ return cloneIfMounted(child);
+ } else {
+ return createVNode(Text, null, String(child));
+ }
+}
+function cloneIfMounted(child) {
+ return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
+}
+function normalizeChildren(vnode, children) {
+ let type = 0;
+ const { shapeFlag } = vnode;
+ if (children == null) {
+ children = null;
+ } else if (shared.isArray(children)) {
+ type = 16;
+ } else if (typeof children === "object") {
+ if (shapeFlag & (1 | 64)) {
+ const slot = children.default;
+ if (slot) {
+ slot._c && (slot._d = false);
+ normalizeChildren(vnode, slot());
+ slot._c && (slot._d = true);
+ }
+ return;
+ } else {
+ type = 32;
+ const slotFlag = children._;
+ if (!slotFlag && !(InternalObjectKey in children)) {
+ children._ctx = currentRenderingInstance;
+ } else if (slotFlag === 3 && currentRenderingInstance) {
+ if (currentRenderingInstance.slots._ === 1) {
+ children._ = 1;
+ } else {
+ children._ = 2;
+ vnode.patchFlag |= 1024;
+ }
+ }
+ }
+ } else if (shared.isFunction(children)) {
+ children = { default: children, _ctx: currentRenderingInstance };
+ type = 32;
+ } else {
+ children = String(children);
+ if (shapeFlag & 64) {
+ type = 16;
+ children = [createTextVNode(children)];
+ } else {
+ type = 8;
+ }
+ }
+ vnode.children = children;
+ vnode.shapeFlag |= type;
+}
+function mergeProps(...args) {
+ const ret = {};
+ for (let i = 0; i < args.length; i++) {
+ const toMerge = args[i];
+ for (const key in toMerge) {
+ if (key === "class") {
+ if (ret.class !== toMerge.class) {
+ ret.class = shared.normalizeClass([ret.class, toMerge.class]);
+ }
+ } else if (key === "style") {
+ ret.style = shared.normalizeStyle([ret.style, toMerge.style]);
+ } else if (shared.isOn(key)) {
+ const existing = ret[key];
+ const incoming = toMerge[key];
+ if (incoming && existing !== incoming && !(shared.isArray(existing) && existing.includes(incoming))) {
+ ret[key] = existing ? [].concat(existing, incoming) : incoming;
+ }
+ } else if (key !== "") {
+ ret[key] = toMerge[key];
+ }
+ }
+ }
+ return ret;
+}
+function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
+ callWithAsyncErrorHandling(hook, instance, 7, [
+ vnode,
+ prevVNode
+ ]);
+}
+
+const emptyAppContext = createAppContext();
+let uid = 0;
+function createComponentInstance(vnode, parent, suspense) {
+ const type = vnode.type;
+ const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
+ const instance = {
+ uid: uid++,
+ vnode,
+ type,
+ parent,
+ appContext,
+ root: null,
+ // to be immediately set
+ next: null,
+ subTree: null,
+ // will be set synchronously right after creation
+ effect: null,
+ update: null,
+ // will be set synchronously right after creation
+ scope: new reactivity.EffectScope(
+ true
+ /* detached */
+ ),
+ render: null,
+ proxy: null,
+ exposed: null,
+ exposeProxy: null,
+ withProxy: null,
+ provides: parent ? parent.provides : Object.create(appContext.provides),
+ accessCache: null,
+ renderCache: [],
+ // local resolved assets
+ components: null,
+ directives: null,
+ // resolved props and emits options
+ propsOptions: normalizePropsOptions(type, appContext),
+ emitsOptions: normalizeEmitsOptions(type, appContext),
+ // emit
+ emit: null,
+ // to be set immediately
+ emitted: null,
+ // props default value
+ propsDefaults: shared.EMPTY_OBJ,
+ // inheritAttrs
+ inheritAttrs: type.inheritAttrs,
+ // state
+ ctx: shared.EMPTY_OBJ,
+ data: shared.EMPTY_OBJ,
+ props: shared.EMPTY_OBJ,
+ attrs: shared.EMPTY_OBJ,
+ slots: shared.EMPTY_OBJ,
+ refs: shared.EMPTY_OBJ,
+ setupState: shared.EMPTY_OBJ,
+ setupContext: null,
+ attrsProxy: null,
+ slotsProxy: null,
+ // suspense related
+ suspense,
+ suspenseId: suspense ? suspense.pendingId : 0,
+ asyncDep: null,
+ asyncResolved: false,
+ // lifecycle hooks
+ // not using enums here because it results in computed properties
+ isMounted: false,
+ isUnmounted: false,
+ isDeactivated: false,
+ bc: null,
+ c: null,
+ bm: null,
+ m: null,
+ bu: null,
+ u: null,
+ um: null,
+ bum: null,
+ da: null,
+ a: null,
+ rtg: null,
+ rtc: null,
+ ec: null,
+ sp: null
+ };
+ {
+ instance.ctx = { _: instance };
+ }
+ instance.root = parent ? parent.root : instance;
+ instance.emit = emit.bind(null, instance);
+ if (vnode.ce) {
+ vnode.ce(instance);
+ }
+ return instance;
+}
+let currentInstance = null;
+const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+let internalSetCurrentInstance;
+let globalCurrentInstanceSetters;
+let settersKey = "__VUE_INSTANCE_SETTERS__";
+{
+ if (!(globalCurrentInstanceSetters = shared.getGlobalThis()[settersKey])) {
+ globalCurrentInstanceSetters = shared.getGlobalThis()[settersKey] = [];
+ }
+ globalCurrentInstanceSetters.push((i) => currentInstance = i);
+ internalSetCurrentInstance = (instance) => {
+ if (globalCurrentInstanceSetters.length > 1) {
+ globalCurrentInstanceSetters.forEach((s) => s(instance));
+ } else {
+ globalCurrentInstanceSetters[0](instance);
+ }
+ };
+}
+const setCurrentInstance = (instance) => {
+ internalSetCurrentInstance(instance);
+ instance.scope.on();
+};
+const unsetCurrentInstance = () => {
+ currentInstance && currentInstance.scope.off();
+ internalSetCurrentInstance(null);
+};
+function isStatefulComponent(instance) {
+ return instance.vnode.shapeFlag & 4;
+}
+let isInSSRComponentSetup = false;
+function setupComponent(instance, isSSR = false) {
+ isInSSRComponentSetup = isSSR;
+ const { props, children } = instance.vnode;
+ const isStateful = isStatefulComponent(instance);
+ initProps(instance, props, isStateful, isSSR);
+ initSlots(instance, children);
+ const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
+ isInSSRComponentSetup = false;
+ return setupResult;
+}
+function setupStatefulComponent(instance, isSSR) {
+ const Component = instance.type;
+ instance.accessCache = /* @__PURE__ */ Object.create(null);
+ instance.proxy = reactivity.markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
+ const { setup } = Component;
+ if (setup) {
+ const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
+ setCurrentInstance(instance);
+ reactivity.pauseTracking();
+ const setupResult = callWithErrorHandling(
+ setup,
+ instance,
+ 0,
+ [instance.props, setupContext]
+ );
+ reactivity.resetTracking();
+ unsetCurrentInstance();
+ if (shared.isPromise(setupResult)) {
+ setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
+ if (isSSR) {
+ return setupResult.then((resolvedResult) => {
+ handleSetupResult(instance, resolvedResult, isSSR);
+ }).catch((e) => {
+ handleError(e, instance, 0);
+ });
+ } else {
+ instance.asyncDep = setupResult;
+ }
+ } else {
+ handleSetupResult(instance, setupResult, isSSR);
+ }
+ } else {
+ finishComponentSetup(instance, isSSR);
+ }
+}
+function handleSetupResult(instance, setupResult, isSSR) {
+ if (shared.isFunction(setupResult)) {
+ if (instance.type.__ssrInlineRender) {
+ instance.ssrRender = setupResult;
+ } else {
+ instance.render = setupResult;
+ }
+ } else if (shared.isObject(setupResult)) {
+ instance.setupState = reactivity.proxyRefs(setupResult);
+ } else ;
+ finishComponentSetup(instance, isSSR);
+}
+let compile;
+let installWithProxy;
+function registerRuntimeCompiler(_compile) {
+ compile = _compile;
+ installWithProxy = (i) => {
+ if (i.render._rc) {
+ i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
+ }
+ };
+}
+const isRuntimeOnly = () => !compile;
+function finishComponentSetup(instance, isSSR, skipOptions) {
+ const Component = instance.type;
+ if (!instance.render) {
+ if (!isSSR && compile && !Component.render) {
+ const template = Component.template || resolveMergedOptions(instance).template;
+ if (template) {
+ const { isCustomElement, compilerOptions } = instance.appContext.config;
+ const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+ const finalCompilerOptions = shared.extend(
+ shared.extend(
+ {
+ isCustomElement,
+ delimiters
+ },
+ compilerOptions
+ ),
+ componentCompilerOptions
+ );
+ Component.render = compile(template, finalCompilerOptions);
+ }
+ }
+ instance.render = Component.render || shared.NOOP;
+ if (installWithProxy) {
+ installWithProxy(instance);
+ }
+ }
+ {
+ setCurrentInstance(instance);
+ reactivity.pauseTracking();
+ try {
+ applyOptions(instance);
+ } finally {
+ reactivity.resetTracking();
+ unsetCurrentInstance();
+ }
+ }
+}
+function getAttrsProxy(instance) {
+ return instance.attrsProxy || (instance.attrsProxy = new Proxy(
+ instance.attrs,
+ {
+ get(target, key) {
+ reactivity.track(instance, "get", "$attrs");
+ return target[key];
+ }
+ }
+ ));
+}
+function createSetupContext(instance) {
+ const expose = (exposed) => {
+ instance.exposed = exposed || {};
+ };
+ {
+ return {
+ get attrs() {
+ return getAttrsProxy(instance);
+ },
+ slots: instance.slots,
+ emit: instance.emit,
+ expose
+ };
+ }
+}
+function getExposeProxy(instance) {
+ if (instance.exposed) {
+ return instance.exposeProxy || (instance.exposeProxy = new Proxy(reactivity.proxyRefs(reactivity.markRaw(instance.exposed)), {
+ get(target, key) {
+ if (key in target) {
+ return target[key];
+ } else if (key in publicPropertiesMap) {
+ return publicPropertiesMap[key](instance);
+ }
+ },
+ has(target, key) {
+ return key in target || key in publicPropertiesMap;
+ }
+ }));
+ }
+}
+function getComponentName(Component, includeInferred = true) {
+ return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function isClassComponent(value) {
+ return shared.isFunction(value) && "__vccOpts" in value;
+}
+
+const computed = (getterOrOptions, debugOptions) => {
+ return reactivity.computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
+};
+
+function h(type, propsOrChildren, children) {
+ const l = arguments.length;
+ if (l === 2) {
+ if (shared.isObject(propsOrChildren) && !shared.isArray(propsOrChildren)) {
+ if (isVNode(propsOrChildren)) {
+ return createVNode(type, null, [propsOrChildren]);
+ }
+ return createVNode(type, propsOrChildren);
+ } else {
+ return createVNode(type, null, propsOrChildren);
+ }
+ } else {
+ if (l > 3) {
+ children = Array.prototype.slice.call(arguments, 2);
+ } else if (l === 3 && isVNode(children)) {
+ children = [children];
+ }
+ return createVNode(type, propsOrChildren, children);
+ }
+}
+
+const ssrContextKey = Symbol.for("v-scx");
+const useSSRContext = () => {
+ {
+ const ctx = inject(ssrContextKey);
+ return ctx;
+ }
+};
+
+function initCustomFormatter() {
+ {
+ return;
+ }
+}
+
+function withMemo(memo, render, cache, index) {
+ const cached = cache[index];
+ if (cached && isMemoSame(cached, memo)) {
+ return cached;
+ }
+ const ret = render();
+ ret.memo = memo.slice();
+ return cache[index] = ret;
+}
+function isMemoSame(cached, memo) {
+ const prev = cached.memo;
+ if (prev.length != memo.length) {
+ return false;
+ }
+ for (let i = 0; i < prev.length; i++) {
+ if (shared.hasChanged(prev[i], memo[i])) {
+ return false;
+ }
+ }
+ if (isBlockTreeEnabled > 0 && currentBlock) {
+ currentBlock.push(cached);
+ }
+ return true;
+}
+
+const version = "3.3.9";
+const _ssrUtils = {
+ createComponentInstance,
+ setupComponent,
+ renderComponentRoot,
+ setCurrentRenderingInstance,
+ isVNode: isVNode,
+ normalizeVNode
+};
+const ssrUtils = _ssrUtils ;
+const resolveFilter = null;
+const compatUtils = null;
+
+exports.EffectScope = reactivity.EffectScope;
+exports.ReactiveEffect = reactivity.ReactiveEffect;
+exports.customRef = reactivity.customRef;
+exports.effect = reactivity.effect;
+exports.effectScope = reactivity.effectScope;
+exports.getCurrentScope = reactivity.getCurrentScope;
+exports.isProxy = reactivity.isProxy;
+exports.isReactive = reactivity.isReactive;
+exports.isReadonly = reactivity.isReadonly;
+exports.isRef = reactivity.isRef;
+exports.isShallow = reactivity.isShallow;
+exports.markRaw = reactivity.markRaw;
+exports.onScopeDispose = reactivity.onScopeDispose;
+exports.proxyRefs = reactivity.proxyRefs;
+exports.reactive = reactivity.reactive;
+exports.readonly = reactivity.readonly;
+exports.ref = reactivity.ref;
+exports.shallowReactive = reactivity.shallowReactive;
+exports.shallowReadonly = reactivity.shallowReadonly;
+exports.shallowRef = reactivity.shallowRef;
+exports.stop = reactivity.stop;
+exports.toRaw = reactivity.toRaw;
+exports.toRef = reactivity.toRef;
+exports.toRefs = reactivity.toRefs;
+exports.toValue = reactivity.toValue;
+exports.triggerRef = reactivity.triggerRef;
+exports.unref = reactivity.unref;
+exports.camelize = shared.camelize;
+exports.capitalize = shared.capitalize;
+exports.normalizeClass = shared.normalizeClass;
+exports.normalizeProps = shared.normalizeProps;
+exports.normalizeStyle = shared.normalizeStyle;
+exports.toDisplayString = shared.toDisplayString;
+exports.toHandlerKey = shared.toHandlerKey;
+exports.BaseTransition = BaseTransition;
+exports.BaseTransitionPropsValidators = BaseTransitionPropsValidators;
+exports.Comment = Comment;
+exports.Fragment = Fragment;
+exports.KeepAlive = KeepAlive;
+exports.Static = Static;
+exports.Suspense = Suspense;
+exports.Teleport = Teleport;
+exports.Text = Text;
+exports.assertNumber = assertNumber;
+exports.callWithAsyncErrorHandling = callWithAsyncErrorHandling;
+exports.callWithErrorHandling = callWithErrorHandling;
+exports.cloneVNode = cloneVNode;
+exports.compatUtils = compatUtils;
+exports.computed = computed;
+exports.createBlock = createBlock;
+exports.createCommentVNode = createCommentVNode;
+exports.createElementBlock = createElementBlock;
+exports.createElementVNode = createBaseVNode;
+exports.createHydrationRenderer = createHydrationRenderer;
+exports.createPropsRestProxy = createPropsRestProxy;
+exports.createRenderer = createRenderer;
+exports.createSlots = createSlots;
+exports.createStaticVNode = createStaticVNode;
+exports.createTextVNode = createTextVNode;
+exports.createVNode = createVNode;
+exports.defineAsyncComponent = defineAsyncComponent;
+exports.defineComponent = defineComponent;
+exports.defineEmits = defineEmits;
+exports.defineExpose = defineExpose;
+exports.defineModel = defineModel;
+exports.defineOptions = defineOptions;
+exports.defineProps = defineProps;
+exports.defineSlots = defineSlots;
+exports.getCurrentInstance = getCurrentInstance;
+exports.getTransitionRawChildren = getTransitionRawChildren;
+exports.guardReactiveProps = guardReactiveProps;
+exports.h = h;
+exports.handleError = handleError;
+exports.hasInjectionContext = hasInjectionContext;
+exports.initCustomFormatter = initCustomFormatter;
+exports.inject = inject;
+exports.isMemoSame = isMemoSame;
+exports.isRuntimeOnly = isRuntimeOnly;
+exports.isVNode = isVNode;
+exports.mergeDefaults = mergeDefaults;
+exports.mergeModels = mergeModels;
+exports.mergeProps = mergeProps;
+exports.nextTick = nextTick;
+exports.onActivated = onActivated;
+exports.onBeforeMount = onBeforeMount;
+exports.onBeforeUnmount = onBeforeUnmount;
+exports.onBeforeUpdate = onBeforeUpdate;
+exports.onDeactivated = onDeactivated;
+exports.onErrorCaptured = onErrorCaptured;
+exports.onMounted = onMounted;
+exports.onRenderTracked = onRenderTracked;
+exports.onRenderTriggered = onRenderTriggered;
+exports.onServerPrefetch = onServerPrefetch;
+exports.onUnmounted = onUnmounted;
+exports.onUpdated = onUpdated;
+exports.openBlock = openBlock;
+exports.popScopeId = popScopeId;
+exports.provide = provide;
+exports.pushScopeId = pushScopeId;
+exports.queuePostFlushCb = queuePostFlushCb;
+exports.registerRuntimeCompiler = registerRuntimeCompiler;
+exports.renderList = renderList;
+exports.renderSlot = renderSlot;
+exports.resolveComponent = resolveComponent;
+exports.resolveDirective = resolveDirective;
+exports.resolveDynamicComponent = resolveDynamicComponent;
+exports.resolveFilter = resolveFilter;
+exports.resolveTransitionHooks = resolveTransitionHooks;
+exports.setBlockTracking = setBlockTracking;
+exports.setDevtoolsHook = setDevtoolsHook;
+exports.setTransitionHooks = setTransitionHooks;
+exports.ssrContextKey = ssrContextKey;
+exports.ssrUtils = ssrUtils;
+exports.toHandlers = toHandlers;
+exports.transformVNodeArgs = transformVNodeArgs;
+exports.useAttrs = useAttrs;
+exports.useModel = useModel;
+exports.useSSRContext = useSSRContext;
+exports.useSlots = useSlots;
+exports.useTransitionState = useTransitionState;
+exports.version = version;
+exports.warn = warn$1;
+exports.watch = watch;
+exports.watchEffect = watchEffect;
+exports.watchPostEffect = watchPostEffect;
+exports.watchSyncEffect = watchSyncEffect;
+exports.withAsyncContext = withAsyncContext;
+exports.withCtx = withCtx;
+exports.withDefaults = withDefaults;
+exports.withDirectives = withDirectives;
+exports.withMemo = withMemo;
+exports.withScopeId = withScopeId;
diff --git a/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.js b/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.js
new file mode 100644
index 0000000..cde7331
--- /dev/null
+++ b/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.js
@@ -0,0 +1,1503 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtimeCore = require('@vue/runtime-core');
+var shared = require('@vue/shared');
+
+const svgNS = "http://www.w3.org/2000/svg";
+const doc = typeof document !== "undefined" ? document : null;
+const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
+const nodeOps = {
+ insert: (child, parent, anchor) => {
+ parent.insertBefore(child, anchor || null);
+ },
+ remove: (child) => {
+ const parent = child.parentNode;
+ if (parent) {
+ parent.removeChild(child);
+ }
+ },
+ createElement: (tag, isSVG, is, props) => {
+ const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);
+ if (tag === "select" && props && props.multiple != null) {
+ el.setAttribute("multiple", props.multiple);
+ }
+ return el;
+ },
+ createText: (text) => doc.createTextNode(text),
+ createComment: (text) => doc.createComment(text),
+ setText: (node, text) => {
+ node.nodeValue = text;
+ },
+ setElementText: (el, text) => {
+ el.textContent = text;
+ },
+ parentNode: (node) => node.parentNode,
+ nextSibling: (node) => node.nextSibling,
+ querySelector: (selector) => doc.querySelector(selector),
+ setScopeId(el, id) {
+ el.setAttribute(id, "");
+ },
+ // __UNSAFE__
+ // Reason: innerHTML.
+ // Static content here can only come from compiled templates.
+ // As long as the user only uses trusted templates, this is safe.
+ insertStaticContent(content, parent, anchor, isSVG, start, end) {
+ const before = anchor ? anchor.previousSibling : parent.lastChild;
+ if (start && (start === end || start.nextSibling)) {
+ while (true) {
+ parent.insertBefore(start.cloneNode(true), anchor);
+ if (start === end || !(start = start.nextSibling))
+ break;
+ }
+ } else {
+ templateContainer.innerHTML = isSVG ? `<svg>${content}</svg>` : content;
+ const template = templateContainer.content;
+ if (isSVG) {
+ const wrapper = template.firstChild;
+ while (wrapper.firstChild) {
+ template.appendChild(wrapper.firstChild);
+ }
+ template.removeChild(wrapper);
+ }
+ parent.insertBefore(template, anchor);
+ }
+ return [
+ // first
+ before ? before.nextSibling : parent.firstChild,
+ // last
+ anchor ? anchor.previousSibling : parent.lastChild
+ ];
+ }
+};
+
+const TRANSITION = "transition";
+const ANIMATION = "animation";
+const vtcKey = Symbol("_vtc");
+const Transition = (props, { slots }) => runtimeCore.h(runtimeCore.BaseTransition, resolveTransitionProps(props), slots);
+Transition.displayName = "Transition";
+const DOMTransitionPropsValidators = {
+ name: String,
+ type: String,
+ css: {
+ type: Boolean,
+ default: true
+ },
+ duration: [String, Number, Object],
+ enterFromClass: String,
+ enterActiveClass: String,
+ enterToClass: String,
+ appearFromClass: String,
+ appearActiveClass: String,
+ appearToClass: String,
+ leaveFromClass: String,
+ leaveActiveClass: String,
+ leaveToClass: String
+};
+const TransitionPropsValidators = Transition.props = /* @__PURE__ */ shared.extend(
+ {},
+ runtimeCore.BaseTransitionPropsValidators,
+ DOMTransitionPropsValidators
+);
+const callHook = (hook, args = []) => {
+ if (shared.isArray(hook)) {
+ hook.forEach((h2) => h2(...args));
+ } else if (hook) {
+ hook(...args);
+ }
+};
+const hasExplicitCallback = (hook) => {
+ return hook ? shared.isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+};
+function resolveTransitionProps(rawProps) {
+ const baseProps = {};
+ for (const key in rawProps) {
+ if (!(key in DOMTransitionPropsValidators)) {
+ baseProps[key] = rawProps[key];
+ }
+ }
+ if (rawProps.css === false) {
+ return baseProps;
+ }
+ const {
+ name = "v",
+ type,
+ duration,
+ enterFromClass = `${name}-enter-from`,
+ enterActiveClass = `${name}-enter-active`,
+ enterToClass = `${name}-enter-to`,
+ appearFromClass = enterFromClass,
+ appearActiveClass = enterActiveClass,
+ appearToClass = enterToClass,
+ leaveFromClass = `${name}-leave-from`,
+ leaveActiveClass = `${name}-leave-active`,
+ leaveToClass = `${name}-leave-to`
+ } = rawProps;
+ const durations = normalizeDuration(duration);
+ const enterDuration = durations && durations[0];
+ const leaveDuration = durations && durations[1];
+ const {
+ onBeforeEnter,
+ onEnter,
+ onEnterCancelled,
+ onLeave,
+ onLeaveCancelled,
+ onBeforeAppear = onBeforeEnter,
+ onAppear = onEnter,
+ onAppearCancelled = onEnterCancelled
+ } = baseProps;
+ const finishEnter = (el, isAppear, done) => {
+ removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
+ removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
+ done && done();
+ };
+ const finishLeave = (el, done) => {
+ el._isLeaving = false;
+ removeTransitionClass(el, leaveFromClass);
+ removeTransitionClass(el, leaveToClass);
+ removeTransitionClass(el, leaveActiveClass);
+ done && done();
+ };
+ const makeEnterHook = (isAppear) => {
+ return (el, done) => {
+ const hook = isAppear ? onAppear : onEnter;
+ const resolve = () => finishEnter(el, isAppear, done);
+ callHook(hook, [el, resolve]);
+ nextFrame(() => {
+ removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
+ addTransitionClass(el, isAppear ? appearToClass : enterToClass);
+ if (!hasExplicitCallback(hook)) {
+ whenTransitionEnds(el, type, enterDuration, resolve);
+ }
+ });
+ };
+ };
+ return shared.extend(baseProps, {
+ onBeforeEnter(el) {
+ callHook(onBeforeEnter, [el]);
+ addTransitionClass(el, enterFromClass);
+ addTransitionClass(el, enterActiveClass);
+ },
+ onBeforeAppear(el) {
+ callHook(onBeforeAppear, [el]);
+ addTransitionClass(el, appearFromClass);
+ addTransitionClass(el, appearActiveClass);
+ },
+ onEnter: makeEnterHook(false),
+ onAppear: makeEnterHook(true),
+ onLeave(el, done) {
+ el._isLeaving = true;
+ const resolve = () => finishLeave(el, done);
+ addTransitionClass(el, leaveFromClass);
+ forceReflow();
+ addTransitionClass(el, leaveActiveClass);
+ nextFrame(() => {
+ if (!el._isLeaving) {
+ return;
+ }
+ removeTransitionClass(el, leaveFromClass);
+ addTransitionClass(el, leaveToClass);
+ if (!hasExplicitCallback(onLeave)) {
+ whenTransitionEnds(el, type, leaveDuration, resolve);
+ }
+ });
+ callHook(onLeave, [el, resolve]);
+ },
+ onEnterCancelled(el) {
+ finishEnter(el, false);
+ callHook(onEnterCancelled, [el]);
+ },
+ onAppearCancelled(el) {
+ finishEnter(el, true);
+ callHook(onAppearCancelled, [el]);
+ },
+ onLeaveCancelled(el) {
+ finishLeave(el);
+ callHook(onLeaveCancelled, [el]);
+ }
+ });
+}
+function normalizeDuration(duration) {
+ if (duration == null) {
+ return null;
+ } else if (shared.isObject(duration)) {
+ return [NumberOf(duration.enter), NumberOf(duration.leave)];
+ } else {
+ const n = NumberOf(duration);
+ return [n, n];
+ }
+}
+function NumberOf(val) {
+ const res = shared.toNumber(val);
+ {
+ runtimeCore.assertNumber(res, "<transition> explicit duration");
+ }
+ return res;
+}
+function addTransitionClass(el, cls) {
+ cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
+ (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
+}
+function removeTransitionClass(el, cls) {
+ cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
+ const _vtc = el[vtcKey];
+ if (_vtc) {
+ _vtc.delete(cls);
+ if (!_vtc.size) {
+ el[vtcKey] = void 0;
+ }
+ }
+}
+function nextFrame(cb) {
+ requestAnimationFrame(() => {
+ requestAnimationFrame(cb);
+ });
+}
+let endId = 0;
+function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
+ const id = el._endId = ++endId;
+ const resolveIfNotStale = () => {
+ if (id === el._endId) {
+ resolve();
+ }
+ };
+ if (explicitTimeout) {
+ return setTimeout(resolveIfNotStale, explicitTimeout);
+ }
+ const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+ if (!type) {
+ return resolve();
+ }
+ const endEvent = type + "end";
+ let ended = 0;
+ const end = () => {
+ el.removeEventListener(endEvent, onEnd);
+ resolveIfNotStale();
+ };
+ const onEnd = (e) => {
+ if (e.target === el && ++ended >= propCount) {
+ end();
+ }
+ };
+ setTimeout(() => {
+ if (ended < propCount) {
+ end();
+ }
+ }, timeout + 1);
+ el.addEventListener(endEvent, onEnd);
+}
+function getTransitionInfo(el, expectedType) {
+ const styles = window.getComputedStyle(el);
+ const getStyleProperties = (key) => (styles[key] || "").split(", ");
+ const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
+ const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
+ const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+ const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
+ const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
+ const animationTimeout = getTimeout(animationDelays, animationDurations);
+ let type = null;
+ let timeout = 0;
+ let propCount = 0;
+ if (expectedType === TRANSITION) {
+ if (transitionTimeout > 0) {
+ type = TRANSITION;
+ timeout = transitionTimeout;
+ propCount = transitionDurations.length;
+ }
+ } else if (expectedType === ANIMATION) {
+ if (animationTimeout > 0) {
+ type = ANIMATION;
+ timeout = animationTimeout;
+ propCount = animationDurations.length;
+ }
+ } else {
+ timeout = Math.max(transitionTimeout, animationTimeout);
+ type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
+ propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
+ }
+ const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
+ getStyleProperties(`${TRANSITION}Property`).toString()
+ );
+ return {
+ type,
+ timeout,
+ propCount,
+ hasTransform
+ };
+}
+function getTimeout(delays, durations) {
+ while (delays.length < durations.length) {
+ delays = delays.concat(delays);
+ }
+ return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
+}
+function toMs(s) {
+ if (s === "auto")
+ return 0;
+ return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+}
+function forceReflow() {
+ return document.body.offsetHeight;
+}
+
+function patchClass(el, value, isSVG) {
+ const transitionClasses = el[vtcKey];
+ if (transitionClasses) {
+ value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
+ }
+ if (value == null) {
+ el.removeAttribute("class");
+ } else if (isSVG) {
+ el.setAttribute("class", value);
+ } else {
+ el.className = value;
+ }
+}
+
+const vShowOldKey = Symbol("_vod");
+const vShow = {
+ beforeMount(el, { value }, { transition }) {
+ el[vShowOldKey] = el.style.display === "none" ? "" : el.style.display;
+ if (transition && value) {
+ transition.beforeEnter(el);
+ } else {
+ setDisplay(el, value);
+ }
+ },
+ mounted(el, { value }, { transition }) {
+ if (transition && value) {
+ transition.enter(el);
+ }
+ },
+ updated(el, { value, oldValue }, { transition }) {
+ if (!value === !oldValue)
+ return;
+ if (transition) {
+ if (value) {
+ transition.beforeEnter(el);
+ setDisplay(el, true);
+ transition.enter(el);
+ } else {
+ transition.leave(el, () => {
+ setDisplay(el, false);
+ });
+ }
+ } else {
+ setDisplay(el, value);
+ }
+ },
+ beforeUnmount(el, { value }) {
+ setDisplay(el, value);
+ }
+};
+function setDisplay(el, value) {
+ el.style.display = value ? el[vShowOldKey] : "none";
+}
+function initVShowForSSR() {
+ vShow.getSSRProps = ({ value }) => {
+ if (!value) {
+ return { style: { display: "none" } };
+ }
+ };
+}
+
+function patchStyle(el, prev, next) {
+ const style = el.style;
+ const isCssString = shared.isString(next);
+ if (next && !isCssString) {
+ if (prev && !shared.isString(prev)) {
+ for (const key in prev) {
+ if (next[key] == null) {
+ setStyle(style, key, "");
+ }
+ }
+ }
+ for (const key in next) {
+ setStyle(style, key, next[key]);
+ }
+ } else {
+ const currentDisplay = style.display;
+ if (isCssString) {
+ if (prev !== next) {
+ style.cssText = next;
+ }
+ } else if (prev) {
+ el.removeAttribute("style");
+ }
+ if (vShowOldKey in el) {
+ style.display = currentDisplay;
+ }
+ }
+}
+const semicolonRE = /[^\\];\s*$/;
+const importantRE = /\s*!important$/;
+function setStyle(style, name, val) {
+ if (shared.isArray(val)) {
+ val.forEach((v) => setStyle(style, name, v));
+ } else {
+ if (val == null)
+ val = "";
+ {
+ if (semicolonRE.test(val)) {
+ runtimeCore.warn(
+ `Unexpected semicolon at the end of '${name}' style value: '${val}'`
+ );
+ }
+ }
+ if (name.startsWith("--")) {
+ style.setProperty(name, val);
+ } else {
+ const prefixed = autoPrefix(style, name);
+ if (importantRE.test(val)) {
+ style.setProperty(
+ shared.hyphenate(prefixed),
+ val.replace(importantRE, ""),
+ "important"
+ );
+ } else {
+ style[prefixed] = val;
+ }
+ }
+ }
+}
+const prefixes = ["Webkit", "Moz", "ms"];
+const prefixCache = {};
+function autoPrefix(style, rawName) {
+ const cached = prefixCache[rawName];
+ if (cached) {
+ return cached;
+ }
+ let name = runtimeCore.camelize(rawName);
+ if (name !== "filter" && name in style) {
+ return prefixCache[rawName] = name;
+ }
+ name = shared.capitalize(name);
+ for (let i = 0; i < prefixes.length; i++) {
+ const prefixed = prefixes[i] + name;
+ if (prefixed in style) {
+ return prefixCache[rawName] = prefixed;
+ }
+ }
+ return rawName;
+}
+
+const xlinkNS = "http://www.w3.org/1999/xlink";
+function patchAttr(el, key, value, isSVG, instance) {
+ if (isSVG && key.startsWith("xlink:")) {
+ if (value == null) {
+ el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
+ } else {
+ el.setAttributeNS(xlinkNS, key, value);
+ }
+ } else {
+ const isBoolean = shared.isSpecialBooleanAttr(key);
+ if (value == null || isBoolean && !shared.includeBooleanAttr(value)) {
+ el.removeAttribute(key);
+ } else {
+ el.setAttribute(key, isBoolean ? "" : value);
+ }
+ }
+}
+
+function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) {
+ if (key === "innerHTML" || key === "textContent") {
+ if (prevChildren) {
+ unmountChildren(prevChildren, parentComponent, parentSuspense);
+ }
+ el[key] = value == null ? "" : value;
+ return;
+ }
+ const tag = el.tagName;
+ if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
+ !tag.includes("-")) {
+ el._value = value;
+ const oldValue = tag === "OPTION" ? el.getAttribute("value") : el.value;
+ const newValue = value == null ? "" : value;
+ if (oldValue !== newValue) {
+ el.value = newValue;
+ }
+ if (value == null) {
+ el.removeAttribute(key);
+ }
+ return;
+ }
+ let needRemove = false;
+ if (value === "" || value == null) {
+ const type = typeof el[key];
+ if (type === "boolean") {
+ value = shared.includeBooleanAttr(value);
+ } else if (value == null && type === "string") {
+ value = "";
+ needRemove = true;
+ } else if (type === "number") {
+ value = 0;
+ needRemove = true;
+ }
+ }
+ try {
+ el[key] = value;
+ } catch (e) {
+ if (!needRemove) {
+ runtimeCore.warn(
+ `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`,
+ e
+ );
+ }
+ }
+ needRemove && el.removeAttribute(key);
+}
+
+function addEventListener(el, event, handler, options) {
+ el.addEventListener(event, handler, options);
+}
+function removeEventListener(el, event, handler, options) {
+ el.removeEventListener(event, handler, options);
+}
+const veiKey = Symbol("_vei");
+function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
+ const invokers = el[veiKey] || (el[veiKey] = {});
+ const existingInvoker = invokers[rawName];
+ if (nextValue && existingInvoker) {
+ existingInvoker.value = nextValue;
+ } else {
+ const [name, options] = parseName(rawName);
+ if (nextValue) {
+ const invoker = invokers[rawName] = createInvoker(nextValue, instance);
+ addEventListener(el, name, invoker, options);
+ } else if (existingInvoker) {
+ removeEventListener(el, name, existingInvoker, options);
+ invokers[rawName] = void 0;
+ }
+ }
+}
+const optionsModifierRE = /(?:Once|Passive|Capture)$/;
+function parseName(name) {
+ let options;
+ if (optionsModifierRE.test(name)) {
+ options = {};
+ let m;
+ while (m = name.match(optionsModifierRE)) {
+ name = name.slice(0, name.length - m[0].length);
+ options[m[0].toLowerCase()] = true;
+ }
+ }
+ const event = name[2] === ":" ? name.slice(3) : shared.hyphenate(name.slice(2));
+ return [event, options];
+}
+let cachedNow = 0;
+const p = /* @__PURE__ */ Promise.resolve();
+const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
+function createInvoker(initialValue, instance) {
+ const invoker = (e) => {
+ if (!e._vts) {
+ e._vts = Date.now();
+ } else if (e._vts <= invoker.attached) {
+ return;
+ }
+ runtimeCore.callWithAsyncErrorHandling(
+ patchStopImmediatePropagation(e, invoker.value),
+ instance,
+ 5,
+ [e]
+ );
+ };
+ invoker.value = initialValue;
+ invoker.attached = getNow();
+ return invoker;
+}
+function patchStopImmediatePropagation(e, value) {
+ if (shared.isArray(value)) {
+ const originalStop = e.stopImmediatePropagation;
+ e.stopImmediatePropagation = () => {
+ originalStop.call(e);
+ e._stopped = true;
+ };
+ return value.map((fn) => (e2) => !e2._stopped && fn && fn(e2));
+ } else {
+ return value;
+ }
+}
+
+const nativeOnRE = /^on[a-z]/;
+const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
+ if (key === "class") {
+ patchClass(el, nextValue, isSVG);
+ } else if (key === "style") {
+ patchStyle(el, prevValue, nextValue);
+ } else if (shared.isOn(key)) {
+ if (!shared.isModelListener(key)) {
+ patchEvent(el, key, prevValue, nextValue, parentComponent);
+ }
+ } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
+ patchDOMProp(
+ el,
+ key,
+ nextValue,
+ prevChildren,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ } else {
+ if (key === "true-value") {
+ el._trueValue = nextValue;
+ } else if (key === "false-value") {
+ el._falseValue = nextValue;
+ }
+ patchAttr(el, key, nextValue, isSVG);
+ }
+};
+function shouldSetAsProp(el, key, value, isSVG) {
+ if (isSVG) {
+ if (key === "innerHTML" || key === "textContent") {
+ return true;
+ }
+ if (key in el && nativeOnRE.test(key) && shared.isFunction(value)) {
+ return true;
+ }
+ return false;
+ }
+ if (key === "spellcheck" || key === "draggable" || key === "translate") {
+ return false;
+ }
+ if (key === "form") {
+ return false;
+ }
+ if (key === "list" && el.tagName === "INPUT") {
+ return false;
+ }
+ if (key === "type" && el.tagName === "TEXTAREA") {
+ return false;
+ }
+ if (nativeOnRE.test(key) && shared.isString(value)) {
+ return false;
+ }
+ return key in el;
+}
+
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineCustomElement(options, hydrate2) {
+ const Comp = runtimeCore.defineComponent(options);
+ class VueCustomElement extends VueElement {
+ constructor(initialProps) {
+ super(Comp, initialProps, hydrate2);
+ }
+ }
+ VueCustomElement.def = Comp;
+ return VueCustomElement;
+}
+/*! #__NO_SIDE_EFFECTS__ */
+const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options) => {
+ return /* @__PURE__ */ defineCustomElement(options, hydrate);
+};
+const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
+};
+class VueElement extends BaseClass {
+ constructor(_def, _props = {}, hydrate2) {
+ super();
+ this._def = _def;
+ this._props = _props;
+ /**
+ * @internal
+ */
+ this._instance = null;
+ this._connected = false;
+ this._resolved = false;
+ this._numberProps = null;
+ this._ob = null;
+ if (this.shadowRoot && hydrate2) {
+ hydrate2(this._createVNode(), this.shadowRoot);
+ } else {
+ if (this.shadowRoot) {
+ runtimeCore.warn(
+ `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
+ );
+ }
+ this.attachShadow({ mode: "open" });
+ if (!this._def.__asyncLoader) {
+ this._resolveProps(this._def);
+ }
+ }
+ }
+ connectedCallback() {
+ this._connected = true;
+ if (!this._instance) {
+ if (this._resolved) {
+ this._update();
+ } else {
+ this._resolveDef();
+ }
+ }
+ }
+ disconnectedCallback() {
+ this._connected = false;
+ if (this._ob) {
+ this._ob.disconnect();
+ this._ob = null;
+ }
+ runtimeCore.nextTick(() => {
+ if (!this._connected) {
+ render(null, this.shadowRoot);
+ this._instance = null;
+ }
+ });
+ }
+ /**
+ * resolve inner component definition (handle possible async component)
+ */
+ _resolveDef() {
+ this._resolved = true;
+ for (let i = 0; i < this.attributes.length; i++) {
+ this._setAttr(this.attributes[i].name);
+ }
+ this._ob = new MutationObserver((mutations) => {
+ for (const m of mutations) {
+ this._setAttr(m.attributeName);
+ }
+ });
+ this._ob.observe(this, { attributes: true });
+ const resolve = (def, isAsync = false) => {
+ const { props, styles } = def;
+ let numberProps;
+ if (props && !shared.isArray(props)) {
+ for (const key in props) {
+ const opt = props[key];
+ if (opt === Number || opt && opt.type === Number) {
+ if (key in this._props) {
+ this._props[key] = shared.toNumber(this._props[key]);
+ }
+ (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[shared.camelize(key)] = true;
+ }
+ }
+ }
+ this._numberProps = numberProps;
+ if (isAsync) {
+ this._resolveProps(def);
+ }
+ this._applyStyles(styles);
+ this._update();
+ };
+ const asyncDef = this._def.__asyncLoader;
+ if (asyncDef) {
+ asyncDef().then((def) => resolve(def, true));
+ } else {
+ resolve(this._def);
+ }
+ }
+ _resolveProps(def) {
+ const { props } = def;
+ const declaredPropKeys = shared.isArray(props) ? props : Object.keys(props || {});
+ for (const key of Object.keys(this)) {
+ if (key[0] !== "_" && declaredPropKeys.includes(key)) {
+ this._setProp(key, this[key], true, false);
+ }
+ }
+ for (const key of declaredPropKeys.map(shared.camelize)) {
+ Object.defineProperty(this, key, {
+ get() {
+ return this._getProp(key);
+ },
+ set(val) {
+ this._setProp(key, val);
+ }
+ });
+ }
+ }
+ _setAttr(key) {
+ let value = this.getAttribute(key);
+ const camelKey = shared.camelize(key);
+ if (this._numberProps && this._numberProps[camelKey]) {
+ value = shared.toNumber(value);
+ }
+ this._setProp(camelKey, value, false);
+ }
+ /**
+ * @internal
+ */
+ _getProp(key) {
+ return this._props[key];
+ }
+ /**
+ * @internal
+ */
+ _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
+ if (val !== this._props[key]) {
+ this._props[key] = val;
+ if (shouldUpdate && this._instance) {
+ this._update();
+ }
+ if (shouldReflect) {
+ if (val === true) {
+ this.setAttribute(shared.hyphenate(key), "");
+ } else if (typeof val === "string" || typeof val === "number") {
+ this.setAttribute(shared.hyphenate(key), val + "");
+ } else if (!val) {
+ this.removeAttribute(shared.hyphenate(key));
+ }
+ }
+ }
+ }
+ _update() {
+ render(this._createVNode(), this.shadowRoot);
+ }
+ _createVNode() {
+ const vnode = runtimeCore.createVNode(this._def, shared.extend({}, this._props));
+ if (!this._instance) {
+ vnode.ce = (instance) => {
+ this._instance = instance;
+ instance.isCE = true;
+ {
+ instance.ceReload = (newStyles) => {
+ if (this._styles) {
+ this._styles.forEach((s) => this.shadowRoot.removeChild(s));
+ this._styles.length = 0;
+ }
+ this._applyStyles(newStyles);
+ this._instance = null;
+ this._update();
+ };
+ }
+ const dispatch = (event, args) => {
+ this.dispatchEvent(
+ new CustomEvent(event, {
+ detail: args
+ })
+ );
+ };
+ instance.emit = (event, ...args) => {
+ dispatch(event, args);
+ if (shared.hyphenate(event) !== event) {
+ dispatch(shared.hyphenate(event), args);
+ }
+ };
+ let parent = this;
+ while (parent = parent && (parent.parentNode || parent.host)) {
+ if (parent instanceof VueElement) {
+ instance.parent = parent._instance;
+ instance.provides = parent._instance.provides;
+ break;
+ }
+ }
+ };
+ }
+ return vnode;
+ }
+ _applyStyles(styles) {
+ if (styles) {
+ styles.forEach((css) => {
+ const s = document.createElement("style");
+ s.textContent = css;
+ this.shadowRoot.appendChild(s);
+ {
+ (this._styles || (this._styles = [])).push(s);
+ }
+ });
+ }
+ }
+}
+
+function useCssModule(name = "$style") {
+ {
+ const instance = runtimeCore.getCurrentInstance();
+ if (!instance) {
+ runtimeCore.warn(`useCssModule must be called inside setup()`);
+ return shared.EMPTY_OBJ;
+ }
+ const modules = instance.type.__cssModules;
+ if (!modules) {
+ runtimeCore.warn(`Current instance does not have CSS modules injected.`);
+ return shared.EMPTY_OBJ;
+ }
+ const mod = modules[name];
+ if (!mod) {
+ runtimeCore.warn(`Current instance does not have CSS module named "${name}".`);
+ return shared.EMPTY_OBJ;
+ }
+ return mod;
+ }
+}
+
+function useCssVars(getter) {
+ return;
+}
+
+const positionMap = /* @__PURE__ */ new WeakMap();
+const newPositionMap = /* @__PURE__ */ new WeakMap();
+const moveCbKey = Symbol("_moveCb");
+const enterCbKey = Symbol("_enterCb");
+const TransitionGroupImpl = {
+ name: "TransitionGroup",
+ props: /* @__PURE__ */ shared.extend({}, TransitionPropsValidators, {
+ tag: String,
+ moveClass: String
+ }),
+ setup(props, { slots }) {
+ const instance = runtimeCore.getCurrentInstance();
+ const state = runtimeCore.useTransitionState();
+ let prevChildren;
+ let children;
+ runtimeCore.onUpdated(() => {
+ if (!prevChildren.length) {
+ return;
+ }
+ const moveClass = props.moveClass || `${props.name || "v"}-move`;
+ if (!hasCSSTransform(
+ prevChildren[0].el,
+ instance.vnode.el,
+ moveClass
+ )) {
+ return;
+ }
+ prevChildren.forEach(callPendingCbs);
+ prevChildren.forEach(recordPosition);
+ const movedChildren = prevChildren.filter(applyTranslation);
+ forceReflow();
+ movedChildren.forEach((c) => {
+ const el = c.el;
+ const style = el.style;
+ addTransitionClass(el, moveClass);
+ style.transform = style.webkitTransform = style.transitionDuration = "";
+ const cb = el[moveCbKey] = (e) => {
+ if (e && e.target !== el) {
+ return;
+ }
+ if (!e || /transform$/.test(e.propertyName)) {
+ el.removeEventListener("transitionend", cb);
+ el[moveCbKey] = null;
+ removeTransitionClass(el, moveClass);
+ }
+ };
+ el.addEventListener("transitionend", cb);
+ });
+ });
+ return () => {
+ const rawProps = runtimeCore.toRaw(props);
+ const cssTransitionProps = resolveTransitionProps(rawProps);
+ let tag = rawProps.tag || runtimeCore.Fragment;
+ prevChildren = children;
+ children = slots.default ? runtimeCore.getTransitionRawChildren(slots.default()) : [];
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (child.key != null) {
+ runtimeCore.setTransitionHooks(
+ child,
+ runtimeCore.resolveTransitionHooks(child, cssTransitionProps, state, instance)
+ );
+ } else {
+ runtimeCore.warn(`<TransitionGroup> children must be keyed.`);
+ }
+ }
+ if (prevChildren) {
+ for (let i = 0; i < prevChildren.length; i++) {
+ const child = prevChildren[i];
+ runtimeCore.setTransitionHooks(
+ child,
+ runtimeCore.resolveTransitionHooks(child, cssTransitionProps, state, instance)
+ );
+ positionMap.set(child, child.el.getBoundingClientRect());
+ }
+ }
+ return runtimeCore.createVNode(tag, null, children);
+ };
+ }
+};
+const removeMode = (props) => delete props.mode;
+/* @__PURE__ */ removeMode(TransitionGroupImpl.props);
+const TransitionGroup = TransitionGroupImpl;
+function callPendingCbs(c) {
+ const el = c.el;
+ if (el[moveCbKey]) {
+ el[moveCbKey]();
+ }
+ if (el[enterCbKey]) {
+ el[enterCbKey]();
+ }
+}
+function recordPosition(c) {
+ newPositionMap.set(c, c.el.getBoundingClientRect());
+}
+function applyTranslation(c) {
+ const oldPos = positionMap.get(c);
+ const newPos = newPositionMap.get(c);
+ const dx = oldPos.left - newPos.left;
+ const dy = oldPos.top - newPos.top;
+ if (dx || dy) {
+ const s = c.el.style;
+ s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+ s.transitionDuration = "0s";
+ return c;
+ }
+}
+function hasCSSTransform(el, root, moveClass) {
+ const clone = el.cloneNode();
+ const _vtc = el[vtcKey];
+ if (_vtc) {
+ _vtc.forEach((cls) => {
+ cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
+ });
+ }
+ moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
+ clone.style.display = "none";
+ const container = root.nodeType === 1 ? root : root.parentNode;
+ container.appendChild(clone);
+ const { hasTransform } = getTransitionInfo(clone);
+ container.removeChild(clone);
+ return hasTransform;
+}
+
+const getModelAssigner = (vnode) => {
+ const fn = vnode.props["onUpdate:modelValue"] || false;
+ return shared.isArray(fn) ? (value) => shared.invokeArrayFns(fn, value) : fn;
+};
+function onCompositionStart(e) {
+ e.target.composing = true;
+}
+function onCompositionEnd(e) {
+ const target = e.target;
+ if (target.composing) {
+ target.composing = false;
+ target.dispatchEvent(new Event("input"));
+ }
+}
+const assignKey = Symbol("_assign");
+const vModelText = {
+ created(el, { modifiers: { lazy, trim, number } }, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ const castToNumber = number || vnode.props && vnode.props.type === "number";
+ addEventListener(el, lazy ? "change" : "input", (e) => {
+ if (e.target.composing)
+ return;
+ let domValue = el.value;
+ if (trim) {
+ domValue = domValue.trim();
+ }
+ if (castToNumber) {
+ domValue = shared.looseToNumber(domValue);
+ }
+ el[assignKey](domValue);
+ });
+ if (trim) {
+ addEventListener(el, "change", () => {
+ el.value = el.value.trim();
+ });
+ }
+ if (!lazy) {
+ addEventListener(el, "compositionstart", onCompositionStart);
+ addEventListener(el, "compositionend", onCompositionEnd);
+ addEventListener(el, "change", onCompositionEnd);
+ }
+ },
+ // set value on mounted so it's after min/max for type="range"
+ mounted(el, { value }) {
+ el.value = value == null ? "" : value;
+ },
+ beforeUpdate(el, { value, modifiers: { lazy, trim, number } }, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ if (el.composing)
+ return;
+ const elValue = number || el.type === "number" ? shared.looseToNumber(el.value) : el.value;
+ const newValue = value == null ? "" : value;
+ if (elValue === newValue) {
+ return;
+ }
+ if (document.activeElement === el && el.type !== "range") {
+ if (lazy) {
+ return;
+ }
+ if (trim && el.value.trim() === newValue) {
+ return;
+ }
+ }
+ el.value = newValue;
+ }
+};
+const vModelCheckbox = {
+ // #4096 array checkboxes need to be deep traversed
+ deep: true,
+ created(el, _, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ addEventListener(el, "change", () => {
+ const modelValue = el._modelValue;
+ const elementValue = getValue(el);
+ const checked = el.checked;
+ const assign = el[assignKey];
+ if (shared.isArray(modelValue)) {
+ const index = shared.looseIndexOf(modelValue, elementValue);
+ const found = index !== -1;
+ if (checked && !found) {
+ assign(modelValue.concat(elementValue));
+ } else if (!checked && found) {
+ const filtered = [...modelValue];
+ filtered.splice(index, 1);
+ assign(filtered);
+ }
+ } else if (shared.isSet(modelValue)) {
+ const cloned = new Set(modelValue);
+ if (checked) {
+ cloned.add(elementValue);
+ } else {
+ cloned.delete(elementValue);
+ }
+ assign(cloned);
+ } else {
+ assign(getCheckboxValue(el, checked));
+ }
+ });
+ },
+ // set initial checked on mount to wait for true-value/false-value
+ mounted: setChecked,
+ beforeUpdate(el, binding, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ setChecked(el, binding, vnode);
+ }
+};
+function setChecked(el, { value, oldValue }, vnode) {
+ el._modelValue = value;
+ if (shared.isArray(value)) {
+ el.checked = shared.looseIndexOf(value, vnode.props.value) > -1;
+ } else if (shared.isSet(value)) {
+ el.checked = value.has(vnode.props.value);
+ } else if (value !== oldValue) {
+ el.checked = shared.looseEqual(value, getCheckboxValue(el, true));
+ }
+}
+const vModelRadio = {
+ created(el, { value }, vnode) {
+ el.checked = shared.looseEqual(value, vnode.props.value);
+ el[assignKey] = getModelAssigner(vnode);
+ addEventListener(el, "change", () => {
+ el[assignKey](getValue(el));
+ });
+ },
+ beforeUpdate(el, { value, oldValue }, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ if (value !== oldValue) {
+ el.checked = shared.looseEqual(value, vnode.props.value);
+ }
+ }
+};
+const vModelSelect = {
+ // <select multiple> value need to be deep traversed
+ deep: true,
+ created(el, { value, modifiers: { number } }, vnode) {
+ const isSetModel = shared.isSet(value);
+ addEventListener(el, "change", () => {
+ const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
+ (o) => number ? shared.looseToNumber(getValue(o)) : getValue(o)
+ );
+ el[assignKey](
+ el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
+ );
+ });
+ el[assignKey] = getModelAssigner(vnode);
+ },
+ // set value in mounted & updated because <select> relies on its children
+ // <option>s.
+ mounted(el, { value }) {
+ setSelected(el, value);
+ },
+ beforeUpdate(el, _binding, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ },
+ updated(el, { value }) {
+ setSelected(el, value);
+ }
+};
+function setSelected(el, value) {
+ const isMultiple = el.multiple;
+ if (isMultiple && !shared.isArray(value) && !shared.isSet(value)) {
+ runtimeCore.warn(
+ `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(value).slice(8, -1)}.`
+ );
+ return;
+ }
+ for (let i = 0, l = el.options.length; i < l; i++) {
+ const option = el.options[i];
+ const optionValue = getValue(option);
+ if (isMultiple) {
+ if (shared.isArray(value)) {
+ option.selected = shared.looseIndexOf(value, optionValue) > -1;
+ } else {
+ option.selected = value.has(optionValue);
+ }
+ } else {
+ if (shared.looseEqual(getValue(option), value)) {
+ if (el.selectedIndex !== i)
+ el.selectedIndex = i;
+ return;
+ }
+ }
+ }
+ if (!isMultiple && el.selectedIndex !== -1) {
+ el.selectedIndex = -1;
+ }
+}
+function getValue(el) {
+ return "_value" in el ? el._value : el.value;
+}
+function getCheckboxValue(el, checked) {
+ const key = checked ? "_trueValue" : "_falseValue";
+ return key in el ? el[key] : checked;
+}
+const vModelDynamic = {
+ created(el, binding, vnode) {
+ callModelHook(el, binding, vnode, null, "created");
+ },
+ mounted(el, binding, vnode) {
+ callModelHook(el, binding, vnode, null, "mounted");
+ },
+ beforeUpdate(el, binding, vnode, prevVNode) {
+ callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+ },
+ updated(el, binding, vnode, prevVNode) {
+ callModelHook(el, binding, vnode, prevVNode, "updated");
+ }
+};
+function resolveDynamicModel(tagName, type) {
+ switch (tagName) {
+ case "SELECT":
+ return vModelSelect;
+ case "TEXTAREA":
+ return vModelText;
+ default:
+ switch (type) {
+ case "checkbox":
+ return vModelCheckbox;
+ case "radio":
+ return vModelRadio;
+ default:
+ return vModelText;
+ }
+ }
+}
+function callModelHook(el, binding, vnode, prevVNode, hook) {
+ const modelToUse = resolveDynamicModel(
+ el.tagName,
+ vnode.props && vnode.props.type
+ );
+ const fn = modelToUse[hook];
+ fn && fn(el, binding, vnode, prevVNode);
+}
+function initVModelForSSR() {
+ vModelText.getSSRProps = ({ value }) => ({ value });
+ vModelRadio.getSSRProps = ({ value }, vnode) => {
+ if (vnode.props && shared.looseEqual(vnode.props.value, value)) {
+ return { checked: true };
+ }
+ };
+ vModelCheckbox.getSSRProps = ({ value }, vnode) => {
+ if (shared.isArray(value)) {
+ if (vnode.props && shared.looseIndexOf(value, vnode.props.value) > -1) {
+ return { checked: true };
+ }
+ } else if (shared.isSet(value)) {
+ if (vnode.props && value.has(vnode.props.value)) {
+ return { checked: true };
+ }
+ } else if (value) {
+ return { checked: true };
+ }
+ };
+ vModelDynamic.getSSRProps = (binding, vnode) => {
+ if (typeof vnode.type !== "string") {
+ return;
+ }
+ const modelToUse = resolveDynamicModel(
+ // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
+ vnode.type.toUpperCase(),
+ vnode.props && vnode.props.type
+ );
+ if (modelToUse.getSSRProps) {
+ return modelToUse.getSSRProps(binding, vnode);
+ }
+ };
+}
+
+const systemModifiers = ["ctrl", "shift", "alt", "meta"];
+const modifierGuards = {
+ stop: (e) => e.stopPropagation(),
+ prevent: (e) => e.preventDefault(),
+ self: (e) => e.target !== e.currentTarget,
+ ctrl: (e) => !e.ctrlKey,
+ shift: (e) => !e.shiftKey,
+ alt: (e) => !e.altKey,
+ meta: (e) => !e.metaKey,
+ left: (e) => "button" in e && e.button !== 0,
+ middle: (e) => "button" in e && e.button !== 1,
+ right: (e) => "button" in e && e.button !== 2,
+ exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
+};
+const withModifiers = (fn, modifiers) => {
+ return (event, ...args) => {
+ for (let i = 0; i < modifiers.length; i++) {
+ const guard = modifierGuards[modifiers[i]];
+ if (guard && guard(event, modifiers))
+ return;
+ }
+ return fn(event, ...args);
+ };
+};
+const keyNames = {
+ esc: "escape",
+ space: " ",
+ up: "arrow-up",
+ left: "arrow-left",
+ right: "arrow-right",
+ down: "arrow-down",
+ delete: "backspace"
+};
+const withKeys = (fn, modifiers) => {
+ return (event) => {
+ if (!("key" in event)) {
+ return;
+ }
+ const eventKey = shared.hyphenate(event.key);
+ if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {
+ return fn(event);
+ }
+ };
+};
+
+const rendererOptions = /* @__PURE__ */ shared.extend({ patchProp }, nodeOps);
+let renderer;
+let enabledHydration = false;
+function ensureRenderer() {
+ return renderer || (renderer = runtimeCore.createRenderer(rendererOptions));
+}
+function ensureHydrationRenderer() {
+ renderer = enabledHydration ? renderer : runtimeCore.createHydrationRenderer(rendererOptions);
+ enabledHydration = true;
+ return renderer;
+}
+const render = (...args) => {
+ ensureRenderer().render(...args);
+};
+const hydrate = (...args) => {
+ ensureHydrationRenderer().hydrate(...args);
+};
+const createApp = (...args) => {
+ const app = ensureRenderer().createApp(...args);
+ {
+ injectNativeTagCheck(app);
+ injectCompilerOptionsCheck(app);
+ }
+ const { mount } = app;
+ app.mount = (containerOrSelector) => {
+ const container = normalizeContainer(containerOrSelector);
+ if (!container)
+ return;
+ const component = app._component;
+ if (!shared.isFunction(component) && !component.render && !component.template) {
+ component.template = container.innerHTML;
+ }
+ container.innerHTML = "";
+ const proxy = mount(container, false, container instanceof SVGElement);
+ if (container instanceof Element) {
+ container.removeAttribute("v-cloak");
+ container.setAttribute("data-v-app", "");
+ }
+ return proxy;
+ };
+ return app;
+};
+const createSSRApp = (...args) => {
+ const app = ensureHydrationRenderer().createApp(...args);
+ {
+ injectNativeTagCheck(app);
+ injectCompilerOptionsCheck(app);
+ }
+ const { mount } = app;
+ app.mount = (containerOrSelector) => {
+ const container = normalizeContainer(containerOrSelector);
+ if (container) {
+ return mount(container, true, container instanceof SVGElement);
+ }
+ };
+ return app;
+};
+function injectNativeTagCheck(app) {
+ Object.defineProperty(app.config, "isNativeTag", {
+ value: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag),
+ writable: false
+ });
+}
+function injectCompilerOptionsCheck(app) {
+ if (runtimeCore.isRuntimeOnly()) {
+ const isCustomElement = app.config.isCustomElement;
+ Object.defineProperty(app.config, "isCustomElement", {
+ get() {
+ return isCustomElement;
+ },
+ set() {
+ runtimeCore.warn(
+ `The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.`
+ );
+ }
+ });
+ const compilerOptions = app.config.compilerOptions;
+ const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead.
+- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.
+- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
+- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
+ Object.defineProperty(app.config, "compilerOptions", {
+ get() {
+ runtimeCore.warn(msg);
+ return compilerOptions;
+ },
+ set() {
+ runtimeCore.warn(msg);
+ }
+ });
+ }
+}
+function normalizeContainer(container) {
+ if (shared.isString(container)) {
+ const res = document.querySelector(container);
+ if (!res) {
+ runtimeCore.warn(
+ `Failed to mount app: mount target selector "${container}" returned null.`
+ );
+ }
+ return res;
+ }
+ if (window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") {
+ runtimeCore.warn(
+ `mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`
+ );
+ }
+ return container;
+}
+let ssrDirectiveInitialized = false;
+const initDirectivesForSSR = () => {
+ if (!ssrDirectiveInitialized) {
+ ssrDirectiveInitialized = true;
+ initVModelForSSR();
+ initVShowForSSR();
+ }
+} ;
+
+exports.Transition = Transition;
+exports.TransitionGroup = TransitionGroup;
+exports.VueElement = VueElement;
+exports.createApp = createApp;
+exports.createSSRApp = createSSRApp;
+exports.defineCustomElement = defineCustomElement;
+exports.defineSSRCustomElement = defineSSRCustomElement;
+exports.hydrate = hydrate;
+exports.initDirectivesForSSR = initDirectivesForSSR;
+exports.render = render;
+exports.useCssModule = useCssModule;
+exports.useCssVars = useCssVars;
+exports.vModelCheckbox = vModelCheckbox;
+exports.vModelDynamic = vModelDynamic;
+exports.vModelRadio = vModelRadio;
+exports.vModelSelect = vModelSelect;
+exports.vModelText = vModelText;
+exports.vShow = vShow;
+exports.withKeys = withKeys;
+exports.withModifiers = withModifiers;
+Object.keys(runtimeCore).forEach(function (k) {
+ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeCore[k];
+});
diff --git a/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.prod.js b/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.prod.js
new file mode 100644
index 0000000..c108dc2
--- /dev/null
+++ b/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.prod.js
@@ -0,0 +1,1406 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtimeCore = require('@vue/runtime-core');
+var shared = require('@vue/shared');
+
+const svgNS = "http://www.w3.org/2000/svg";
+const doc = typeof document !== "undefined" ? document : null;
+const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
+const nodeOps = {
+ insert: (child, parent, anchor) => {
+ parent.insertBefore(child, anchor || null);
+ },
+ remove: (child) => {
+ const parent = child.parentNode;
+ if (parent) {
+ parent.removeChild(child);
+ }
+ },
+ createElement: (tag, isSVG, is, props) => {
+ const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);
+ if (tag === "select" && props && props.multiple != null) {
+ el.setAttribute("multiple", props.multiple);
+ }
+ return el;
+ },
+ createText: (text) => doc.createTextNode(text),
+ createComment: (text) => doc.createComment(text),
+ setText: (node, text) => {
+ node.nodeValue = text;
+ },
+ setElementText: (el, text) => {
+ el.textContent = text;
+ },
+ parentNode: (node) => node.parentNode,
+ nextSibling: (node) => node.nextSibling,
+ querySelector: (selector) => doc.querySelector(selector),
+ setScopeId(el, id) {
+ el.setAttribute(id, "");
+ },
+ // __UNSAFE__
+ // Reason: innerHTML.
+ // Static content here can only come from compiled templates.
+ // As long as the user only uses trusted templates, this is safe.
+ insertStaticContent(content, parent, anchor, isSVG, start, end) {
+ const before = anchor ? anchor.previousSibling : parent.lastChild;
+ if (start && (start === end || start.nextSibling)) {
+ while (true) {
+ parent.insertBefore(start.cloneNode(true), anchor);
+ if (start === end || !(start = start.nextSibling))
+ break;
+ }
+ } else {
+ templateContainer.innerHTML = isSVG ? `<svg>${content}</svg>` : content;
+ const template = templateContainer.content;
+ if (isSVG) {
+ const wrapper = template.firstChild;
+ while (wrapper.firstChild) {
+ template.appendChild(wrapper.firstChild);
+ }
+ template.removeChild(wrapper);
+ }
+ parent.insertBefore(template, anchor);
+ }
+ return [
+ // first
+ before ? before.nextSibling : parent.firstChild,
+ // last
+ anchor ? anchor.previousSibling : parent.lastChild
+ ];
+ }
+};
+
+const TRANSITION = "transition";
+const ANIMATION = "animation";
+const vtcKey = Symbol("_vtc");
+const Transition = (props, { slots }) => runtimeCore.h(runtimeCore.BaseTransition, resolveTransitionProps(props), slots);
+Transition.displayName = "Transition";
+const DOMTransitionPropsValidators = {
+ name: String,
+ type: String,
+ css: {
+ type: Boolean,
+ default: true
+ },
+ duration: [String, Number, Object],
+ enterFromClass: String,
+ enterActiveClass: String,
+ enterToClass: String,
+ appearFromClass: String,
+ appearActiveClass: String,
+ appearToClass: String,
+ leaveFromClass: String,
+ leaveActiveClass: String,
+ leaveToClass: String
+};
+const TransitionPropsValidators = Transition.props = /* @__PURE__ */ shared.extend(
+ {},
+ runtimeCore.BaseTransitionPropsValidators,
+ DOMTransitionPropsValidators
+);
+const callHook = (hook, args = []) => {
+ if (shared.isArray(hook)) {
+ hook.forEach((h2) => h2(...args));
+ } else if (hook) {
+ hook(...args);
+ }
+};
+const hasExplicitCallback = (hook) => {
+ return hook ? shared.isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+};
+function resolveTransitionProps(rawProps) {
+ const baseProps = {};
+ for (const key in rawProps) {
+ if (!(key in DOMTransitionPropsValidators)) {
+ baseProps[key] = rawProps[key];
+ }
+ }
+ if (rawProps.css === false) {
+ return baseProps;
+ }
+ const {
+ name = "v",
+ type,
+ duration,
+ enterFromClass = `${name}-enter-from`,
+ enterActiveClass = `${name}-enter-active`,
+ enterToClass = `${name}-enter-to`,
+ appearFromClass = enterFromClass,
+ appearActiveClass = enterActiveClass,
+ appearToClass = enterToClass,
+ leaveFromClass = `${name}-leave-from`,
+ leaveActiveClass = `${name}-leave-active`,
+ leaveToClass = `${name}-leave-to`
+ } = rawProps;
+ const durations = normalizeDuration(duration);
+ const enterDuration = durations && durations[0];
+ const leaveDuration = durations && durations[1];
+ const {
+ onBeforeEnter,
+ onEnter,
+ onEnterCancelled,
+ onLeave,
+ onLeaveCancelled,
+ onBeforeAppear = onBeforeEnter,
+ onAppear = onEnter,
+ onAppearCancelled = onEnterCancelled
+ } = baseProps;
+ const finishEnter = (el, isAppear, done) => {
+ removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
+ removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
+ done && done();
+ };
+ const finishLeave = (el, done) => {
+ el._isLeaving = false;
+ removeTransitionClass(el, leaveFromClass);
+ removeTransitionClass(el, leaveToClass);
+ removeTransitionClass(el, leaveActiveClass);
+ done && done();
+ };
+ const makeEnterHook = (isAppear) => {
+ return (el, done) => {
+ const hook = isAppear ? onAppear : onEnter;
+ const resolve = () => finishEnter(el, isAppear, done);
+ callHook(hook, [el, resolve]);
+ nextFrame(() => {
+ removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
+ addTransitionClass(el, isAppear ? appearToClass : enterToClass);
+ if (!hasExplicitCallback(hook)) {
+ whenTransitionEnds(el, type, enterDuration, resolve);
+ }
+ });
+ };
+ };
+ return shared.extend(baseProps, {
+ onBeforeEnter(el) {
+ callHook(onBeforeEnter, [el]);
+ addTransitionClass(el, enterFromClass);
+ addTransitionClass(el, enterActiveClass);
+ },
+ onBeforeAppear(el) {
+ callHook(onBeforeAppear, [el]);
+ addTransitionClass(el, appearFromClass);
+ addTransitionClass(el, appearActiveClass);
+ },
+ onEnter: makeEnterHook(false),
+ onAppear: makeEnterHook(true),
+ onLeave(el, done) {
+ el._isLeaving = true;
+ const resolve = () => finishLeave(el, done);
+ addTransitionClass(el, leaveFromClass);
+ forceReflow();
+ addTransitionClass(el, leaveActiveClass);
+ nextFrame(() => {
+ if (!el._isLeaving) {
+ return;
+ }
+ removeTransitionClass(el, leaveFromClass);
+ addTransitionClass(el, leaveToClass);
+ if (!hasExplicitCallback(onLeave)) {
+ whenTransitionEnds(el, type, leaveDuration, resolve);
+ }
+ });
+ callHook(onLeave, [el, resolve]);
+ },
+ onEnterCancelled(el) {
+ finishEnter(el, false);
+ callHook(onEnterCancelled, [el]);
+ },
+ onAppearCancelled(el) {
+ finishEnter(el, true);
+ callHook(onAppearCancelled, [el]);
+ },
+ onLeaveCancelled(el) {
+ finishLeave(el);
+ callHook(onLeaveCancelled, [el]);
+ }
+ });
+}
+function normalizeDuration(duration) {
+ if (duration == null) {
+ return null;
+ } else if (shared.isObject(duration)) {
+ return [NumberOf(duration.enter), NumberOf(duration.leave)];
+ } else {
+ const n = NumberOf(duration);
+ return [n, n];
+ }
+}
+function NumberOf(val) {
+ const res = shared.toNumber(val);
+ return res;
+}
+function addTransitionClass(el, cls) {
+ cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
+ (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
+}
+function removeTransitionClass(el, cls) {
+ cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
+ const _vtc = el[vtcKey];
+ if (_vtc) {
+ _vtc.delete(cls);
+ if (!_vtc.size) {
+ el[vtcKey] = void 0;
+ }
+ }
+}
+function nextFrame(cb) {
+ requestAnimationFrame(() => {
+ requestAnimationFrame(cb);
+ });
+}
+let endId = 0;
+function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
+ const id = el._endId = ++endId;
+ const resolveIfNotStale = () => {
+ if (id === el._endId) {
+ resolve();
+ }
+ };
+ if (explicitTimeout) {
+ return setTimeout(resolveIfNotStale, explicitTimeout);
+ }
+ const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+ if (!type) {
+ return resolve();
+ }
+ const endEvent = type + "end";
+ let ended = 0;
+ const end = () => {
+ el.removeEventListener(endEvent, onEnd);
+ resolveIfNotStale();
+ };
+ const onEnd = (e) => {
+ if (e.target === el && ++ended >= propCount) {
+ end();
+ }
+ };
+ setTimeout(() => {
+ if (ended < propCount) {
+ end();
+ }
+ }, timeout + 1);
+ el.addEventListener(endEvent, onEnd);
+}
+function getTransitionInfo(el, expectedType) {
+ const styles = window.getComputedStyle(el);
+ const getStyleProperties = (key) => (styles[key] || "").split(", ");
+ const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
+ const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
+ const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+ const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
+ const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
+ const animationTimeout = getTimeout(animationDelays, animationDurations);
+ let type = null;
+ let timeout = 0;
+ let propCount = 0;
+ if (expectedType === TRANSITION) {
+ if (transitionTimeout > 0) {
+ type = TRANSITION;
+ timeout = transitionTimeout;
+ propCount = transitionDurations.length;
+ }
+ } else if (expectedType === ANIMATION) {
+ if (animationTimeout > 0) {
+ type = ANIMATION;
+ timeout = animationTimeout;
+ propCount = animationDurations.length;
+ }
+ } else {
+ timeout = Math.max(transitionTimeout, animationTimeout);
+ type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
+ propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
+ }
+ const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
+ getStyleProperties(`${TRANSITION}Property`).toString()
+ );
+ return {
+ type,
+ timeout,
+ propCount,
+ hasTransform
+ };
+}
+function getTimeout(delays, durations) {
+ while (delays.length < durations.length) {
+ delays = delays.concat(delays);
+ }
+ return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
+}
+function toMs(s) {
+ if (s === "auto")
+ return 0;
+ return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+}
+function forceReflow() {
+ return document.body.offsetHeight;
+}
+
+function patchClass(el, value, isSVG) {
+ const transitionClasses = el[vtcKey];
+ if (transitionClasses) {
+ value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
+ }
+ if (value == null) {
+ el.removeAttribute("class");
+ } else if (isSVG) {
+ el.setAttribute("class", value);
+ } else {
+ el.className = value;
+ }
+}
+
+const vShowOldKey = Symbol("_vod");
+const vShow = {
+ beforeMount(el, { value }, { transition }) {
+ el[vShowOldKey] = el.style.display === "none" ? "" : el.style.display;
+ if (transition && value) {
+ transition.beforeEnter(el);
+ } else {
+ setDisplay(el, value);
+ }
+ },
+ mounted(el, { value }, { transition }) {
+ if (transition && value) {
+ transition.enter(el);
+ }
+ },
+ updated(el, { value, oldValue }, { transition }) {
+ if (!value === !oldValue)
+ return;
+ if (transition) {
+ if (value) {
+ transition.beforeEnter(el);
+ setDisplay(el, true);
+ transition.enter(el);
+ } else {
+ transition.leave(el, () => {
+ setDisplay(el, false);
+ });
+ }
+ } else {
+ setDisplay(el, value);
+ }
+ },
+ beforeUnmount(el, { value }) {
+ setDisplay(el, value);
+ }
+};
+function setDisplay(el, value) {
+ el.style.display = value ? el[vShowOldKey] : "none";
+}
+function initVShowForSSR() {
+ vShow.getSSRProps = ({ value }) => {
+ if (!value) {
+ return { style: { display: "none" } };
+ }
+ };
+}
+
+function patchStyle(el, prev, next) {
+ const style = el.style;
+ const isCssString = shared.isString(next);
+ if (next && !isCssString) {
+ if (prev && !shared.isString(prev)) {
+ for (const key in prev) {
+ if (next[key] == null) {
+ setStyle(style, key, "");
+ }
+ }
+ }
+ for (const key in next) {
+ setStyle(style, key, next[key]);
+ }
+ } else {
+ const currentDisplay = style.display;
+ if (isCssString) {
+ if (prev !== next) {
+ style.cssText = next;
+ }
+ } else if (prev) {
+ el.removeAttribute("style");
+ }
+ if (vShowOldKey in el) {
+ style.display = currentDisplay;
+ }
+ }
+}
+const importantRE = /\s*!important$/;
+function setStyle(style, name, val) {
+ if (shared.isArray(val)) {
+ val.forEach((v) => setStyle(style, name, v));
+ } else {
+ if (val == null)
+ val = "";
+ if (name.startsWith("--")) {
+ style.setProperty(name, val);
+ } else {
+ const prefixed = autoPrefix(style, name);
+ if (importantRE.test(val)) {
+ style.setProperty(
+ shared.hyphenate(prefixed),
+ val.replace(importantRE, ""),
+ "important"
+ );
+ } else {
+ style[prefixed] = val;
+ }
+ }
+ }
+}
+const prefixes = ["Webkit", "Moz", "ms"];
+const prefixCache = {};
+function autoPrefix(style, rawName) {
+ const cached = prefixCache[rawName];
+ if (cached) {
+ return cached;
+ }
+ let name = runtimeCore.camelize(rawName);
+ if (name !== "filter" && name in style) {
+ return prefixCache[rawName] = name;
+ }
+ name = shared.capitalize(name);
+ for (let i = 0; i < prefixes.length; i++) {
+ const prefixed = prefixes[i] + name;
+ if (prefixed in style) {
+ return prefixCache[rawName] = prefixed;
+ }
+ }
+ return rawName;
+}
+
+const xlinkNS = "http://www.w3.org/1999/xlink";
+function patchAttr(el, key, value, isSVG, instance) {
+ if (isSVG && key.startsWith("xlink:")) {
+ if (value == null) {
+ el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
+ } else {
+ el.setAttributeNS(xlinkNS, key, value);
+ }
+ } else {
+ const isBoolean = shared.isSpecialBooleanAttr(key);
+ if (value == null || isBoolean && !shared.includeBooleanAttr(value)) {
+ el.removeAttribute(key);
+ } else {
+ el.setAttribute(key, isBoolean ? "" : value);
+ }
+ }
+}
+
+function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) {
+ if (key === "innerHTML" || key === "textContent") {
+ if (prevChildren) {
+ unmountChildren(prevChildren, parentComponent, parentSuspense);
+ }
+ el[key] = value == null ? "" : value;
+ return;
+ }
+ const tag = el.tagName;
+ if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
+ !tag.includes("-")) {
+ el._value = value;
+ const oldValue = tag === "OPTION" ? el.getAttribute("value") : el.value;
+ const newValue = value == null ? "" : value;
+ if (oldValue !== newValue) {
+ el.value = newValue;
+ }
+ if (value == null) {
+ el.removeAttribute(key);
+ }
+ return;
+ }
+ let needRemove = false;
+ if (value === "" || value == null) {
+ const type = typeof el[key];
+ if (type === "boolean") {
+ value = shared.includeBooleanAttr(value);
+ } else if (value == null && type === "string") {
+ value = "";
+ needRemove = true;
+ } else if (type === "number") {
+ value = 0;
+ needRemove = true;
+ }
+ }
+ try {
+ el[key] = value;
+ } catch (e) {
+ }
+ needRemove && el.removeAttribute(key);
+}
+
+function addEventListener(el, event, handler, options) {
+ el.addEventListener(event, handler, options);
+}
+function removeEventListener(el, event, handler, options) {
+ el.removeEventListener(event, handler, options);
+}
+const veiKey = Symbol("_vei");
+function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
+ const invokers = el[veiKey] || (el[veiKey] = {});
+ const existingInvoker = invokers[rawName];
+ if (nextValue && existingInvoker) {
+ existingInvoker.value = nextValue;
+ } else {
+ const [name, options] = parseName(rawName);
+ if (nextValue) {
+ const invoker = invokers[rawName] = createInvoker(nextValue, instance);
+ addEventListener(el, name, invoker, options);
+ } else if (existingInvoker) {
+ removeEventListener(el, name, existingInvoker, options);
+ invokers[rawName] = void 0;
+ }
+ }
+}
+const optionsModifierRE = /(?:Once|Passive|Capture)$/;
+function parseName(name) {
+ let options;
+ if (optionsModifierRE.test(name)) {
+ options = {};
+ let m;
+ while (m = name.match(optionsModifierRE)) {
+ name = name.slice(0, name.length - m[0].length);
+ options[m[0].toLowerCase()] = true;
+ }
+ }
+ const event = name[2] === ":" ? name.slice(3) : shared.hyphenate(name.slice(2));
+ return [event, options];
+}
+let cachedNow = 0;
+const p = /* @__PURE__ */ Promise.resolve();
+const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
+function createInvoker(initialValue, instance) {
+ const invoker = (e) => {
+ if (!e._vts) {
+ e._vts = Date.now();
+ } else if (e._vts <= invoker.attached) {
+ return;
+ }
+ runtimeCore.callWithAsyncErrorHandling(
+ patchStopImmediatePropagation(e, invoker.value),
+ instance,
+ 5,
+ [e]
+ );
+ };
+ invoker.value = initialValue;
+ invoker.attached = getNow();
+ return invoker;
+}
+function patchStopImmediatePropagation(e, value) {
+ if (shared.isArray(value)) {
+ const originalStop = e.stopImmediatePropagation;
+ e.stopImmediatePropagation = () => {
+ originalStop.call(e);
+ e._stopped = true;
+ };
+ return value.map((fn) => (e2) => !e2._stopped && fn && fn(e2));
+ } else {
+ return value;
+ }
+}
+
+const nativeOnRE = /^on[a-z]/;
+const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
+ if (key === "class") {
+ patchClass(el, nextValue, isSVG);
+ } else if (key === "style") {
+ patchStyle(el, prevValue, nextValue);
+ } else if (shared.isOn(key)) {
+ if (!shared.isModelListener(key)) {
+ patchEvent(el, key, prevValue, nextValue, parentComponent);
+ }
+ } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
+ patchDOMProp(
+ el,
+ key,
+ nextValue,
+ prevChildren,
+ parentComponent,
+ parentSuspense,
+ unmountChildren
+ );
+ } else {
+ if (key === "true-value") {
+ el._trueValue = nextValue;
+ } else if (key === "false-value") {
+ el._falseValue = nextValue;
+ }
+ patchAttr(el, key, nextValue, isSVG);
+ }
+};
+function shouldSetAsProp(el, key, value, isSVG) {
+ if (isSVG) {
+ if (key === "innerHTML" || key === "textContent") {
+ return true;
+ }
+ if (key in el && nativeOnRE.test(key) && shared.isFunction(value)) {
+ return true;
+ }
+ return false;
+ }
+ if (key === "spellcheck" || key === "draggable" || key === "translate") {
+ return false;
+ }
+ if (key === "form") {
+ return false;
+ }
+ if (key === "list" && el.tagName === "INPUT") {
+ return false;
+ }
+ if (key === "type" && el.tagName === "TEXTAREA") {
+ return false;
+ }
+ if (nativeOnRE.test(key) && shared.isString(value)) {
+ return false;
+ }
+ return key in el;
+}
+
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineCustomElement(options, hydrate2) {
+ const Comp = runtimeCore.defineComponent(options);
+ class VueCustomElement extends VueElement {
+ constructor(initialProps) {
+ super(Comp, initialProps, hydrate2);
+ }
+ }
+ VueCustomElement.def = Comp;
+ return VueCustomElement;
+}
+/*! #__NO_SIDE_EFFECTS__ */
+const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options) => {
+ return /* @__PURE__ */ defineCustomElement(options, hydrate);
+};
+const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
+};
+class VueElement extends BaseClass {
+ constructor(_def, _props = {}, hydrate2) {
+ super();
+ this._def = _def;
+ this._props = _props;
+ /**
+ * @internal
+ */
+ this._instance = null;
+ this._connected = false;
+ this._resolved = false;
+ this._numberProps = null;
+ this._ob = null;
+ if (this.shadowRoot && hydrate2) {
+ hydrate2(this._createVNode(), this.shadowRoot);
+ } else {
+ this.attachShadow({ mode: "open" });
+ if (!this._def.__asyncLoader) {
+ this._resolveProps(this._def);
+ }
+ }
+ }
+ connectedCallback() {
+ this._connected = true;
+ if (!this._instance) {
+ if (this._resolved) {
+ this._update();
+ } else {
+ this._resolveDef();
+ }
+ }
+ }
+ disconnectedCallback() {
+ this._connected = false;
+ if (this._ob) {
+ this._ob.disconnect();
+ this._ob = null;
+ }
+ runtimeCore.nextTick(() => {
+ if (!this._connected) {
+ render(null, this.shadowRoot);
+ this._instance = null;
+ }
+ });
+ }
+ /**
+ * resolve inner component definition (handle possible async component)
+ */
+ _resolveDef() {
+ this._resolved = true;
+ for (let i = 0; i < this.attributes.length; i++) {
+ this._setAttr(this.attributes[i].name);
+ }
+ this._ob = new MutationObserver((mutations) => {
+ for (const m of mutations) {
+ this._setAttr(m.attributeName);
+ }
+ });
+ this._ob.observe(this, { attributes: true });
+ const resolve = (def, isAsync = false) => {
+ const { props, styles } = def;
+ let numberProps;
+ if (props && !shared.isArray(props)) {
+ for (const key in props) {
+ const opt = props[key];
+ if (opt === Number || opt && opt.type === Number) {
+ if (key in this._props) {
+ this._props[key] = shared.toNumber(this._props[key]);
+ }
+ (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[shared.camelize(key)] = true;
+ }
+ }
+ }
+ this._numberProps = numberProps;
+ if (isAsync) {
+ this._resolveProps(def);
+ }
+ this._applyStyles(styles);
+ this._update();
+ };
+ const asyncDef = this._def.__asyncLoader;
+ if (asyncDef) {
+ asyncDef().then((def) => resolve(def, true));
+ } else {
+ resolve(this._def);
+ }
+ }
+ _resolveProps(def) {
+ const { props } = def;
+ const declaredPropKeys = shared.isArray(props) ? props : Object.keys(props || {});
+ for (const key of Object.keys(this)) {
+ if (key[0] !== "_" && declaredPropKeys.includes(key)) {
+ this._setProp(key, this[key], true, false);
+ }
+ }
+ for (const key of declaredPropKeys.map(shared.camelize)) {
+ Object.defineProperty(this, key, {
+ get() {
+ return this._getProp(key);
+ },
+ set(val) {
+ this._setProp(key, val);
+ }
+ });
+ }
+ }
+ _setAttr(key) {
+ let value = this.getAttribute(key);
+ const camelKey = shared.camelize(key);
+ if (this._numberProps && this._numberProps[camelKey]) {
+ value = shared.toNumber(value);
+ }
+ this._setProp(camelKey, value, false);
+ }
+ /**
+ * @internal
+ */
+ _getProp(key) {
+ return this._props[key];
+ }
+ /**
+ * @internal
+ */
+ _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
+ if (val !== this._props[key]) {
+ this._props[key] = val;
+ if (shouldUpdate && this._instance) {
+ this._update();
+ }
+ if (shouldReflect) {
+ if (val === true) {
+ this.setAttribute(shared.hyphenate(key), "");
+ } else if (typeof val === "string" || typeof val === "number") {
+ this.setAttribute(shared.hyphenate(key), val + "");
+ } else if (!val) {
+ this.removeAttribute(shared.hyphenate(key));
+ }
+ }
+ }
+ }
+ _update() {
+ render(this._createVNode(), this.shadowRoot);
+ }
+ _createVNode() {
+ const vnode = runtimeCore.createVNode(this._def, shared.extend({}, this._props));
+ if (!this._instance) {
+ vnode.ce = (instance) => {
+ this._instance = instance;
+ instance.isCE = true;
+ const dispatch = (event, args) => {
+ this.dispatchEvent(
+ new CustomEvent(event, {
+ detail: args
+ })
+ );
+ };
+ instance.emit = (event, ...args) => {
+ dispatch(event, args);
+ if (shared.hyphenate(event) !== event) {
+ dispatch(shared.hyphenate(event), args);
+ }
+ };
+ let parent = this;
+ while (parent = parent && (parent.parentNode || parent.host)) {
+ if (parent instanceof VueElement) {
+ instance.parent = parent._instance;
+ instance.provides = parent._instance.provides;
+ break;
+ }
+ }
+ };
+ }
+ return vnode;
+ }
+ _applyStyles(styles) {
+ if (styles) {
+ styles.forEach((css) => {
+ const s = document.createElement("style");
+ s.textContent = css;
+ this.shadowRoot.appendChild(s);
+ });
+ }
+ }
+}
+
+function useCssModule(name = "$style") {
+ {
+ const instance = runtimeCore.getCurrentInstance();
+ if (!instance) {
+ return shared.EMPTY_OBJ;
+ }
+ const modules = instance.type.__cssModules;
+ if (!modules) {
+ return shared.EMPTY_OBJ;
+ }
+ const mod = modules[name];
+ if (!mod) {
+ return shared.EMPTY_OBJ;
+ }
+ return mod;
+ }
+}
+
+function useCssVars(getter) {
+ return;
+}
+
+const positionMap = /* @__PURE__ */ new WeakMap();
+const newPositionMap = /* @__PURE__ */ new WeakMap();
+const moveCbKey = Symbol("_moveCb");
+const enterCbKey = Symbol("_enterCb");
+const TransitionGroupImpl = {
+ name: "TransitionGroup",
+ props: /* @__PURE__ */ shared.extend({}, TransitionPropsValidators, {
+ tag: String,
+ moveClass: String
+ }),
+ setup(props, { slots }) {
+ const instance = runtimeCore.getCurrentInstance();
+ const state = runtimeCore.useTransitionState();
+ let prevChildren;
+ let children;
+ runtimeCore.onUpdated(() => {
+ if (!prevChildren.length) {
+ return;
+ }
+ const moveClass = props.moveClass || `${props.name || "v"}-move`;
+ if (!hasCSSTransform(
+ prevChildren[0].el,
+ instance.vnode.el,
+ moveClass
+ )) {
+ return;
+ }
+ prevChildren.forEach(callPendingCbs);
+ prevChildren.forEach(recordPosition);
+ const movedChildren = prevChildren.filter(applyTranslation);
+ forceReflow();
+ movedChildren.forEach((c) => {
+ const el = c.el;
+ const style = el.style;
+ addTransitionClass(el, moveClass);
+ style.transform = style.webkitTransform = style.transitionDuration = "";
+ const cb = el[moveCbKey] = (e) => {
+ if (e && e.target !== el) {
+ return;
+ }
+ if (!e || /transform$/.test(e.propertyName)) {
+ el.removeEventListener("transitionend", cb);
+ el[moveCbKey] = null;
+ removeTransitionClass(el, moveClass);
+ }
+ };
+ el.addEventListener("transitionend", cb);
+ });
+ });
+ return () => {
+ const rawProps = runtimeCore.toRaw(props);
+ const cssTransitionProps = resolveTransitionProps(rawProps);
+ let tag = rawProps.tag || runtimeCore.Fragment;
+ prevChildren = children;
+ children = slots.default ? runtimeCore.getTransitionRawChildren(slots.default()) : [];
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (child.key != null) {
+ runtimeCore.setTransitionHooks(
+ child,
+ runtimeCore.resolveTransitionHooks(child, cssTransitionProps, state, instance)
+ );
+ }
+ }
+ if (prevChildren) {
+ for (let i = 0; i < prevChildren.length; i++) {
+ const child = prevChildren[i];
+ runtimeCore.setTransitionHooks(
+ child,
+ runtimeCore.resolveTransitionHooks(child, cssTransitionProps, state, instance)
+ );
+ positionMap.set(child, child.el.getBoundingClientRect());
+ }
+ }
+ return runtimeCore.createVNode(tag, null, children);
+ };
+ }
+};
+const removeMode = (props) => delete props.mode;
+/* @__PURE__ */ removeMode(TransitionGroupImpl.props);
+const TransitionGroup = TransitionGroupImpl;
+function callPendingCbs(c) {
+ const el = c.el;
+ if (el[moveCbKey]) {
+ el[moveCbKey]();
+ }
+ if (el[enterCbKey]) {
+ el[enterCbKey]();
+ }
+}
+function recordPosition(c) {
+ newPositionMap.set(c, c.el.getBoundingClientRect());
+}
+function applyTranslation(c) {
+ const oldPos = positionMap.get(c);
+ const newPos = newPositionMap.get(c);
+ const dx = oldPos.left - newPos.left;
+ const dy = oldPos.top - newPos.top;
+ if (dx || dy) {
+ const s = c.el.style;
+ s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+ s.transitionDuration = "0s";
+ return c;
+ }
+}
+function hasCSSTransform(el, root, moveClass) {
+ const clone = el.cloneNode();
+ const _vtc = el[vtcKey];
+ if (_vtc) {
+ _vtc.forEach((cls) => {
+ cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
+ });
+ }
+ moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
+ clone.style.display = "none";
+ const container = root.nodeType === 1 ? root : root.parentNode;
+ container.appendChild(clone);
+ const { hasTransform } = getTransitionInfo(clone);
+ container.removeChild(clone);
+ return hasTransform;
+}
+
+const getModelAssigner = (vnode) => {
+ const fn = vnode.props["onUpdate:modelValue"] || false;
+ return shared.isArray(fn) ? (value) => shared.invokeArrayFns(fn, value) : fn;
+};
+function onCompositionStart(e) {
+ e.target.composing = true;
+}
+function onCompositionEnd(e) {
+ const target = e.target;
+ if (target.composing) {
+ target.composing = false;
+ target.dispatchEvent(new Event("input"));
+ }
+}
+const assignKey = Symbol("_assign");
+const vModelText = {
+ created(el, { modifiers: { lazy, trim, number } }, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ const castToNumber = number || vnode.props && vnode.props.type === "number";
+ addEventListener(el, lazy ? "change" : "input", (e) => {
+ if (e.target.composing)
+ return;
+ let domValue = el.value;
+ if (trim) {
+ domValue = domValue.trim();
+ }
+ if (castToNumber) {
+ domValue = shared.looseToNumber(domValue);
+ }
+ el[assignKey](domValue);
+ });
+ if (trim) {
+ addEventListener(el, "change", () => {
+ el.value = el.value.trim();
+ });
+ }
+ if (!lazy) {
+ addEventListener(el, "compositionstart", onCompositionStart);
+ addEventListener(el, "compositionend", onCompositionEnd);
+ addEventListener(el, "change", onCompositionEnd);
+ }
+ },
+ // set value on mounted so it's after min/max for type="range"
+ mounted(el, { value }) {
+ el.value = value == null ? "" : value;
+ },
+ beforeUpdate(el, { value, modifiers: { lazy, trim, number } }, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ if (el.composing)
+ return;
+ const elValue = number || el.type === "number" ? shared.looseToNumber(el.value) : el.value;
+ const newValue = value == null ? "" : value;
+ if (elValue === newValue) {
+ return;
+ }
+ if (document.activeElement === el && el.type !== "range") {
+ if (lazy) {
+ return;
+ }
+ if (trim && el.value.trim() === newValue) {
+ return;
+ }
+ }
+ el.value = newValue;
+ }
+};
+const vModelCheckbox = {
+ // #4096 array checkboxes need to be deep traversed
+ deep: true,
+ created(el, _, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ addEventListener(el, "change", () => {
+ const modelValue = el._modelValue;
+ const elementValue = getValue(el);
+ const checked = el.checked;
+ const assign = el[assignKey];
+ if (shared.isArray(modelValue)) {
+ const index = shared.looseIndexOf(modelValue, elementValue);
+ const found = index !== -1;
+ if (checked && !found) {
+ assign(modelValue.concat(elementValue));
+ } else if (!checked && found) {
+ const filtered = [...modelValue];
+ filtered.splice(index, 1);
+ assign(filtered);
+ }
+ } else if (shared.isSet(modelValue)) {
+ const cloned = new Set(modelValue);
+ if (checked) {
+ cloned.add(elementValue);
+ } else {
+ cloned.delete(elementValue);
+ }
+ assign(cloned);
+ } else {
+ assign(getCheckboxValue(el, checked));
+ }
+ });
+ },
+ // set initial checked on mount to wait for true-value/false-value
+ mounted: setChecked,
+ beforeUpdate(el, binding, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ setChecked(el, binding, vnode);
+ }
+};
+function setChecked(el, { value, oldValue }, vnode) {
+ el._modelValue = value;
+ if (shared.isArray(value)) {
+ el.checked = shared.looseIndexOf(value, vnode.props.value) > -1;
+ } else if (shared.isSet(value)) {
+ el.checked = value.has(vnode.props.value);
+ } else if (value !== oldValue) {
+ el.checked = shared.looseEqual(value, getCheckboxValue(el, true));
+ }
+}
+const vModelRadio = {
+ created(el, { value }, vnode) {
+ el.checked = shared.looseEqual(value, vnode.props.value);
+ el[assignKey] = getModelAssigner(vnode);
+ addEventListener(el, "change", () => {
+ el[assignKey](getValue(el));
+ });
+ },
+ beforeUpdate(el, { value, oldValue }, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ if (value !== oldValue) {
+ el.checked = shared.looseEqual(value, vnode.props.value);
+ }
+ }
+};
+const vModelSelect = {
+ // <select multiple> value need to be deep traversed
+ deep: true,
+ created(el, { value, modifiers: { number } }, vnode) {
+ const isSetModel = shared.isSet(value);
+ addEventListener(el, "change", () => {
+ const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
+ (o) => number ? shared.looseToNumber(getValue(o)) : getValue(o)
+ );
+ el[assignKey](
+ el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
+ );
+ });
+ el[assignKey] = getModelAssigner(vnode);
+ },
+ // set value in mounted & updated because <select> relies on its children
+ // <option>s.
+ mounted(el, { value }) {
+ setSelected(el, value);
+ },
+ beforeUpdate(el, _binding, vnode) {
+ el[assignKey] = getModelAssigner(vnode);
+ },
+ updated(el, { value }) {
+ setSelected(el, value);
+ }
+};
+function setSelected(el, value) {
+ const isMultiple = el.multiple;
+ if (isMultiple && !shared.isArray(value) && !shared.isSet(value)) {
+ return;
+ }
+ for (let i = 0, l = el.options.length; i < l; i++) {
+ const option = el.options[i];
+ const optionValue = getValue(option);
+ if (isMultiple) {
+ if (shared.isArray(value)) {
+ option.selected = shared.looseIndexOf(value, optionValue) > -1;
+ } else {
+ option.selected = value.has(optionValue);
+ }
+ } else {
+ if (shared.looseEqual(getValue(option), value)) {
+ if (el.selectedIndex !== i)
+ el.selectedIndex = i;
+ return;
+ }
+ }
+ }
+ if (!isMultiple && el.selectedIndex !== -1) {
+ el.selectedIndex = -1;
+ }
+}
+function getValue(el) {
+ return "_value" in el ? el._value : el.value;
+}
+function getCheckboxValue(el, checked) {
+ const key = checked ? "_trueValue" : "_falseValue";
+ return key in el ? el[key] : checked;
+}
+const vModelDynamic = {
+ created(el, binding, vnode) {
+ callModelHook(el, binding, vnode, null, "created");
+ },
+ mounted(el, binding, vnode) {
+ callModelHook(el, binding, vnode, null, "mounted");
+ },
+ beforeUpdate(el, binding, vnode, prevVNode) {
+ callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+ },
+ updated(el, binding, vnode, prevVNode) {
+ callModelHook(el, binding, vnode, prevVNode, "updated");
+ }
+};
+function resolveDynamicModel(tagName, type) {
+ switch (tagName) {
+ case "SELECT":
+ return vModelSelect;
+ case "TEXTAREA":
+ return vModelText;
+ default:
+ switch (type) {
+ case "checkbox":
+ return vModelCheckbox;
+ case "radio":
+ return vModelRadio;
+ default:
+ return vModelText;
+ }
+ }
+}
+function callModelHook(el, binding, vnode, prevVNode, hook) {
+ const modelToUse = resolveDynamicModel(
+ el.tagName,
+ vnode.props && vnode.props.type
+ );
+ const fn = modelToUse[hook];
+ fn && fn(el, binding, vnode, prevVNode);
+}
+function initVModelForSSR() {
+ vModelText.getSSRProps = ({ value }) => ({ value });
+ vModelRadio.getSSRProps = ({ value }, vnode) => {
+ if (vnode.props && shared.looseEqual(vnode.props.value, value)) {
+ return { checked: true };
+ }
+ };
+ vModelCheckbox.getSSRProps = ({ value }, vnode) => {
+ if (shared.isArray(value)) {
+ if (vnode.props && shared.looseIndexOf(value, vnode.props.value) > -1) {
+ return { checked: true };
+ }
+ } else if (shared.isSet(value)) {
+ if (vnode.props && value.has(vnode.props.value)) {
+ return { checked: true };
+ }
+ } else if (value) {
+ return { checked: true };
+ }
+ };
+ vModelDynamic.getSSRProps = (binding, vnode) => {
+ if (typeof vnode.type !== "string") {
+ return;
+ }
+ const modelToUse = resolveDynamicModel(
+ // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
+ vnode.type.toUpperCase(),
+ vnode.props && vnode.props.type
+ );
+ if (modelToUse.getSSRProps) {
+ return modelToUse.getSSRProps(binding, vnode);
+ }
+ };
+}
+
+const systemModifiers = ["ctrl", "shift", "alt", "meta"];
+const modifierGuards = {
+ stop: (e) => e.stopPropagation(),
+ prevent: (e) => e.preventDefault(),
+ self: (e) => e.target !== e.currentTarget,
+ ctrl: (e) => !e.ctrlKey,
+ shift: (e) => !e.shiftKey,
+ alt: (e) => !e.altKey,
+ meta: (e) => !e.metaKey,
+ left: (e) => "button" in e && e.button !== 0,
+ middle: (e) => "button" in e && e.button !== 1,
+ right: (e) => "button" in e && e.button !== 2,
+ exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
+};
+const withModifiers = (fn, modifiers) => {
+ return (event, ...args) => {
+ for (let i = 0; i < modifiers.length; i++) {
+ const guard = modifierGuards[modifiers[i]];
+ if (guard && guard(event, modifiers))
+ return;
+ }
+ return fn(event, ...args);
+ };
+};
+const keyNames = {
+ esc: "escape",
+ space: " ",
+ up: "arrow-up",
+ left: "arrow-left",
+ right: "arrow-right",
+ down: "arrow-down",
+ delete: "backspace"
+};
+const withKeys = (fn, modifiers) => {
+ return (event) => {
+ if (!("key" in event)) {
+ return;
+ }
+ const eventKey = shared.hyphenate(event.key);
+ if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {
+ return fn(event);
+ }
+ };
+};
+
+const rendererOptions = /* @__PURE__ */ shared.extend({ patchProp }, nodeOps);
+let renderer;
+let enabledHydration = false;
+function ensureRenderer() {
+ return renderer || (renderer = runtimeCore.createRenderer(rendererOptions));
+}
+function ensureHydrationRenderer() {
+ renderer = enabledHydration ? renderer : runtimeCore.createHydrationRenderer(rendererOptions);
+ enabledHydration = true;
+ return renderer;
+}
+const render = (...args) => {
+ ensureRenderer().render(...args);
+};
+const hydrate = (...args) => {
+ ensureHydrationRenderer().hydrate(...args);
+};
+const createApp = (...args) => {
+ const app = ensureRenderer().createApp(...args);
+ const { mount } = app;
+ app.mount = (containerOrSelector) => {
+ const container = normalizeContainer(containerOrSelector);
+ if (!container)
+ return;
+ const component = app._component;
+ if (!shared.isFunction(component) && !component.render && !component.template) {
+ component.template = container.innerHTML;
+ }
+ container.innerHTML = "";
+ const proxy = mount(container, false, container instanceof SVGElement);
+ if (container instanceof Element) {
+ container.removeAttribute("v-cloak");
+ container.setAttribute("data-v-app", "");
+ }
+ return proxy;
+ };
+ return app;
+};
+const createSSRApp = (...args) => {
+ const app = ensureHydrationRenderer().createApp(...args);
+ const { mount } = app;
+ app.mount = (containerOrSelector) => {
+ const container = normalizeContainer(containerOrSelector);
+ if (container) {
+ return mount(container, true, container instanceof SVGElement);
+ }
+ };
+ return app;
+};
+function normalizeContainer(container) {
+ if (shared.isString(container)) {
+ const res = document.querySelector(container);
+ return res;
+ }
+ return container;
+}
+let ssrDirectiveInitialized = false;
+const initDirectivesForSSR = () => {
+ if (!ssrDirectiveInitialized) {
+ ssrDirectiveInitialized = true;
+ initVModelForSSR();
+ initVShowForSSR();
+ }
+} ;
+
+exports.Transition = Transition;
+exports.TransitionGroup = TransitionGroup;
+exports.VueElement = VueElement;
+exports.createApp = createApp;
+exports.createSSRApp = createSSRApp;
+exports.defineCustomElement = defineCustomElement;
+exports.defineSSRCustomElement = defineSSRCustomElement;
+exports.hydrate = hydrate;
+exports.initDirectivesForSSR = initDirectivesForSSR;
+exports.render = render;
+exports.useCssModule = useCssModule;
+exports.useCssVars = useCssVars;
+exports.vModelCheckbox = vModelCheckbox;
+exports.vModelDynamic = vModelDynamic;
+exports.vModelRadio = vModelRadio;
+exports.vModelSelect = vModelSelect;
+exports.vModelText = vModelText;
+exports.vShow = vShow;
+exports.withKeys = withKeys;
+exports.withModifiers = withModifiers;
+Object.keys(runtimeCore).forEach(function (k) {
+ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeCore[k];
+});
diff --git a/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.js b/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.js
new file mode 100644
index 0000000..040e61c
--- /dev/null
+++ b/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.js
@@ -0,0 +1,1086 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Vue = require('vue');
+var shared = require('@vue/shared');
+var compilerSsr = require('@vue/compiler-ssr');
+
+function _interopNamespaceDefault(e) {
+ var n = Object.create(null);
+ if (e) {
+ for (var k in e) {
+ n[k] = e[k];
+ }
+ }
+ n.default = e;
+ return Object.freeze(n);
+}
+
+var Vue__namespace = /*#__PURE__*/_interopNamespaceDefault(Vue);
+
+const shouldIgnoreProp = shared.makeMap(
+ `,key,ref,innerHTML,textContent,ref_key,ref_for`
+);
+function ssrRenderAttrs(props, tag) {
+ let ret = "";
+ for (const key in props) {
+ if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value") {
+ continue;
+ }
+ const value = props[key];
+ if (key === "class") {
+ ret += ` class="${ssrRenderClass(value)}"`;
+ } else if (key === "style") {
+ ret += ` style="${ssrRenderStyle(value)}"`;
+ } else {
+ ret += ssrRenderDynamicAttr(key, value, tag);
+ }
+ }
+ return ret;
+}
+function ssrRenderDynamicAttr(key, value, tag) {
+ if (!isRenderableValue(value)) {
+ return ``;
+ }
+ const attrKey = tag && (tag.indexOf("-") > 0 || shared.isSVGTag(tag)) ? key : shared.propsToAttrMap[key] || key.toLowerCase();
+ if (shared.isBooleanAttr(attrKey)) {
+ return shared.includeBooleanAttr(value) ? ` ${attrKey}` : ``;
+ } else if (shared.isSSRSafeAttrName(attrKey)) {
+ return value === "" ? ` ${attrKey}` : ` ${attrKey}="${shared.escapeHtml(value)}"`;
+ } else {
+ console.warn(
+ `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
+ );
+ return ``;
+ }
+}
+function ssrRenderAttr(key, value) {
+ if (!isRenderableValue(value)) {
+ return ``;
+ }
+ return ` ${key}="${shared.escapeHtml(value)}"`;
+}
+function isRenderableValue(value) {
+ if (value == null) {
+ return false;
+ }
+ const type = typeof value;
+ return type === "string" || type === "number" || type === "boolean";
+}
+function ssrRenderClass(raw) {
+ return shared.escapeHtml(shared.normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+ if (!raw) {
+ return "";
+ }
+ if (shared.isString(raw)) {
+ return shared.escapeHtml(raw);
+ }
+ const styles = shared.normalizeStyle(raw);
+ return shared.escapeHtml(shared.stringifyStyle(styles));
+}
+
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
+ return renderComponentVNode(
+ Vue.createVNode(comp, props, children),
+ parentComponent,
+ slotScopeId
+ );
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
+ push(`<!--[-->`);
+ ssrRenderSlotInner(
+ slots,
+ slotName,
+ slotProps,
+ fallbackRenderFn,
+ push,
+ parentComponent,
+ slotScopeId
+ );
+ push(`<!--]-->`);
+}
+function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
+ const slotFn = slots[slotName];
+ if (slotFn) {
+ const slotBuffer = [];
+ const bufferedPush = (item) => {
+ slotBuffer.push(item);
+ };
+ const ret = slotFn(
+ slotProps,
+ bufferedPush,
+ parentComponent,
+ slotScopeId ? " " + slotScopeId : ""
+ );
+ if (shared.isArray(ret)) {
+ renderVNodeChildren(push, ret, parentComponent, slotScopeId);
+ } else {
+ let isEmptySlot = true;
+ if (transition) {
+ isEmptySlot = false;
+ } else {
+ for (let i = 0; i < slotBuffer.length; i++) {
+ if (!isComment(slotBuffer[i])) {
+ isEmptySlot = false;
+ break;
+ }
+ }
+ }
+ if (isEmptySlot) {
+ if (fallbackRenderFn) {
+ fallbackRenderFn();
+ }
+ } else {
+ for (let i = 0; i < slotBuffer.length; i++) {
+ push(slotBuffer[i]);
+ }
+ }
+ }
+ } else if (fallbackRenderFn) {
+ fallbackRenderFn();
+ }
+}
+const commentTestRE = /^<!--.*-->$/s;
+const commentRE = /<!--[^]*?-->/gm;
+function isComment(item) {
+ if (typeof item !== "string" || !commentTestRE.test(item))
+ return false;
+ if (item.length <= 8)
+ return true;
+ return !item.replace(commentRE, "").trim();
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+ parentPush("<!--teleport start-->");
+ const context = parentComponent.appContext.provides[Vue.ssrContextKey];
+ const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+ const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+ const bufferIndex = targetBuffer.length;
+ let teleportContent;
+ if (disabled) {
+ contentRenderFn(parentPush);
+ teleportContent = `<!--teleport anchor-->`;
+ } else {
+ const { getBuffer, push } = createBuffer();
+ contentRenderFn(push);
+ push(`<!--teleport anchor-->`);
+ teleportContent = getBuffer();
+ }
+ targetBuffer.splice(bufferIndex, 0, teleportContent);
+ parentPush("<!--teleport end-->");
+}
+
+function ssrInterpolate(value) {
+ return shared.escapeHtml(shared.toDisplayString(value));
+}
+
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+ trackStack.push(shouldTrack);
+ shouldTrack = false;
+}
+function resetTracking() {
+ const last = trackStack.pop();
+ shouldTrack = last === void 0 ? true : last;
+}
+
+function toRaw(observed) {
+ const raw = observed && observed["__v_raw"];
+ return raw ? toRaw(raw) : observed;
+}
+
+function isRef(r) {
+ return !!(r && r.__v_isRef === true);
+}
+
+const stack = [];
+function pushWarningContext(vnode) {
+ stack.push(vnode);
+}
+function popWarningContext() {
+ stack.pop();
+}
+function warn(msg, ...args) {
+ pauseTracking();
+ const instance = stack.length ? stack[stack.length - 1].component : null;
+ const appWarnHandler = instance && instance.appContext.config.warnHandler;
+ const trace = getComponentTrace();
+ if (appWarnHandler) {
+ callWithErrorHandling(
+ appWarnHandler,
+ instance,
+ 11,
+ [
+ msg + args.join(""),
+ instance && instance.proxy,
+ trace.map(
+ ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+ ).join("\n"),
+ trace
+ ]
+ );
+ } else {
+ const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+ if (trace.length && // avoid spamming console during tests
+ true) {
+ warnArgs.push(`
+`, ...formatTrace(trace));
+ }
+ console.warn(...warnArgs);
+ }
+ resetTracking();
+}
+function getComponentTrace() {
+ let currentVNode = stack[stack.length - 1];
+ if (!currentVNode) {
+ return [];
+ }
+ const normalizedStack = [];
+ while (currentVNode) {
+ const last = normalizedStack[0];
+ if (last && last.vnode === currentVNode) {
+ last.recurseCount++;
+ } else {
+ normalizedStack.push({
+ vnode: currentVNode,
+ recurseCount: 0
+ });
+ }
+ const parentInstance = currentVNode.component && currentVNode.component.parent;
+ currentVNode = parentInstance && parentInstance.vnode;
+ }
+ return normalizedStack;
+}
+function formatTrace(trace) {
+ const logs = [];
+ trace.forEach((entry, i) => {
+ logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+ });
+ return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+ const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+ const isRoot = vnode.component ? vnode.component.parent == null : false;
+ const open = ` at <${formatComponentName(
+ vnode.component,
+ vnode.type,
+ isRoot
+ )}`;
+ const close = `>` + postfix;
+ return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+ const res = [];
+ const keys = Object.keys(props);
+ keys.slice(0, 3).forEach((key) => {
+ res.push(...formatProp(key, props[key]));
+ });
+ if (keys.length > 3) {
+ res.push(` ...`);
+ }
+ return res;
+}
+function formatProp(key, value, raw) {
+ if (shared.isString(value)) {
+ value = JSON.stringify(value);
+ return raw ? value : [`${key}=${value}`];
+ } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+ return raw ? value : [`${key}=${value}`];
+ } else if (isRef(value)) {
+ value = formatProp(key, toRaw(value.value), true);
+ return raw ? value : [`${key}=Ref<`, value, `>`];
+ } else if (shared.isFunction(value)) {
+ return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+ } else {
+ value = toRaw(value);
+ return raw ? value : [`${key}=`, value];
+ }
+}
+
+const ErrorTypeStrings = {
+ ["sp"]: "serverPrefetch hook",
+ ["bc"]: "beforeCreate hook",
+ ["c"]: "created hook",
+ ["bm"]: "beforeMount hook",
+ ["m"]: "mounted hook",
+ ["bu"]: "beforeUpdate hook",
+ ["u"]: "updated",
+ ["bum"]: "beforeUnmount hook",
+ ["um"]: "unmounted hook",
+ ["a"]: "activated hook",
+ ["da"]: "deactivated hook",
+ ["ec"]: "errorCaptured hook",
+ ["rtc"]: "renderTracked hook",
+ ["rtg"]: "renderTriggered hook",
+ [0]: "setup function",
+ [1]: "render function",
+ [2]: "watcher getter",
+ [3]: "watcher callback",
+ [4]: "watcher cleanup function",
+ [5]: "native event handler",
+ [6]: "component event handler",
+ [7]: "vnode hook",
+ [8]: "directive hook",
+ [9]: "transition hook",
+ [10]: "app errorHandler",
+ [11]: "app warnHandler",
+ [12]: "ref function",
+ [13]: "async component loader",
+ [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+ let res;
+ try {
+ res = args ? fn(...args) : fn();
+ } catch (err) {
+ handleError(err, instance, type);
+ }
+ return res;
+}
+function handleError(err, instance, type, throwInDev = true) {
+ const contextVNode = instance ? instance.vnode : null;
+ if (instance) {
+ let cur = instance.parent;
+ const exposedInstance = instance.proxy;
+ const errorInfo = ErrorTypeStrings[type] ;
+ while (cur) {
+ const errorCapturedHooks = cur.ec;
+ if (errorCapturedHooks) {
+ for (let i = 0; i < errorCapturedHooks.length; i++) {
+ if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+ return;
+ }
+ }
+ }
+ cur = cur.parent;
+ }
+ const appErrorHandler = instance.appContext.config.errorHandler;
+ if (appErrorHandler) {
+ callWithErrorHandling(
+ appErrorHandler,
+ null,
+ 10,
+ [err, exposedInstance, errorInfo]
+ );
+ return;
+ }
+ }
+ logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+ {
+ const info = ErrorTypeStrings[type];
+ if (contextVNode) {
+ pushWarningContext(contextVNode);
+ }
+ warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+ if (contextVNode) {
+ popWarningContext();
+ }
+ if (throwInDev) {
+ throw err;
+ } else {
+ console.error(err);
+ }
+ }
+}
+
+let globalCurrentInstanceSetters;
+let settersKey = "__VUE_INSTANCE_SETTERS__";
+{
+ if (!(globalCurrentInstanceSetters = shared.getGlobalThis()[settersKey])) {
+ globalCurrentInstanceSetters = shared.getGlobalThis()[settersKey] = [];
+ }
+ globalCurrentInstanceSetters.push((i) => i);
+}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+ return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+ let name = getComponentName(Component);
+ if (!name && Component.__file) {
+ const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+ if (match) {
+ name = match[1];
+ }
+ }
+ if (!name && instance && instance.parent) {
+ const inferFromRegistry = (registry) => {
+ for (const key in registry) {
+ if (registry[key] === Component) {
+ return key;
+ }
+ }
+ };
+ name = inferFromRegistry(
+ instance.components || instance.parent.type.components
+ ) || inferFromRegistry(instance.appContext.components);
+ }
+ return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+
+function ssrRenderList(source, renderItem) {
+ if (shared.isArray(source) || shared.isString(source)) {
+ for (let i = 0, l = source.length; i < l; i++) {
+ renderItem(source[i], i);
+ }
+ } else if (typeof source === "number") {
+ if (!Number.isInteger(source)) {
+ warn(`The v-for range expect an integer value but got ${source}.`);
+ return;
+ }
+ for (let i = 0; i < source; i++) {
+ renderItem(i + 1, i);
+ }
+ } else if (shared.isObject(source)) {
+ if (source[Symbol.iterator]) {
+ const arr = Array.from(source);
+ for (let i = 0, l = arr.length; i < l; i++) {
+ renderItem(arr[i], i);
+ }
+ } else {
+ const keys = Object.keys(source);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ const key = keys[i];
+ renderItem(source[key], key, i);
+ }
+ }
+ }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+ if (renderContent) {
+ renderContent();
+ } else {
+ push(`<!---->`);
+ }
+}
+
+function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
+ if (typeof dir !== "function" && dir.getSSRProps) {
+ return dir.getSSRProps(
+ {
+ dir,
+ instance,
+ value,
+ oldValue: void 0,
+ arg,
+ modifiers
+ },
+ null
+ ) || {};
+ }
+ return {};
+}
+
+const ssrLooseEqual = shared.looseEqual;
+function ssrLooseContain(arr, value) {
+ return shared.looseIndexOf(arr, value) > -1;
+}
+function ssrRenderDynamicModel(type, model, value) {
+ switch (type) {
+ case "radio":
+ return shared.looseEqual(model, value) ? " checked" : "";
+ case "checkbox":
+ return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
+ default:
+ return ssrRenderAttr("value", model);
+ }
+}
+function ssrGetDynamicModelProps(existingProps = {}, model) {
+ const { type, value } = existingProps;
+ switch (type) {
+ case "radio":
+ return shared.looseEqual(model, value) ? { checked: true } : null;
+ case "checkbox":
+ return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
+ default:
+ return { value: model };
+ }
+}
+
+var helpers = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ ssrGetDirectiveProps: ssrGetDirectiveProps,
+ ssrGetDynamicModelProps: ssrGetDynamicModelProps,
+ ssrIncludeBooleanAttr: shared.includeBooleanAttr,
+ ssrInterpolate: ssrInterpolate,
+ ssrLooseContain: ssrLooseContain,
+ ssrLooseEqual: ssrLooseEqual,
+ ssrRenderAttr: ssrRenderAttr,
+ ssrRenderAttrs: ssrRenderAttrs,
+ ssrRenderClass: ssrRenderClass,
+ ssrRenderComponent: ssrRenderComponent,
+ ssrRenderDynamicAttr: ssrRenderDynamicAttr,
+ ssrRenderDynamicModel: ssrRenderDynamicModel,
+ ssrRenderList: ssrRenderList,
+ ssrRenderSlot: ssrRenderSlot,
+ ssrRenderSlotInner: ssrRenderSlotInner,
+ ssrRenderStyle: ssrRenderStyle,
+ ssrRenderSuspense: ssrRenderSuspense,
+ ssrRenderTeleport: ssrRenderTeleport,
+ ssrRenderVNode: renderVNode
+});
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function ssrCompile(template, instance) {
+ const Component = instance.type;
+ const { isCustomElement, compilerOptions } = instance.appContext.config;
+ const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+ const finalCompilerOptions = shared.extend(
+ shared.extend(
+ {
+ isCustomElement,
+ delimiters
+ },
+ compilerOptions
+ ),
+ componentCompilerOptions
+ );
+ finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO;
+ finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO;
+ const cacheKey = JSON.stringify(
+ {
+ template,
+ compilerOptions: finalCompilerOptions
+ },
+ (key, value) => {
+ return shared.isFunction(value) ? value.toString() : value;
+ }
+ );
+ const cached = compileCache[cacheKey];
+ if (cached) {
+ return cached;
+ }
+ finalCompilerOptions.onError = (err) => {
+ {
+ const message = `[@vue/server-renderer] Template compilation error: ${err.message}`;
+ const codeFrame = err.loc && shared.generateCodeFrame(
+ template,
+ err.loc.start.offset,
+ err.loc.end.offset
+ );
+ Vue.warn(codeFrame ? `${message}
+${codeFrame}` : message);
+ }
+ };
+ const { code } = compilerSsr.compile(template, finalCompilerOptions);
+ const requireMap = {
+ vue: Vue__namespace,
+ "vue/server-renderer": helpers
+ };
+ const fakeRequire = (id) => requireMap[id];
+ return compileCache[cacheKey] = Function("require", code)(fakeRequire);
+}
+
+const {
+ createComponentInstance,
+ setCurrentRenderingInstance,
+ setupComponent,
+ renderComponentRoot,
+ normalizeVNode
+} = Vue.ssrUtils;
+function createBuffer() {
+ let appendable = false;
+ const buffer = [];
+ return {
+ getBuffer() {
+ return buffer;
+ },
+ push(item) {
+ const isStringItem = shared.isString(item);
+ if (appendable && isStringItem) {
+ buffer[buffer.length - 1] += item;
+ } else {
+ buffer.push(item);
+ }
+ appendable = isStringItem;
+ if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) {
+ buffer.hasAsync = true;
+ }
+ }
+ };
+}
+function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
+ const instance = createComponentInstance(vnode, parentComponent, null);
+ const res = setupComponent(
+ instance,
+ true
+ /* isSSR */
+ );
+ const hasAsyncSetup = shared.isPromise(res);
+ const prefetches = instance.sp;
+ if (hasAsyncSetup || prefetches) {
+ let p = hasAsyncSetup ? res : Promise.resolve();
+ if (prefetches) {
+ p = p.then(
+ () => Promise.all(prefetches.map((prefetch) => prefetch.call(instance.proxy)))
+ ).catch(() => {
+ });
+ }
+ return p.then(() => renderComponentSubTree(instance, slotScopeId));
+ } else {
+ return renderComponentSubTree(instance, slotScopeId);
+ }
+}
+function renderComponentSubTree(instance, slotScopeId) {
+ const comp = instance.type;
+ const { getBuffer, push } = createBuffer();
+ if (shared.isFunction(comp)) {
+ let root = renderComponentRoot(instance);
+ if (!comp.props) {
+ for (const key in instance.attrs) {
+ if (key.startsWith(`data-v-`)) {
+ (root.props || (root.props = {}))[key] = ``;
+ }
+ }
+ }
+ renderVNode(push, instance.subTree = root, instance, slotScopeId);
+ } else {
+ if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) {
+ comp.ssrRender = ssrCompile(comp.template, instance);
+ }
+ for (const e of instance.scope.effects) {
+ if (e.computed)
+ e.computed._cacheable = true;
+ }
+ const ssrRender = instance.ssrRender || comp.ssrRender;
+ if (ssrRender) {
+ let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
+ let hasCloned = false;
+ let cur = instance;
+ while (true) {
+ const scopeId = cur.vnode.scopeId;
+ if (scopeId) {
+ if (!hasCloned) {
+ attrs = { ...attrs };
+ hasCloned = true;
+ }
+ attrs[scopeId] = "";
+ }
+ const parent = cur.parent;
+ if (parent && parent.subTree && parent.subTree === cur.vnode) {
+ cur = parent;
+ } else {
+ break;
+ }
+ }
+ if (slotScopeId) {
+ if (!hasCloned)
+ attrs = { ...attrs };
+ attrs[slotScopeId.trim()] = "";
+ }
+ const prev = setCurrentRenderingInstance(instance);
+ try {
+ ssrRender(
+ instance.proxy,
+ push,
+ instance,
+ attrs,
+ // compiler-optimized bindings
+ instance.props,
+ instance.setupState,
+ instance.data,
+ instance.ctx
+ );
+ } finally {
+ setCurrentRenderingInstance(prev);
+ }
+ } else if (instance.render && instance.render !== shared.NOOP) {
+ renderVNode(
+ push,
+ instance.subTree = renderComponentRoot(instance),
+ instance,
+ slotScopeId
+ );
+ } else {
+ const componentName = comp.name || comp.__file || `<Anonymous>`;
+ Vue.warn(`Component ${componentName} is missing template or render function.`);
+ push(`<!---->`);
+ }
+ }
+ return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent, slotScopeId) {
+ const { type, shapeFlag, children } = vnode;
+ switch (type) {
+ case Vue.Text:
+ push(shared.escapeHtml(children));
+ break;
+ case Vue.Comment:
+ push(
+ children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`
+ );
+ break;
+ case Vue.Static:
+ push(children);
+ break;
+ case Vue.Fragment:
+ if (vnode.slotScopeIds) {
+ slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
+ }
+ push(`<!--[-->`);
+ renderVNodeChildren(
+ push,
+ children,
+ parentComponent,
+ slotScopeId
+ );
+ push(`<!--]-->`);
+ break;
+ default:
+ if (shapeFlag & 1) {
+ renderElementVNode(push, vnode, parentComponent, slotScopeId);
+ } else if (shapeFlag & 6) {
+ push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+ } else if (shapeFlag & 64) {
+ renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+ } else if (shapeFlag & 128) {
+ renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+ } else {
+ Vue.warn(
+ "[@vue/server-renderer] Invalid VNode type:",
+ type,
+ `(${typeof type})`
+ );
+ }
+ }
+}
+function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+ for (let i = 0; i < children.length; i++) {
+ renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+ }
+}
+function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
+ const tag = vnode.type;
+ let { props, children, shapeFlag, scopeId, dirs } = vnode;
+ let openTag = `<${tag}`;
+ if (dirs) {
+ props = applySSRDirectives(vnode, props, dirs);
+ }
+ if (props) {
+ openTag += ssrRenderAttrs(props, tag);
+ }
+ if (scopeId) {
+ openTag += ` ${scopeId}`;
+ }
+ let curParent = parentComponent;
+ let curVnode = vnode;
+ while (curParent && curVnode === curParent.subTree) {
+ curVnode = curParent.vnode;
+ if (curVnode.scopeId) {
+ openTag += ` ${curVnode.scopeId}`;
+ }
+ curParent = curParent.parent;
+ }
+ if (slotScopeId) {
+ openTag += ` ${slotScopeId}`;
+ }
+ push(openTag + `>`);
+ if (!shared.isVoidTag(tag)) {
+ let hasChildrenOverride = false;
+ if (props) {
+ if (props.innerHTML) {
+ hasChildrenOverride = true;
+ push(props.innerHTML);
+ } else if (props.textContent) {
+ hasChildrenOverride = true;
+ push(shared.escapeHtml(props.textContent));
+ } else if (tag === "textarea" && props.value) {
+ hasChildrenOverride = true;
+ push(shared.escapeHtml(props.value));
+ }
+ }
+ if (!hasChildrenOverride) {
+ if (shapeFlag & 8) {
+ push(shared.escapeHtml(children));
+ } else if (shapeFlag & 16) {
+ renderVNodeChildren(
+ push,
+ children,
+ parentComponent,
+ slotScopeId
+ );
+ }
+ }
+ push(`</${tag}>`);
+ }
+}
+function applySSRDirectives(vnode, rawProps, dirs) {
+ const toMerge = [];
+ for (let i = 0; i < dirs.length; i++) {
+ const binding = dirs[i];
+ const {
+ dir: { getSSRProps }
+ } = binding;
+ if (getSSRProps) {
+ const props = getSSRProps(binding, vnode);
+ if (props)
+ toMerge.push(props);
+ }
+ }
+ return Vue.mergeProps(rawProps || {}, ...toMerge);
+}
+function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
+ const target = vnode.props && vnode.props.to;
+ const disabled = vnode.props && vnode.props.disabled;
+ if (!target) {
+ if (!disabled) {
+ Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
+ }
+ return [];
+ }
+ if (!shared.isString(target)) {
+ Vue.warn(
+ `[@vue/server-renderer] Teleport target must be a query selector string.`
+ );
+ return [];
+ }
+ ssrRenderTeleport(
+ push,
+ (push2) => {
+ renderVNodeChildren(
+ push2,
+ vnode.children,
+ parentComponent,
+ slotScopeId
+ );
+ },
+ target,
+ disabled || disabled === "",
+ parentComponent
+ );
+}
+
+const { isVNode: isVNode$1 } = Vue.ssrUtils;
+async function unrollBuffer$1(buffer) {
+ if (buffer.hasAsync) {
+ let ret = "";
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isPromise(item)) {
+ item = await item;
+ }
+ if (shared.isString(item)) {
+ ret += item;
+ } else {
+ ret += await unrollBuffer$1(item);
+ }
+ }
+ return ret;
+ } else {
+ return unrollBufferSync$1(buffer);
+ }
+}
+function unrollBufferSync$1(buffer) {
+ let ret = "";
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isString(item)) {
+ ret += item;
+ } else {
+ ret += unrollBufferSync$1(item);
+ }
+ }
+ return ret;
+}
+async function renderToString(input, context = {}) {
+ if (isVNode$1(input)) {
+ return renderToString(Vue.createApp({ render: () => input }), context);
+ }
+ const vnode = Vue.createVNode(input._component, input._props);
+ vnode.appContext = input._context;
+ input.provide(Vue.ssrContextKey, context);
+ const buffer = await renderComponentVNode(vnode);
+ const result = await unrollBuffer$1(buffer);
+ await resolveTeleports(context);
+ if (context.__watcherHandles) {
+ for (const unwatch of context.__watcherHandles) {
+ unwatch();
+ }
+ }
+ return result;
+}
+async function resolveTeleports(context) {
+ if (context.__teleportBuffers) {
+ context.teleports = context.teleports || {};
+ for (const key in context.__teleportBuffers) {
+ context.teleports[key] = await unrollBuffer$1(
+ await Promise.all([context.__teleportBuffers[key]])
+ );
+ }
+ }
+}
+
+const { isVNode } = Vue.ssrUtils;
+async function unrollBuffer(buffer, stream) {
+ if (buffer.hasAsync) {
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isPromise(item)) {
+ item = await item;
+ }
+ if (shared.isString(item)) {
+ stream.push(item);
+ } else {
+ await unrollBuffer(item, stream);
+ }
+ }
+ } else {
+ unrollBufferSync(buffer, stream);
+ }
+}
+function unrollBufferSync(buffer, stream) {
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isString(item)) {
+ stream.push(item);
+ } else {
+ unrollBufferSync(item, stream);
+ }
+ }
+}
+function renderToSimpleStream(input, context, stream) {
+ if (isVNode(input)) {
+ return renderToSimpleStream(
+ Vue.createApp({ render: () => input }),
+ context,
+ stream
+ );
+ }
+ const vnode = Vue.createVNode(input._component, input._props);
+ vnode.appContext = input._context;
+ input.provide(Vue.ssrContextKey, context);
+ Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
+ if (context.__watcherHandles) {
+ for (const unwatch of context.__watcherHandles) {
+ unwatch();
+ }
+ }
+ }).then(() => stream.push(null)).catch((error) => {
+ stream.destroy(error);
+ });
+ return stream;
+}
+function renderToStream(input, context = {}) {
+ console.warn(
+ `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`
+ );
+ return renderToNodeStream(input, context);
+}
+function renderToNodeStream(input, context = {}) {
+ const stream = new (require("stream")).Readable({ read() {
+ } }) ;
+ if (!stream) {
+ throw new Error(
+ `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
+ );
+ }
+ return renderToSimpleStream(input, context, stream);
+}
+function pipeToNodeWritable(input, context = {}, writable) {
+ renderToSimpleStream(input, context, {
+ push(content) {
+ if (content != null) {
+ writable.write(content);
+ } else {
+ writable.end();
+ }
+ },
+ destroy(err) {
+ writable.destroy(err);
+ }
+ });
+}
+function renderToWebStream(input, context = {}) {
+ if (typeof ReadableStream !== "function") {
+ throw new Error(
+ `ReadableStream constructor is not available in the global scope. If the target environment does support web streams, consider using pipeToWebWritable() with an existing WritableStream instance instead.`
+ );
+ }
+ const encoder = new TextEncoder();
+ let cancelled = false;
+ return new ReadableStream({
+ start(controller) {
+ renderToSimpleStream(input, context, {
+ push(content) {
+ if (cancelled)
+ return;
+ if (content != null) {
+ controller.enqueue(encoder.encode(content));
+ } else {
+ controller.close();
+ }
+ },
+ destroy(err) {
+ controller.error(err);
+ }
+ });
+ },
+ cancel() {
+ cancelled = true;
+ }
+ });
+}
+function pipeToWebWritable(input, context = {}, writable) {
+ const writer = writable.getWriter();
+ const encoder = new TextEncoder();
+ let hasReady = false;
+ try {
+ hasReady = shared.isPromise(writer.ready);
+ } catch (e) {
+ }
+ renderToSimpleStream(input, context, {
+ async push(content) {
+ if (hasReady) {
+ await writer.ready;
+ }
+ if (content != null) {
+ return writer.write(encoder.encode(content));
+ } else {
+ return writer.close();
+ }
+ },
+ destroy(err) {
+ console.log(err);
+ writer.close();
+ }
+ });
+}
+
+Vue.initDirectivesForSSR();
+
+exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
+exports.pipeToNodeWritable = pipeToNodeWritable;
+exports.pipeToWebWritable = pipeToWebWritable;
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToSimpleStream = renderToSimpleStream;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToWebStream = renderToWebStream;
+exports.ssrGetDirectiveProps = ssrGetDirectiveProps;
+exports.ssrGetDynamicModelProps = ssrGetDynamicModelProps;
+exports.ssrInterpolate = ssrInterpolate;
+exports.ssrLooseContain = ssrLooseContain;
+exports.ssrLooseEqual = ssrLooseEqual;
+exports.ssrRenderAttr = ssrRenderAttr;
+exports.ssrRenderAttrs = ssrRenderAttrs;
+exports.ssrRenderClass = ssrRenderClass;
+exports.ssrRenderComponent = ssrRenderComponent;
+exports.ssrRenderDynamicAttr = ssrRenderDynamicAttr;
+exports.ssrRenderDynamicModel = ssrRenderDynamicModel;
+exports.ssrRenderList = ssrRenderList;
+exports.ssrRenderSlot = ssrRenderSlot;
+exports.ssrRenderSlotInner = ssrRenderSlotInner;
+exports.ssrRenderStyle = ssrRenderStyle;
+exports.ssrRenderSuspense = ssrRenderSuspense;
+exports.ssrRenderTeleport = ssrRenderTeleport;
+exports.ssrRenderVNode = renderVNode;
diff --git a/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.prod.js b/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.prod.js
new file mode 100644
index 0000000..bc53616
--- /dev/null
+++ b/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.prod.js
@@ -0,0 +1,826 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Vue = require('vue');
+var shared = require('@vue/shared');
+var compilerSsr = require('@vue/compiler-ssr');
+
+function _interopNamespaceDefault(e) {
+ var n = Object.create(null);
+ if (e) {
+ for (var k in e) {
+ n[k] = e[k];
+ }
+ }
+ n.default = e;
+ return Object.freeze(n);
+}
+
+var Vue__namespace = /*#__PURE__*/_interopNamespaceDefault(Vue);
+
+const shouldIgnoreProp = shared.makeMap(
+ `,key,ref,innerHTML,textContent,ref_key,ref_for`
+);
+function ssrRenderAttrs(props, tag) {
+ let ret = "";
+ for (const key in props) {
+ if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value") {
+ continue;
+ }
+ const value = props[key];
+ if (key === "class") {
+ ret += ` class="${ssrRenderClass(value)}"`;
+ } else if (key === "style") {
+ ret += ` style="${ssrRenderStyle(value)}"`;
+ } else {
+ ret += ssrRenderDynamicAttr(key, value, tag);
+ }
+ }
+ return ret;
+}
+function ssrRenderDynamicAttr(key, value, tag) {
+ if (!isRenderableValue(value)) {
+ return ``;
+ }
+ const attrKey = tag && (tag.indexOf("-") > 0 || shared.isSVGTag(tag)) ? key : shared.propsToAttrMap[key] || key.toLowerCase();
+ if (shared.isBooleanAttr(attrKey)) {
+ return shared.includeBooleanAttr(value) ? ` ${attrKey}` : ``;
+ } else if (shared.isSSRSafeAttrName(attrKey)) {
+ return value === "" ? ` ${attrKey}` : ` ${attrKey}="${shared.escapeHtml(value)}"`;
+ } else {
+ console.warn(
+ `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
+ );
+ return ``;
+ }
+}
+function ssrRenderAttr(key, value) {
+ if (!isRenderableValue(value)) {
+ return ``;
+ }
+ return ` ${key}="${shared.escapeHtml(value)}"`;
+}
+function isRenderableValue(value) {
+ if (value == null) {
+ return false;
+ }
+ const type = typeof value;
+ return type === "string" || type === "number" || type === "boolean";
+}
+function ssrRenderClass(raw) {
+ return shared.escapeHtml(shared.normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+ if (!raw) {
+ return "";
+ }
+ if (shared.isString(raw)) {
+ return shared.escapeHtml(raw);
+ }
+ const styles = shared.normalizeStyle(raw);
+ return shared.escapeHtml(shared.stringifyStyle(styles));
+}
+
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
+ return renderComponentVNode(
+ Vue.createVNode(comp, props, children),
+ parentComponent,
+ slotScopeId
+ );
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
+ push(`<!--[-->`);
+ ssrRenderSlotInner(
+ slots,
+ slotName,
+ slotProps,
+ fallbackRenderFn,
+ push,
+ parentComponent,
+ slotScopeId
+ );
+ push(`<!--]-->`);
+}
+function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
+ const slotFn = slots[slotName];
+ if (slotFn) {
+ const slotBuffer = [];
+ const bufferedPush = (item) => {
+ slotBuffer.push(item);
+ };
+ const ret = slotFn(
+ slotProps,
+ bufferedPush,
+ parentComponent,
+ slotScopeId ? " " + slotScopeId : ""
+ );
+ if (shared.isArray(ret)) {
+ renderVNodeChildren(push, ret, parentComponent, slotScopeId);
+ } else {
+ let isEmptySlot = true;
+ if (transition) {
+ isEmptySlot = false;
+ } else {
+ for (let i = 0; i < slotBuffer.length; i++) {
+ if (!isComment(slotBuffer[i])) {
+ isEmptySlot = false;
+ break;
+ }
+ }
+ }
+ if (isEmptySlot) {
+ if (fallbackRenderFn) {
+ fallbackRenderFn();
+ }
+ } else {
+ for (let i = 0; i < slotBuffer.length; i++) {
+ push(slotBuffer[i]);
+ }
+ }
+ }
+ } else if (fallbackRenderFn) {
+ fallbackRenderFn();
+ }
+}
+const commentTestRE = /^<!--.*-->$/s;
+const commentRE = /<!--[^]*?-->/gm;
+function isComment(item) {
+ if (typeof item !== "string" || !commentTestRE.test(item))
+ return false;
+ if (item.length <= 8)
+ return true;
+ return !item.replace(commentRE, "").trim();
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+ parentPush("<!--teleport start-->");
+ const context = parentComponent.appContext.provides[Vue.ssrContextKey];
+ const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+ const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+ const bufferIndex = targetBuffer.length;
+ let teleportContent;
+ if (disabled) {
+ contentRenderFn(parentPush);
+ teleportContent = `<!--teleport anchor-->`;
+ } else {
+ const { getBuffer, push } = createBuffer();
+ contentRenderFn(push);
+ push(`<!--teleport anchor-->`);
+ teleportContent = getBuffer();
+ }
+ targetBuffer.splice(bufferIndex, 0, teleportContent);
+ parentPush("<!--teleport end-->");
+}
+
+function ssrInterpolate(value) {
+ return shared.escapeHtml(shared.toDisplayString(value));
+}
+
+function ssrRenderList(source, renderItem) {
+ if (shared.isArray(source) || shared.isString(source)) {
+ for (let i = 0, l = source.length; i < l; i++) {
+ renderItem(source[i], i);
+ }
+ } else if (typeof source === "number") {
+ for (let i = 0; i < source; i++) {
+ renderItem(i + 1, i);
+ }
+ } else if (shared.isObject(source)) {
+ if (source[Symbol.iterator]) {
+ const arr = Array.from(source);
+ for (let i = 0, l = arr.length; i < l; i++) {
+ renderItem(arr[i], i);
+ }
+ } else {
+ const keys = Object.keys(source);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ const key = keys[i];
+ renderItem(source[key], key, i);
+ }
+ }
+ }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+ if (renderContent) {
+ renderContent();
+ } else {
+ push(`<!---->`);
+ }
+}
+
+function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
+ if (typeof dir !== "function" && dir.getSSRProps) {
+ return dir.getSSRProps(
+ {
+ dir,
+ instance,
+ value,
+ oldValue: void 0,
+ arg,
+ modifiers
+ },
+ null
+ ) || {};
+ }
+ return {};
+}
+
+const ssrLooseEqual = shared.looseEqual;
+function ssrLooseContain(arr, value) {
+ return shared.looseIndexOf(arr, value) > -1;
+}
+function ssrRenderDynamicModel(type, model, value) {
+ switch (type) {
+ case "radio":
+ return shared.looseEqual(model, value) ? " checked" : "";
+ case "checkbox":
+ return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
+ default:
+ return ssrRenderAttr("value", model);
+ }
+}
+function ssrGetDynamicModelProps(existingProps = {}, model) {
+ const { type, value } = existingProps;
+ switch (type) {
+ case "radio":
+ return shared.looseEqual(model, value) ? { checked: true } : null;
+ case "checkbox":
+ return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
+ default:
+ return { value: model };
+ }
+}
+
+var helpers = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ ssrGetDirectiveProps: ssrGetDirectiveProps,
+ ssrGetDynamicModelProps: ssrGetDynamicModelProps,
+ ssrIncludeBooleanAttr: shared.includeBooleanAttr,
+ ssrInterpolate: ssrInterpolate,
+ ssrLooseContain: ssrLooseContain,
+ ssrLooseEqual: ssrLooseEqual,
+ ssrRenderAttr: ssrRenderAttr,
+ ssrRenderAttrs: ssrRenderAttrs,
+ ssrRenderClass: ssrRenderClass,
+ ssrRenderComponent: ssrRenderComponent,
+ ssrRenderDynamicAttr: ssrRenderDynamicAttr,
+ ssrRenderDynamicModel: ssrRenderDynamicModel,
+ ssrRenderList: ssrRenderList,
+ ssrRenderSlot: ssrRenderSlot,
+ ssrRenderSlotInner: ssrRenderSlotInner,
+ ssrRenderStyle: ssrRenderStyle,
+ ssrRenderSuspense: ssrRenderSuspense,
+ ssrRenderTeleport: ssrRenderTeleport,
+ ssrRenderVNode: renderVNode
+});
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function ssrCompile(template, instance) {
+ const Component = instance.type;
+ const { isCustomElement, compilerOptions } = instance.appContext.config;
+ const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+ const finalCompilerOptions = shared.extend(
+ shared.extend(
+ {
+ isCustomElement,
+ delimiters
+ },
+ compilerOptions
+ ),
+ componentCompilerOptions
+ );
+ finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO;
+ finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO;
+ const cacheKey = JSON.stringify(
+ {
+ template,
+ compilerOptions: finalCompilerOptions
+ },
+ (key, value) => {
+ return shared.isFunction(value) ? value.toString() : value;
+ }
+ );
+ const cached = compileCache[cacheKey];
+ if (cached) {
+ return cached;
+ }
+ finalCompilerOptions.onError = (err) => {
+ {
+ throw err;
+ }
+ };
+ const { code } = compilerSsr.compile(template, finalCompilerOptions);
+ const requireMap = {
+ vue: Vue__namespace,
+ "vue/server-renderer": helpers
+ };
+ const fakeRequire = (id) => requireMap[id];
+ return compileCache[cacheKey] = Function("require", code)(fakeRequire);
+}
+
+const {
+ createComponentInstance,
+ setCurrentRenderingInstance,
+ setupComponent,
+ renderComponentRoot,
+ normalizeVNode
+} = Vue.ssrUtils;
+function createBuffer() {
+ let appendable = false;
+ const buffer = [];
+ return {
+ getBuffer() {
+ return buffer;
+ },
+ push(item) {
+ const isStringItem = shared.isString(item);
+ if (appendable && isStringItem) {
+ buffer[buffer.length - 1] += item;
+ } else {
+ buffer.push(item);
+ }
+ appendable = isStringItem;
+ if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) {
+ buffer.hasAsync = true;
+ }
+ }
+ };
+}
+function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
+ const instance = createComponentInstance(vnode, parentComponent, null);
+ const res = setupComponent(
+ instance,
+ true
+ /* isSSR */
+ );
+ const hasAsyncSetup = shared.isPromise(res);
+ const prefetches = instance.sp;
+ if (hasAsyncSetup || prefetches) {
+ let p = hasAsyncSetup ? res : Promise.resolve();
+ if (prefetches) {
+ p = p.then(
+ () => Promise.all(prefetches.map((prefetch) => prefetch.call(instance.proxy)))
+ ).catch(() => {
+ });
+ }
+ return p.then(() => renderComponentSubTree(instance, slotScopeId));
+ } else {
+ return renderComponentSubTree(instance, slotScopeId);
+ }
+}
+function renderComponentSubTree(instance, slotScopeId) {
+ const comp = instance.type;
+ const { getBuffer, push } = createBuffer();
+ if (shared.isFunction(comp)) {
+ let root = renderComponentRoot(instance);
+ if (!comp.props) {
+ for (const key in instance.attrs) {
+ if (key.startsWith(`data-v-`)) {
+ (root.props || (root.props = {}))[key] = ``;
+ }
+ }
+ }
+ renderVNode(push, instance.subTree = root, instance, slotScopeId);
+ } else {
+ if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) {
+ comp.ssrRender = ssrCompile(comp.template, instance);
+ }
+ for (const e of instance.scope.effects) {
+ if (e.computed)
+ e.computed._cacheable = true;
+ }
+ const ssrRender = instance.ssrRender || comp.ssrRender;
+ if (ssrRender) {
+ let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
+ let hasCloned = false;
+ let cur = instance;
+ while (true) {
+ const scopeId = cur.vnode.scopeId;
+ if (scopeId) {
+ if (!hasCloned) {
+ attrs = { ...attrs };
+ hasCloned = true;
+ }
+ attrs[scopeId] = "";
+ }
+ const parent = cur.parent;
+ if (parent && parent.subTree && parent.subTree === cur.vnode) {
+ cur = parent;
+ } else {
+ break;
+ }
+ }
+ if (slotScopeId) {
+ if (!hasCloned)
+ attrs = { ...attrs };
+ attrs[slotScopeId.trim()] = "";
+ }
+ const prev = setCurrentRenderingInstance(instance);
+ try {
+ ssrRender(
+ instance.proxy,
+ push,
+ instance,
+ attrs,
+ // compiler-optimized bindings
+ instance.props,
+ instance.setupState,
+ instance.data,
+ instance.ctx
+ );
+ } finally {
+ setCurrentRenderingInstance(prev);
+ }
+ } else if (instance.render && instance.render !== shared.NOOP) {
+ renderVNode(
+ push,
+ instance.subTree = renderComponentRoot(instance),
+ instance,
+ slotScopeId
+ );
+ } else {
+ const componentName = comp.name || comp.__file || `<Anonymous>`;
+ Vue.warn(`Component ${componentName} is missing template or render function.`);
+ push(`<!---->`);
+ }
+ }
+ return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent, slotScopeId) {
+ const { type, shapeFlag, children } = vnode;
+ switch (type) {
+ case Vue.Text:
+ push(shared.escapeHtml(children));
+ break;
+ case Vue.Comment:
+ push(
+ children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`
+ );
+ break;
+ case Vue.Static:
+ push(children);
+ break;
+ case Vue.Fragment:
+ if (vnode.slotScopeIds) {
+ slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
+ }
+ push(`<!--[-->`);
+ renderVNodeChildren(
+ push,
+ children,
+ parentComponent,
+ slotScopeId
+ );
+ push(`<!--]-->`);
+ break;
+ default:
+ if (shapeFlag & 1) {
+ renderElementVNode(push, vnode, parentComponent, slotScopeId);
+ } else if (shapeFlag & 6) {
+ push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+ } else if (shapeFlag & 64) {
+ renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+ } else if (shapeFlag & 128) {
+ renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+ } else {
+ Vue.warn(
+ "[@vue/server-renderer] Invalid VNode type:",
+ type,
+ `(${typeof type})`
+ );
+ }
+ }
+}
+function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+ for (let i = 0; i < children.length; i++) {
+ renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+ }
+}
+function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
+ const tag = vnode.type;
+ let { props, children, shapeFlag, scopeId, dirs } = vnode;
+ let openTag = `<${tag}`;
+ if (dirs) {
+ props = applySSRDirectives(vnode, props, dirs);
+ }
+ if (props) {
+ openTag += ssrRenderAttrs(props, tag);
+ }
+ if (scopeId) {
+ openTag += ` ${scopeId}`;
+ }
+ let curParent = parentComponent;
+ let curVnode = vnode;
+ while (curParent && curVnode === curParent.subTree) {
+ curVnode = curParent.vnode;
+ if (curVnode.scopeId) {
+ openTag += ` ${curVnode.scopeId}`;
+ }
+ curParent = curParent.parent;
+ }
+ if (slotScopeId) {
+ openTag += ` ${slotScopeId}`;
+ }
+ push(openTag + `>`);
+ if (!shared.isVoidTag(tag)) {
+ let hasChildrenOverride = false;
+ if (props) {
+ if (props.innerHTML) {
+ hasChildrenOverride = true;
+ push(props.innerHTML);
+ } else if (props.textContent) {
+ hasChildrenOverride = true;
+ push(shared.escapeHtml(props.textContent));
+ } else if (tag === "textarea" && props.value) {
+ hasChildrenOverride = true;
+ push(shared.escapeHtml(props.value));
+ }
+ }
+ if (!hasChildrenOverride) {
+ if (shapeFlag & 8) {
+ push(shared.escapeHtml(children));
+ } else if (shapeFlag & 16) {
+ renderVNodeChildren(
+ push,
+ children,
+ parentComponent,
+ slotScopeId
+ );
+ }
+ }
+ push(`</${tag}>`);
+ }
+}
+function applySSRDirectives(vnode, rawProps, dirs) {
+ const toMerge = [];
+ for (let i = 0; i < dirs.length; i++) {
+ const binding = dirs[i];
+ const {
+ dir: { getSSRProps }
+ } = binding;
+ if (getSSRProps) {
+ const props = getSSRProps(binding, vnode);
+ if (props)
+ toMerge.push(props);
+ }
+ }
+ return Vue.mergeProps(rawProps || {}, ...toMerge);
+}
+function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
+ const target = vnode.props && vnode.props.to;
+ const disabled = vnode.props && vnode.props.disabled;
+ if (!target) {
+ if (!disabled) {
+ Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
+ }
+ return [];
+ }
+ if (!shared.isString(target)) {
+ Vue.warn(
+ `[@vue/server-renderer] Teleport target must be a query selector string.`
+ );
+ return [];
+ }
+ ssrRenderTeleport(
+ push,
+ (push2) => {
+ renderVNodeChildren(
+ push2,
+ vnode.children,
+ parentComponent,
+ slotScopeId
+ );
+ },
+ target,
+ disabled || disabled === "",
+ parentComponent
+ );
+}
+
+const { isVNode: isVNode$1 } = Vue.ssrUtils;
+async function unrollBuffer$1(buffer) {
+ if (buffer.hasAsync) {
+ let ret = "";
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isPromise(item)) {
+ item = await item;
+ }
+ if (shared.isString(item)) {
+ ret += item;
+ } else {
+ ret += await unrollBuffer$1(item);
+ }
+ }
+ return ret;
+ } else {
+ return unrollBufferSync$1(buffer);
+ }
+}
+function unrollBufferSync$1(buffer) {
+ let ret = "";
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isString(item)) {
+ ret += item;
+ } else {
+ ret += unrollBufferSync$1(item);
+ }
+ }
+ return ret;
+}
+async function renderToString(input, context = {}) {
+ if (isVNode$1(input)) {
+ return renderToString(Vue.createApp({ render: () => input }), context);
+ }
+ const vnode = Vue.createVNode(input._component, input._props);
+ vnode.appContext = input._context;
+ input.provide(Vue.ssrContextKey, context);
+ const buffer = await renderComponentVNode(vnode);
+ const result = await unrollBuffer$1(buffer);
+ await resolveTeleports(context);
+ if (context.__watcherHandles) {
+ for (const unwatch of context.__watcherHandles) {
+ unwatch();
+ }
+ }
+ return result;
+}
+async function resolveTeleports(context) {
+ if (context.__teleportBuffers) {
+ context.teleports = context.teleports || {};
+ for (const key in context.__teleportBuffers) {
+ context.teleports[key] = await unrollBuffer$1(
+ await Promise.all([context.__teleportBuffers[key]])
+ );
+ }
+ }
+}
+
+const { isVNode } = Vue.ssrUtils;
+async function unrollBuffer(buffer, stream) {
+ if (buffer.hasAsync) {
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isPromise(item)) {
+ item = await item;
+ }
+ if (shared.isString(item)) {
+ stream.push(item);
+ } else {
+ await unrollBuffer(item, stream);
+ }
+ }
+ } else {
+ unrollBufferSync(buffer, stream);
+ }
+}
+function unrollBufferSync(buffer, stream) {
+ for (let i = 0; i < buffer.length; i++) {
+ let item = buffer[i];
+ if (shared.isString(item)) {
+ stream.push(item);
+ } else {
+ unrollBufferSync(item, stream);
+ }
+ }
+}
+function renderToSimpleStream(input, context, stream) {
+ if (isVNode(input)) {
+ return renderToSimpleStream(
+ Vue.createApp({ render: () => input }),
+ context,
+ stream
+ );
+ }
+ const vnode = Vue.createVNode(input._component, input._props);
+ vnode.appContext = input._context;
+ input.provide(Vue.ssrContextKey, context);
+ Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
+ if (context.__watcherHandles) {
+ for (const unwatch of context.__watcherHandles) {
+ unwatch();
+ }
+ }
+ }).then(() => stream.push(null)).catch((error) => {
+ stream.destroy(error);
+ });
+ return stream;
+}
+function renderToStream(input, context = {}) {
+ console.warn(
+ `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`
+ );
+ return renderToNodeStream(input, context);
+}
+function renderToNodeStream(input, context = {}) {
+ const stream = new (require("stream")).Readable({ read() {
+ } }) ;
+ if (!stream) {
+ throw new Error(
+ `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
+ );
+ }
+ return renderToSimpleStream(input, context, stream);
+}
+function pipeToNodeWritable(input, context = {}, writable) {
+ renderToSimpleStream(input, context, {
+ push(content) {
+ if (content != null) {
+ writable.write(content);
+ } else {
+ writable.end();
+ }
+ },
+ destroy(err) {
+ writable.destroy(err);
+ }
+ });
+}
+function renderToWebStream(input, context = {}) {
+ if (typeof ReadableStream !== "function") {
+ throw new Error(
+ `ReadableStream constructor is not available in the global scope. If the target environment does support web streams, consider using pipeToWebWritable() with an existing WritableStream instance instead.`
+ );
+ }
+ const encoder = new TextEncoder();
+ let cancelled = false;
+ return new ReadableStream({
+ start(controller) {
+ renderToSimpleStream(input, context, {
+ push(content) {
+ if (cancelled)
+ return;
+ if (content != null) {
+ controller.enqueue(encoder.encode(content));
+ } else {
+ controller.close();
+ }
+ },
+ destroy(err) {
+ controller.error(err);
+ }
+ });
+ },
+ cancel() {
+ cancelled = true;
+ }
+ });
+}
+function pipeToWebWritable(input, context = {}, writable) {
+ const writer = writable.getWriter();
+ const encoder = new TextEncoder();
+ let hasReady = false;
+ try {
+ hasReady = shared.isPromise(writer.ready);
+ } catch (e) {
+ }
+ renderToSimpleStream(input, context, {
+ async push(content) {
+ if (hasReady) {
+ await writer.ready;
+ }
+ if (content != null) {
+ return writer.write(encoder.encode(content));
+ } else {
+ return writer.close();
+ }
+ },
+ destroy(err) {
+ console.log(err);
+ writer.close();
+ }
+ });
+}
+
+Vue.initDirectivesForSSR();
+
+exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
+exports.pipeToNodeWritable = pipeToNodeWritable;
+exports.pipeToWebWritable = pipeToWebWritable;
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToSimpleStream = renderToSimpleStream;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToWebStream = renderToWebStream;
+exports.ssrGetDirectiveProps = ssrGetDirectiveProps;
+exports.ssrGetDynamicModelProps = ssrGetDynamicModelProps;
+exports.ssrInterpolate = ssrInterpolate;
+exports.ssrLooseContain = ssrLooseContain;
+exports.ssrLooseEqual = ssrLooseEqual;
+exports.ssrRenderAttr = ssrRenderAttr;
+exports.ssrRenderAttrs = ssrRenderAttrs;
+exports.ssrRenderClass = ssrRenderClass;
+exports.ssrRenderComponent = ssrRenderComponent;
+exports.ssrRenderDynamicAttr = ssrRenderDynamicAttr;
+exports.ssrRenderDynamicModel = ssrRenderDynamicModel;
+exports.ssrRenderList = ssrRenderList;
+exports.ssrRenderSlot = ssrRenderSlot;
+exports.ssrRenderSlotInner = ssrRenderSlotInner;
+exports.ssrRenderStyle = ssrRenderStyle;
+exports.ssrRenderSuspense = ssrRenderSuspense;
+exports.ssrRenderTeleport = ssrRenderTeleport;
+exports.ssrRenderVNode = renderVNode;
diff --git a/.output/server/node_modules/@vue/shared/dist/shared.cjs.js b/.output/server/node_modules/@vue/shared/dist/shared.cjs.js
new file mode 100644
index 0000000..66a7b39
--- /dev/null
+++ b/.output/server/node_modules/@vue/shared/dist/shared.cjs.js
@@ -0,0 +1,474 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function makeMap(str, expectsLowerCase) {
+ const map = /* @__PURE__ */ Object.create(null);
+ const list = str.split(",");
+ for (let i = 0; i < list.length; i++) {
+ map[list[i]] = true;
+ }
+ return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+}
+
+const EMPTY_OBJ = Object.freeze({}) ;
+const EMPTY_ARR = Object.freeze([]) ;
+const NOOP = () => {
+};
+const NO = () => false;
+const onRE = /^on[^a-z]/;
+const isOn = (key) => onRE.test(key);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+ const i = arr.indexOf(el);
+ if (i > -1) {
+ arr.splice(i, 1);
+ }
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+ return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+ return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+ // the leading comma is intentional so empty string "" is also included
+ ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+ "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+ const cache = /* @__PURE__ */ Object.create(null);
+ return (str) => {
+ const hit = cache[str];
+ return hit || (cache[str] = fn(str));
+ };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+ return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+ (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction((str) => {
+ return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction((str) => {
+ const s = str ? `on${capitalize(str)}` : ``;
+ return s;
+});
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns = (fns, arg) => {
+ for (let i = 0; i < fns.length; i++) {
+ fns[i](arg);
+ }
+};
+const def = (obj, key, value) => {
+ Object.defineProperty(obj, key, {
+ configurable: true,
+ enumerable: false,
+ value
+ });
+};
+const looseToNumber = (val) => {
+ const n = parseFloat(val);
+ return isNaN(n) ? val : n;
+};
+const toNumber = (val) => {
+ const n = isString(val) ? Number(val) : NaN;
+ return isNaN(n) ? val : n;
+};
+let _globalThis;
+const getGlobalThis = () => {
+ return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+ return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
+}
+
+const PatchFlagNames = {
+ [1]: `TEXT`,
+ [2]: `CLASS`,
+ [4]: `STYLE`,
+ [8]: `PROPS`,
+ [16]: `FULL_PROPS`,
+ [32]: `NEED_HYDRATION`,
+ [64]: `STABLE_FRAGMENT`,
+ [128]: `KEYED_FRAGMENT`,
+ [256]: `UNKEYED_FRAGMENT`,
+ [512]: `NEED_PATCH`,
+ [1024]: `DYNAMIC_SLOTS`,
+ [2048]: `DEV_ROOT_FRAGMENT`,
+ [-1]: `HOISTED`,
+ [-2]: `BAIL`
+};
+
+const slotFlagsText = {
+ [1]: "STABLE",
+ [2]: "DYNAMIC",
+ [3]: "FORWARDED"
+};
+
+const 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";
+const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
+const isGloballyWhitelisted = isGloballyAllowed;
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+ let lines = source.split(/(\r?\n)/);
+ const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+ lines = lines.filter((_, idx) => idx % 2 === 0);
+ let count = 0;
+ const res = [];
+ for (let i = 0; i < lines.length; i++) {
+ count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+ if (count >= start) {
+ for (let j = i - range; j <= i + range || end > count; j++) {
+ if (j < 0 || j >= lines.length)
+ continue;
+ const line = j + 1;
+ res.push(
+ `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
+ );
+ const lineLength = lines[j].length;
+ const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+ if (j === i) {
+ const pad = start - (count - (lineLength + newLineSeqLength));
+ const length = Math.max(
+ 1,
+ end > count ? lineLength - pad : end - start
+ );
+ res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
+ } else if (j > i) {
+ if (end > count) {
+ const length = Math.max(Math.min(end - count, lineLength), 1);
+ res.push(` | ` + "^".repeat(length));
+ }
+ count += lineLength + newLineSeqLength;
+ }
+ }
+ break;
+ }
+ }
+ return res.join("\n");
+}
+
+function normalizeStyle(value) {
+ if (isArray(value)) {
+ const res = {};
+ for (let i = 0; i < value.length; i++) {
+ const item = value[i];
+ const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+ if (normalized) {
+ for (const key in normalized) {
+ res[key] = normalized[key];
+ }
+ }
+ }
+ return res;
+ } else if (isString(value) || isObject(value)) {
+ return value;
+ }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+ const ret = {};
+ cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+ if (item) {
+ const tmp = item.split(propertyDelimiterRE);
+ tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+ }
+ });
+ return ret;
+}
+function stringifyStyle(styles) {
+ let ret = "";
+ if (!styles || isString(styles)) {
+ return ret;
+ }
+ for (const key in styles) {
+ const value = styles[key];
+ const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+ if (isString(value) || typeof value === "number") {
+ ret += `${normalizedKey}:${value};`;
+ }
+ }
+ return ret;
+}
+function normalizeClass(value) {
+ let res = "";
+ if (isString(value)) {
+ res = value;
+ } else if (isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ const normalized = normalizeClass(value[i]);
+ if (normalized) {
+ res += normalized + " ";
+ }
+ }
+ } else if (isObject(value)) {
+ for (const name in value) {
+ if (value[name]) {
+ res += name + " ";
+ }
+ }
+ }
+ return res.trim();
+}
+function normalizeProps(props) {
+ if (!props)
+ return null;
+ let { class: klass, style } = props;
+ if (klass && !isString(klass)) {
+ props.class = normalizeClass(klass);
+ }
+ if (style) {
+ props.style = normalizeStyle(style);
+ }
+ return props;
+}
+
+const 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";
+const 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";
+const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
+
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+const isBooleanAttr = /* @__PURE__ */ makeMap(
+ specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+ return !!value || value === "";
+}
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+const attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+ if (attrValidationCache.hasOwnProperty(name)) {
+ return attrValidationCache[name];
+ }
+ const isUnsafe = unsafeAttrCharRE.test(name);
+ if (isUnsafe) {
+ console.error(`unsafe attribute name: ${name}`);
+ }
+ return attrValidationCache[name] = !isUnsafe;
+}
+const propsToAttrMap = {
+ acceptCharset: "accept-charset",
+ className: "class",
+ htmlFor: "for",
+ httpEquiv: "http-equiv"
+};
+const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+ `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`
+);
+const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+ `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,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+);
+
+const escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+ const str = "" + string;
+ const match = escapeRE.exec(str);
+ if (!match) {
+ return str;
+ }
+ let html = "";
+ let escaped;
+ let index;
+ let lastIndex = 0;
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ escaped = """;
+ break;
+ case 38:
+ escaped = "&";
+ break;
+ case 39:
+ escaped = "'";
+ break;
+ case 60:
+ escaped = "<";
+ break;
+ case 62:
+ escaped = ">";
+ break;
+ default:
+ continue;
+ }
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+ lastIndex = index + 1;
+ html += escaped;
+ }
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+ return src.replace(commentStripRE, "");
+}
+
+function looseCompareArrays(a, b) {
+ if (a.length !== b.length)
+ return false;
+ let equal = true;
+ for (let i = 0; equal && i < a.length; i++) {
+ equal = looseEqual(a[i], b[i]);
+ }
+ return equal;
+}
+function looseEqual(a, b) {
+ if (a === b)
+ return true;
+ let aValidType = isDate(a);
+ let bValidType = isDate(b);
+ if (aValidType || bValidType) {
+ return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+ }
+ aValidType = isSymbol(a);
+ bValidType = isSymbol(b);
+ if (aValidType || bValidType) {
+ return a === b;
+ }
+ aValidType = isArray(a);
+ bValidType = isArray(b);
+ if (aValidType || bValidType) {
+ return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+ }
+ aValidType = isObject(a);
+ bValidType = isObject(b);
+ if (aValidType || bValidType) {
+ if (!aValidType || !bValidType) {
+ return false;
+ }
+ const aKeysCount = Object.keys(a).length;
+ const bKeysCount = Object.keys(b).length;
+ if (aKeysCount !== bKeysCount) {
+ return false;
+ }
+ for (const key in a) {
+ const aHasKey = a.hasOwnProperty(key);
+ const bHasKey = b.hasOwnProperty(key);
+ if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+ return false;
+ }
+ }
+ }
+ return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+ return arr.findIndex((item) => looseEqual(item, val));
+}
+
+const toDisplayString = (val) => {
+ return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+ if (val && val.__v_isRef) {
+ return replacer(_key, val.value);
+ } else if (isMap(val)) {
+ return {
+ [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
+ entries[`${key} =>`] = val2;
+ return entries;
+ }, {})
+ };
+ } else if (isSet(val)) {
+ return {
+ [`Set(${val.size})`]: [...val.values()]
+ };
+ } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+ return String(val);
+ }
+ return val;
+};
+
+exports.EMPTY_ARR = EMPTY_ARR;
+exports.EMPTY_OBJ = EMPTY_OBJ;
+exports.NO = NO;
+exports.NOOP = NOOP;
+exports.PatchFlagNames = PatchFlagNames;
+exports.camelize = camelize;
+exports.capitalize = capitalize;
+exports.def = def;
+exports.escapeHtml = escapeHtml;
+exports.escapeHtmlComment = escapeHtmlComment;
+exports.extend = extend;
+exports.genPropsAccessExp = genPropsAccessExp;
+exports.generateCodeFrame = generateCodeFrame;
+exports.getGlobalThis = getGlobalThis;
+exports.hasChanged = hasChanged;
+exports.hasOwn = hasOwn;
+exports.hyphenate = hyphenate;
+exports.includeBooleanAttr = includeBooleanAttr;
+exports.invokeArrayFns = invokeArrayFns;
+exports.isArray = isArray;
+exports.isBooleanAttr = isBooleanAttr;
+exports.isBuiltInDirective = isBuiltInDirective;
+exports.isDate = isDate;
+exports.isFunction = isFunction;
+exports.isGloballyAllowed = isGloballyAllowed;
+exports.isGloballyWhitelisted = isGloballyWhitelisted;
+exports.isHTMLTag = isHTMLTag;
+exports.isIntegerKey = isIntegerKey;
+exports.isKnownHtmlAttr = isKnownHtmlAttr;
+exports.isKnownSvgAttr = isKnownSvgAttr;
+exports.isMap = isMap;
+exports.isModelListener = isModelListener;
+exports.isObject = isObject;
+exports.isOn = isOn;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isReservedProp = isReservedProp;
+exports.isSSRSafeAttrName = isSSRSafeAttrName;
+exports.isSVGTag = isSVGTag;
+exports.isSet = isSet;
+exports.isSpecialBooleanAttr = isSpecialBooleanAttr;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isVoidTag = isVoidTag;
+exports.looseEqual = looseEqual;
+exports.looseIndexOf = looseIndexOf;
+exports.looseToNumber = looseToNumber;
+exports.makeMap = makeMap;
+exports.normalizeClass = normalizeClass;
+exports.normalizeProps = normalizeProps;
+exports.normalizeStyle = normalizeStyle;
+exports.objectToString = objectToString;
+exports.parseStringStyle = parseStringStyle;
+exports.propsToAttrMap = propsToAttrMap;
+exports.remove = remove;
+exports.slotFlagsText = slotFlagsText;
+exports.stringifyStyle = stringifyStyle;
+exports.toDisplayString = toDisplayString;
+exports.toHandlerKey = toHandlerKey;
+exports.toNumber = toNumber;
+exports.toRawType = toRawType;
+exports.toTypeString = toTypeString;
diff --git a/.output/server/node_modules/@vue/shared/dist/shared.cjs.prod.js b/.output/server/node_modules/@vue/shared/dist/shared.cjs.prod.js
new file mode 100644
index 0000000..3f0e390
--- /dev/null
+++ b/.output/server/node_modules/@vue/shared/dist/shared.cjs.prod.js
@@ -0,0 +1,474 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function makeMap(str, expectsLowerCase) {
+ const map = /* @__PURE__ */ Object.create(null);
+ const list = str.split(",");
+ for (let i = 0; i < list.length; i++) {
+ map[list[i]] = true;
+ }
+ return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+}
+
+const EMPTY_OBJ = {};
+const EMPTY_ARR = [];
+const NOOP = () => {
+};
+const NO = () => false;
+const onRE = /^on[^a-z]/;
+const isOn = (key) => onRE.test(key);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+ const i = arr.indexOf(el);
+ if (i > -1) {
+ arr.splice(i, 1);
+ }
+};
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
+const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+ return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+ return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+ // the leading comma is intentional so empty string "" is also included
+ ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+ "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+ const cache = /* @__PURE__ */ Object.create(null);
+ return (str) => {
+ const hit = cache[str];
+ return hit || (cache[str] = fn(str));
+ };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+ return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+ (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction((str) => {
+ return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction((str) => {
+ const s = str ? `on${capitalize(str)}` : ``;
+ return s;
+});
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns = (fns, arg) => {
+ for (let i = 0; i < fns.length; i++) {
+ fns[i](arg);
+ }
+};
+const def = (obj, key, value) => {
+ Object.defineProperty(obj, key, {
+ configurable: true,
+ enumerable: false,
+ value
+ });
+};
+const looseToNumber = (val) => {
+ const n = parseFloat(val);
+ return isNaN(n) ? val : n;
+};
+const toNumber = (val) => {
+ const n = isString(val) ? Number(val) : NaN;
+ return isNaN(n) ? val : n;
+};
+let _globalThis;
+const getGlobalThis = () => {
+ return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
+function genPropsAccessExp(name) {
+ return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
+}
+
+const PatchFlagNames = {
+ [1]: `TEXT`,
+ [2]: `CLASS`,
+ [4]: `STYLE`,
+ [8]: `PROPS`,
+ [16]: `FULL_PROPS`,
+ [32]: `NEED_HYDRATION`,
+ [64]: `STABLE_FRAGMENT`,
+ [128]: `KEYED_FRAGMENT`,
+ [256]: `UNKEYED_FRAGMENT`,
+ [512]: `NEED_PATCH`,
+ [1024]: `DYNAMIC_SLOTS`,
+ [2048]: `DEV_ROOT_FRAGMENT`,
+ [-1]: `HOISTED`,
+ [-2]: `BAIL`
+};
+
+const slotFlagsText = {
+ [1]: "STABLE",
+ [2]: "DYNAMIC",
+ [3]: "FORWARDED"
+};
+
+const 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";
+const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
+const isGloballyWhitelisted = isGloballyAllowed;
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+ let lines = source.split(/(\r?\n)/);
+ const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+ lines = lines.filter((_, idx) => idx % 2 === 0);
+ let count = 0;
+ const res = [];
+ for (let i = 0; i < lines.length; i++) {
+ count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+ if (count >= start) {
+ for (let j = i - range; j <= i + range || end > count; j++) {
+ if (j < 0 || j >= lines.length)
+ continue;
+ const line = j + 1;
+ res.push(
+ `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
+ );
+ const lineLength = lines[j].length;
+ const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+ if (j === i) {
+ const pad = start - (count - (lineLength + newLineSeqLength));
+ const length = Math.max(
+ 1,
+ end > count ? lineLength - pad : end - start
+ );
+ res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
+ } else if (j > i) {
+ if (end > count) {
+ const length = Math.max(Math.min(end - count, lineLength), 1);
+ res.push(` | ` + "^".repeat(length));
+ }
+ count += lineLength + newLineSeqLength;
+ }
+ }
+ break;
+ }
+ }
+ return res.join("\n");
+}
+
+function normalizeStyle(value) {
+ if (isArray(value)) {
+ const res = {};
+ for (let i = 0; i < value.length; i++) {
+ const item = value[i];
+ const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+ if (normalized) {
+ for (const key in normalized) {
+ res[key] = normalized[key];
+ }
+ }
+ }
+ return res;
+ } else if (isString(value) || isObject(value)) {
+ return value;
+ }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+ const ret = {};
+ cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+ if (item) {
+ const tmp = item.split(propertyDelimiterRE);
+ tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+ }
+ });
+ return ret;
+}
+function stringifyStyle(styles) {
+ let ret = "";
+ if (!styles || isString(styles)) {
+ return ret;
+ }
+ for (const key in styles) {
+ const value = styles[key];
+ const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+ if (isString(value) || typeof value === "number") {
+ ret += `${normalizedKey}:${value};`;
+ }
+ }
+ return ret;
+}
+function normalizeClass(value) {
+ let res = "";
+ if (isString(value)) {
+ res = value;
+ } else if (isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ const normalized = normalizeClass(value[i]);
+ if (normalized) {
+ res += normalized + " ";
+ }
+ }
+ } else if (isObject(value)) {
+ for (const name in value) {
+ if (value[name]) {
+ res += name + " ";
+ }
+ }
+ }
+ return res.trim();
+}
+function normalizeProps(props) {
+ if (!props)
+ return null;
+ let { class: klass, style } = props;
+ if (klass && !isString(klass)) {
+ props.class = normalizeClass(klass);
+ }
+ if (style) {
+ props.style = normalizeStyle(style);
+ }
+ return props;
+}
+
+const 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";
+const 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";
+const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
+
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+const isBooleanAttr = /* @__PURE__ */ makeMap(
+ specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+ return !!value || value === "";
+}
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+const attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+ if (attrValidationCache.hasOwnProperty(name)) {
+ return attrValidationCache[name];
+ }
+ const isUnsafe = unsafeAttrCharRE.test(name);
+ if (isUnsafe) {
+ console.error(`unsafe attribute name: ${name}`);
+ }
+ return attrValidationCache[name] = !isUnsafe;
+}
+const propsToAttrMap = {
+ acceptCharset: "accept-charset",
+ className: "class",
+ htmlFor: "for",
+ httpEquiv: "http-equiv"
+};
+const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+ `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`
+);
+const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+ `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,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+);
+
+const escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+ const str = "" + string;
+ const match = escapeRE.exec(str);
+ if (!match) {
+ return str;
+ }
+ let html = "";
+ let escaped;
+ let index;
+ let lastIndex = 0;
+ for (index = match.index; index < str.length; index++) {
+ switch (str.charCodeAt(index)) {
+ case 34:
+ escaped = """;
+ break;
+ case 38:
+ escaped = "&";
+ break;
+ case 39:
+ escaped = "'";
+ break;
+ case 60:
+ escaped = "<";
+ break;
+ case 62:
+ escaped = ">";
+ break;
+ default:
+ continue;
+ }
+ if (lastIndex !== index) {
+ html += str.slice(lastIndex, index);
+ }
+ lastIndex = index + 1;
+ html += escaped;
+ }
+ return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+ return src.replace(commentStripRE, "");
+}
+
+function looseCompareArrays(a, b) {
+ if (a.length !== b.length)
+ return false;
+ let equal = true;
+ for (let i = 0; equal && i < a.length; i++) {
+ equal = looseEqual(a[i], b[i]);
+ }
+ return equal;
+}
+function looseEqual(a, b) {
+ if (a === b)
+ return true;
+ let aValidType = isDate(a);
+ let bValidType = isDate(b);
+ if (aValidType || bValidType) {
+ return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+ }
+ aValidType = isSymbol(a);
+ bValidType = isSymbol(b);
+ if (aValidType || bValidType) {
+ return a === b;
+ }
+ aValidType = isArray(a);
+ bValidType = isArray(b);
+ if (aValidType || bValidType) {
+ return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+ }
+ aValidType = isObject(a);
+ bValidType = isObject(b);
+ if (aValidType || bValidType) {
+ if (!aValidType || !bValidType) {
+ return false;
+ }
+ const aKeysCount = Object.keys(a).length;
+ const bKeysCount = Object.keys(b).length;
+ if (aKeysCount !== bKeysCount) {
+ return false;
+ }
+ for (const key in a) {
+ const aHasKey = a.hasOwnProperty(key);
+ const bHasKey = b.hasOwnProperty(key);
+ if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+ return false;
+ }
+ }
+ }
+ return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+ return arr.findIndex((item) => looseEqual(item, val));
+}
+
+const toDisplayString = (val) => {
+ return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+ if (val && val.__v_isRef) {
+ return replacer(_key, val.value);
+ } else if (isMap(val)) {
+ return {
+ [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
+ entries[`${key} =>`] = val2;
+ return entries;
+ }, {})
+ };
+ } else if (isSet(val)) {
+ return {
+ [`Set(${val.size})`]: [...val.values()]
+ };
+ } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+ return String(val);
+ }
+ return val;
+};
+
+exports.EMPTY_ARR = EMPTY_ARR;
+exports.EMPTY_OBJ = EMPTY_OBJ;
+exports.NO = NO;
+exports.NOOP = NOOP;
+exports.PatchFlagNames = PatchFlagNames;
+exports.camelize = camelize;
+exports.capitalize = capitalize;
+exports.def = def;
+exports.escapeHtml = escapeHtml;
+exports.escapeHtmlComment = escapeHtmlComment;
+exports.extend = extend;
+exports.genPropsAccessExp = genPropsAccessExp;
+exports.generateCodeFrame = generateCodeFrame;
+exports.getGlobalThis = getGlobalThis;
+exports.hasChanged = hasChanged;
+exports.hasOwn = hasOwn;
+exports.hyphenate = hyphenate;
+exports.includeBooleanAttr = includeBooleanAttr;
+exports.invokeArrayFns = invokeArrayFns;
+exports.isArray = isArray;
+exports.isBooleanAttr = isBooleanAttr;
+exports.isBuiltInDirective = isBuiltInDirective;
+exports.isDate = isDate;
+exports.isFunction = isFunction;
+exports.isGloballyAllowed = isGloballyAllowed;
+exports.isGloballyWhitelisted = isGloballyWhitelisted;
+exports.isHTMLTag = isHTMLTag;
+exports.isIntegerKey = isIntegerKey;
+exports.isKnownHtmlAttr = isKnownHtmlAttr;
+exports.isKnownSvgAttr = isKnownSvgAttr;
+exports.isMap = isMap;
+exports.isModelListener = isModelListener;
+exports.isObject = isObject;
+exports.isOn = isOn;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isReservedProp = isReservedProp;
+exports.isSSRSafeAttrName = isSSRSafeAttrName;
+exports.isSVGTag = isSVGTag;
+exports.isSet = isSet;
+exports.isSpecialBooleanAttr = isSpecialBooleanAttr;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isVoidTag = isVoidTag;
+exports.looseEqual = looseEqual;
+exports.looseIndexOf = looseIndexOf;
+exports.looseToNumber = looseToNumber;
+exports.makeMap = makeMap;
+exports.normalizeClass = normalizeClass;
+exports.normalizeProps = normalizeProps;
+exports.normalizeStyle = normalizeStyle;
+exports.objectToString = objectToString;
+exports.parseStringStyle = parseStringStyle;
+exports.propsToAttrMap = propsToAttrMap;
+exports.remove = remove;
+exports.slotFlagsText = slotFlagsText;
+exports.stringifyStyle = stringifyStyle;
+exports.toDisplayString = toDisplayString;
+exports.toHandlerKey = toHandlerKey;
+exports.toNumber = toNumber;
+exports.toRawType = toRawType;
+exports.toTypeString = toTypeString;
diff --git a/.output/server/node_modules/estree-walker/dist/umd/estree-walker.js b/.output/server/node_modules/estree-walker/dist/umd/estree-walker.js
new file mode 100644
index 0000000..46fed0f
--- /dev/null
+++ b/.output/server/node_modules/estree-walker/dist/umd/estree-walker.js
@@ -0,0 +1,344 @@
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (global = global || self, factory(global.estreeWalker = {}));
+}(this, (function (exports) { 'use strict';
+
+ // @ts-check
+ /** @typedef { import('estree').BaseNode} BaseNode */
+
+ /** @typedef {{
+ skip: () => void;
+ remove: () => void;
+ replace: (node: BaseNode) => void;
+ }} WalkerContext */
+
+ class WalkerBase {
+ constructor() {
+ /** @type {boolean} */
+ this.should_skip = false;
+
+ /** @type {boolean} */
+ this.should_remove = false;
+
+ /** @type {BaseNode | null} */
+ this.replacement = null;
+
+ /** @type {WalkerContext} */
+ this.context = {
+ skip: () => (this.should_skip = true),
+ remove: () => (this.should_remove = true),
+ replace: (node) => (this.replacement = node)
+ };
+ }
+
+ /**
+ *
+ * @param {any} parent
+ * @param {string} prop
+ * @param {number} index
+ * @param {BaseNode} node
+ */
+ replace(parent, prop, index, node) {
+ if (parent) {
+ if (index !== null) {
+ parent[prop][index] = node;
+ } else {
+ parent[prop] = node;
+ }
+ }
+ }
+
+ /**
+ *
+ * @param {any} parent
+ * @param {string} prop
+ * @param {number} index
+ */
+ remove(parent, prop, index) {
+ if (parent) {
+ if (index !== null) {
+ parent[prop].splice(index, 1);
+ } else {
+ delete parent[prop];
+ }
+ }
+ }
+ }
+
+ // @ts-check
+
+ /** @typedef { import('estree').BaseNode} BaseNode */
+ /** @typedef { import('./walker.js').WalkerContext} WalkerContext */
+
+ /** @typedef {(
+ * this: WalkerContext,
+ * node: BaseNode,
+ * parent: BaseNode,
+ * key: string,
+ * index: number
+ * ) => void} SyncHandler */
+
+ class SyncWalker extends WalkerBase {
+ /**
+ *
+ * @param {SyncHandler} enter
+ * @param {SyncHandler} leave
+ */
+ constructor(enter, leave) {
+ super();
+
+ /** @type {SyncHandler} */
+ this.enter = enter;
+
+ /** @type {SyncHandler} */
+ this.leave = leave;
+ }
+
+ /**
+ *
+ * @param {BaseNode} node
+ * @param {BaseNode} parent
+ * @param {string} [prop]
+ * @param {number} [index]
+ * @returns {BaseNode}
+ */
+ visit(node, parent, prop, index) {
+ if (node) {
+ if (this.enter) {
+ const _should_skip = this.should_skip;
+ const _should_remove = this.should_remove;
+ const _replacement = this.replacement;
+ this.should_skip = false;
+ this.should_remove = false;
+ this.replacement = null;
+
+ this.enter.call(this.context, node, parent, prop, index);
+
+ if (this.replacement) {
+ node = this.replacement;
+ this.replace(parent, prop, index, node);
+ }
+
+ if (this.should_remove) {
+ this.remove(parent, prop, index);
+ }
+
+ const skipped = this.should_skip;
+ const removed = this.should_remove;
+
+ this.should_skip = _should_skip;
+ this.should_remove = _should_remove;
+ this.replacement = _replacement;
+
+ if (skipped) return node;
+ if (removed) return null;
+ }
+
+ for (const key in node) {
+ const value = node[key];
+
+ if (typeof value !== "object") {
+ continue;
+ } else if (Array.isArray(value)) {
+ for (let i = 0; i < value.length; i += 1) {
+ if (value[i] !== null && typeof value[i].type === 'string') {
+ if (!this.visit(value[i], node, key, i)) {
+ // removed
+ i--;
+ }
+ }
+ }
+ } else if (value !== null && typeof value.type === "string") {
+ this.visit(value, node, key, null);
+ }
+ }
+
+ if (this.leave) {
+ const _replacement = this.replacement;
+ const _should_remove = this.should_remove;
+ this.replacement = null;
+ this.should_remove = false;
+
+ this.leave.call(this.context, node, parent, prop, index);
+
+ if (this.replacement) {
+ node = this.replacement;
+ this.replace(parent, prop, index, node);
+ }
+
+ if (this.should_remove) {
+ this.remove(parent, prop, index);
+ }
+
+ const removed = this.should_remove;
+
+ this.replacement = _replacement;
+ this.should_remove = _should_remove;
+
+ if (removed) return null;
+ }
+ }
+
+ return node;
+ }
+ }
+
+ // @ts-check
+
+ /** @typedef { import('estree').BaseNode} BaseNode */
+ /** @typedef { import('./walker').WalkerContext} WalkerContext */
+
+ /** @typedef {(
+ * this: WalkerContext,
+ * node: BaseNode,
+ * parent: BaseNode,
+ * key: string,
+ * index: number
+ * ) => Promise<void>} AsyncHandler */
+
+ class AsyncWalker extends WalkerBase {
+ /**
+ *
+ * @param {AsyncHandler} enter
+ * @param {AsyncHandler} leave
+ */
+ constructor(enter, leave) {
+ super();
+
+ /** @type {AsyncHandler} */
+ this.enter = enter;
+
+ /** @type {AsyncHandler} */
+ this.leave = leave;
+ }
+
+ /**
+ *
+ * @param {BaseNode} node
+ * @param {BaseNode} parent
+ * @param {string} [prop]
+ * @param {number} [index]
+ * @returns {Promise<BaseNode>}
+ */
+ async visit(node, parent, prop, index) {
+ if (node) {
+ if (this.enter) {
+ const _should_skip = this.should_skip;
+ const _should_remove = this.should_remove;
+ const _replacement = this.replacement;
+ this.should_skip = false;
+ this.should_remove = false;
+ this.replacement = null;
+
+ await this.enter.call(this.context, node, parent, prop, index);
+
+ if (this.replacement) {
+ node = this.replacement;
+ this.replace(parent, prop, index, node);
+ }
+
+ if (this.should_remove) {
+ this.remove(parent, prop, index);
+ }
+
+ const skipped = this.should_skip;
+ const removed = this.should_remove;
+
+ this.should_skip = _should_skip;
+ this.should_remove = _should_remove;
+ this.replacement = _replacement;
+
+ if (skipped) return node;
+ if (removed) return null;
+ }
+
+ for (const key in node) {
+ const value = node[key];
+
+ if (typeof value !== "object") {
+ continue;
+ } else if (Array.isArray(value)) {
+ for (let i = 0; i < value.length; i += 1) {
+ if (value[i] !== null && typeof value[i].type === 'string') {
+ if (!(await this.visit(value[i], node, key, i))) {
+ // removed
+ i--;
+ }
+ }
+ }
+ } else if (value !== null && typeof value.type === "string") {
+ await this.visit(value, node, key, null);
+ }
+ }
+
+ if (this.leave) {
+ const _replacement = this.replacement;
+ const _should_remove = this.should_remove;
+ this.replacement = null;
+ this.should_remove = false;
+
+ await this.leave.call(this.context, node, parent, prop, index);
+
+ if (this.replacement) {
+ node = this.replacement;
+ this.replace(parent, prop, index, node);
+ }
+
+ if (this.should_remove) {
+ this.remove(parent, prop, index);
+ }
+
+ const removed = this.should_remove;
+
+ this.replacement = _replacement;
+ this.should_remove = _should_remove;
+
+ if (removed) return null;
+ }
+ }
+
+ return node;
+ }
+ }
+
+ // @ts-check
+
+ /** @typedef { import('estree').BaseNode} BaseNode */
+ /** @typedef { import('./sync.js').SyncHandler} SyncHandler */
+ /** @typedef { import('./async.js').AsyncHandler} AsyncHandler */
+
+ /**
+ *
+ * @param {BaseNode} ast
+ * @param {{
+ * enter?: SyncHandler
+ * leave?: SyncHandler
+ * }} walker
+ * @returns {BaseNode}
+ */
+ function walk(ast, { enter, leave }) {
+ const instance = new SyncWalker(enter, leave);
+ return instance.visit(ast, null);
+ }
+
+ /**
+ *
+ * @param {BaseNode} ast
+ * @param {{
+ * enter?: AsyncHandler
+ * leave?: AsyncHandler
+ * }} walker
+ * @returns {Promise<BaseNode>}
+ */
+ async function asyncWalk(ast, { enter, leave }) {
+ const instance = new AsyncWalker(enter, leave);
+ return await instance.visit(ast, null);
+ }
+
+ exports.asyncWalk = asyncWalk;
+ exports.walk = walk;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
diff --git a/.output/server/node_modules/hookable/dist/index.mjs b/.output/server/node_modules/hookable/dist/index.mjs
new file mode 100644
index 0000000..6695406
--- /dev/null
+++ b/.output/server/node_modules/hookable/dist/index.mjs
@@ -0,0 +1,290 @@
+function flatHooks(configHooks, hooks = {}, parentName) {
+ for (const key in configHooks) {
+ const subHook = configHooks[key];
+ const name = parentName ? `${parentName}:${key}` : key;
+ if (typeof subHook === "object" && subHook !== null) {
+ flatHooks(subHook, hooks, name);
+ } else if (typeof subHook === "function") {
+ hooks[name] = subHook;
+ }
+ }
+ return hooks;
+}
+function mergeHooks(...hooks) {
+ const finalHooks = {};
+ for (const hook of hooks) {
+ const flatenHook = flatHooks(hook);
+ for (const key in flatenHook) {
+ if (finalHooks[key]) {
+ finalHooks[key].push(flatenHook[key]);
+ } else {
+ finalHooks[key] = [flatenHook[key]];
+ }
+ }
+ }
+ for (const key in finalHooks) {
+ if (finalHooks[key].length > 1) {
+ const array = finalHooks[key];
+ finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+ } else {
+ finalHooks[key] = finalHooks[key][0];
+ }
+ }
+ return finalHooks;
+}
+function serial(tasks, function_) {
+ return tasks.reduce(
+ (promise, task) => promise.then(() => function_(task)),
+ Promise.resolve()
+ );
+}
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks, args) {
+ const name = args.shift();
+ const task = createTask(name);
+ return hooks.reduce(
+ (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+ Promise.resolve()
+ );
+}
+function parallelTaskCaller(hooks, args) {
+ const name = args.shift();
+ const task = createTask(name);
+ return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+}
+function serialCaller(hooks, arguments_) {
+ return hooks.reduce(
+ (promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])),
+ Promise.resolve()
+ );
+}
+function parallelCaller(hooks, args) {
+ return Promise.all(hooks.map((hook) => hook(...args || [])));
+}
+function callEachWith(callbacks, arg0) {
+ for (const callback of [...callbacks]) {
+ callback(arg0);
+ }
+}
+
+class Hookable {
+ constructor() {
+ this._hooks = {};
+ this._before = void 0;
+ this._after = void 0;
+ this._deprecatedMessages = void 0;
+ this._deprecatedHooks = {};
+ this.hook = this.hook.bind(this);
+ this.callHook = this.callHook.bind(this);
+ this.callHookWith = this.callHookWith.bind(this);
+ }
+ hook(name, function_, options = {}) {
+ if (!name || typeof function_ !== "function") {
+ return () => {
+ };
+ }
+ const originalName = name;
+ let dep;
+ while (this._deprecatedHooks[name]) {
+ dep = this._deprecatedHooks[name];
+ name = dep.to;
+ }
+ if (dep && !options.allowDeprecated) {
+ let message = dep.message;
+ if (!message) {
+ message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+ }
+ if (!this._deprecatedMessages) {
+ this._deprecatedMessages = /* @__PURE__ */ new Set();
+ }
+ if (!this._deprecatedMessages.has(message)) {
+ console.warn(message);
+ this._deprecatedMessages.add(message);
+ }
+ }
+ if (!function_.name) {
+ try {
+ Object.defineProperty(function_, "name", {
+ get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+ configurable: true
+ });
+ } catch {
+ }
+ }
+ this._hooks[name] = this._hooks[name] || [];
+ this._hooks[name].push(function_);
+ return () => {
+ if (function_) {
+ this.removeHook(name, function_);
+ function_ = void 0;
+ }
+ };
+ }
+ hookOnce(name, function_) {
+ let _unreg;
+ let _function = (...arguments_) => {
+ if (typeof _unreg === "function") {
+ _unreg();
+ }
+ _unreg = void 0;
+ _function = void 0;
+ return function_(...arguments_);
+ };
+ _unreg = this.hook(name, _function);
+ return _unreg;
+ }
+ removeHook(name, function_) {
+ if (this._hooks[name]) {
+ const index = this._hooks[name].indexOf(function_);
+ if (index !== -1) {
+ this._hooks[name].splice(index, 1);
+ }
+ if (this._hooks[name].length === 0) {
+ delete this._hooks[name];
+ }
+ }
+ }
+ deprecateHook(name, deprecated) {
+ this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+ const _hooks = this._hooks[name] || [];
+ delete this._hooks[name];
+ for (const hook of _hooks) {
+ this.hook(name, hook);
+ }
+ }
+ deprecateHooks(deprecatedHooks) {
+ Object.assign(this._deprecatedHooks, deprecatedHooks);
+ for (const name in deprecatedHooks) {
+ this.deprecateHook(name, deprecatedHooks[name]);
+ }
+ }
+ addHooks(configHooks) {
+ const hooks = flatHooks(configHooks);
+ const removeFns = Object.keys(hooks).map(
+ (key) => this.hook(key, hooks[key])
+ );
+ return () => {
+ for (const unreg of removeFns.splice(0, removeFns.length)) {
+ unreg();
+ }
+ };
+ }
+ removeHooks(configHooks) {
+ const hooks = flatHooks(configHooks);
+ for (const key in hooks) {
+ this.removeHook(key, hooks[key]);
+ }
+ }
+ removeAllHooks() {
+ for (const key in this._hooks) {
+ delete this._hooks[key];
+ }
+ }
+ callHook(name, ...arguments_) {
+ arguments_.unshift(name);
+ return this.callHookWith(serialTaskCaller, name, ...arguments_);
+ }
+ callHookParallel(name, ...arguments_) {
+ arguments_.unshift(name);
+ return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+ }
+ callHookWith(caller, name, ...arguments_) {
+ const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
+ if (this._before) {
+ callEachWith(this._before, event);
+ }
+ const result = caller(
+ name in this._hooks ? [...this._hooks[name]] : [],
+ arguments_
+ );
+ if (result instanceof Promise) {
+ return result.finally(() => {
+ if (this._after && event) {
+ callEachWith(this._after, event);
+ }
+ });
+ }
+ if (this._after && event) {
+ callEachWith(this._after, event);
+ }
+ return result;
+ }
+ beforeEach(function_) {
+ this._before = this._before || [];
+ this._before.push(function_);
+ return () => {
+ if (this._before !== void 0) {
+ const index = this._before.indexOf(function_);
+ if (index !== -1) {
+ this._before.splice(index, 1);
+ }
+ }
+ };
+ }
+ afterEach(function_) {
+ this._after = this._after || [];
+ this._after.push(function_);
+ return () => {
+ if (this._after !== void 0) {
+ const index = this._after.indexOf(function_);
+ if (index !== -1) {
+ this._after.splice(index, 1);
+ }
+ }
+ };
+ }
+}
+function createHooks() {
+ return new Hookable();
+}
+
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+ const options = {
+ inspect: isBrowser,
+ group: isBrowser,
+ filter: () => true,
+ ..._options
+ };
+ const _filter = options.filter;
+ const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+ const _tag = options.tag ? `[${options.tag}] ` : "";
+ const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+ const _idCtr = {};
+ const unsubscribeBefore = hooks.beforeEach((event) => {
+ if (filter !== void 0 && !filter(event.name)) {
+ return;
+ }
+ _idCtr[event.name] = _idCtr[event.name] || 0;
+ event._id = _idCtr[event.name]++;
+ console.time(logPrefix(event));
+ });
+ const unsubscribeAfter = hooks.afterEach((event) => {
+ if (filter !== void 0 && !filter(event.name)) {
+ return;
+ }
+ if (options.group) {
+ console.groupCollapsed(event.name);
+ }
+ if (options.inspect) {
+ console.timeLog(logPrefix(event), event.args);
+ } else {
+ console.timeEnd(logPrefix(event));
+ }
+ if (options.group) {
+ console.groupEnd();
+ }
+ _idCtr[event.name]--;
+ });
+ return {
+ /** Stop debugging and remove listeners */
+ close: () => {
+ unsubscribeBefore();
+ unsubscribeAfter();
+ }
+ };
+}
+
+export { Hookable, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };
diff --git a/.output/server/node_modules/ufo/dist/index.mjs b/.output/server/node_modules/ufo/dist/index.mjs
new file mode 100644
index 0000000..ab21cc1
--- /dev/null
+++ b/.output/server/node_modules/ufo/dist/index.mjs
@@ -0,0 +1,533 @@
+const n = /[^\0-\x7E]/;
+const t = /[\x2E\u3002\uFF0E\uFF61]/g;
+const o = {
+ overflow: "Overflow Error",
+ "not-basic": "Illegal Input",
+ "invalid-input": "Invalid Input"
+};
+const e = Math.floor;
+const r = String.fromCharCode;
+function s(n2) {
+ throw new RangeError(o[n2]);
+}
+const c = function(n2, t2) {
+ return n2 + 22 + 75 * (n2 < 26) - ((t2 != 0) << 5);
+};
+const u = function(n2, t2, o2) {
+ let r2 = 0;
+ for (n2 = o2 ? e(n2 / 700) : n2 >> 1, n2 += e(n2 / t2); n2 > 455; r2 += 36) {
+ n2 = e(n2 / 35);
+ }
+ return e(r2 + 36 * n2 / (n2 + 38));
+};
+function toASCII(o2) {
+ return function(n2, o3) {
+ const e2 = n2.split("@");
+ let r2 = "";
+ e2.length > 1 && (r2 = e2[0] + "@", n2 = e2[1]);
+ const s2 = function(n3, t2) {
+ const o4 = [];
+ let e3 = n3.length;
+ for (; e3--; ) {
+ o4[e3] = t2(n3[e3]);
+ }
+ return o4;
+ }((n2 = n2.replace(t, ".")).split("."), o3).join(".");
+ return r2 + s2;
+ }(o2, function(t2) {
+ return n.test(t2) ? "xn--" + function(n2) {
+ const t3 = [];
+ const o3 = (n2 = function(n3) {
+ const t4 = [];
+ let o4 = 0;
+ const e2 = n3.length;
+ for (; o4 < e2; ) {
+ const r2 = n3.charCodeAt(o4++);
+ if (r2 >= 55296 && r2 <= 56319 && o4 < e2) {
+ const e3 = n3.charCodeAt(o4++);
+ (64512 & e3) == 56320 ? t4.push(((1023 & r2) << 10) + (1023 & e3) + 65536) : (t4.push(r2), o4--);
+ } else {
+ t4.push(r2);
+ }
+ }
+ return t4;
+ }(n2)).length;
+ let f = 128;
+ let i = 0;
+ let l = 72;
+ for (const o4 of n2) {
+ o4 < 128 && t3.push(r(o4));
+ }
+ const h = t3.length;
+ let p = h;
+ for (h && t3.push("-"); p < o3; ) {
+ let o4 = 2147483647;
+ for (const t4 of n2) {
+ t4 >= f && t4 < o4 && (o4 = t4);
+ }
+ const a = p + 1;
+ o4 - f > e((2147483647 - i) / a) && s("overflow"), i += (o4 - f) * a, f = o4;
+ for (const o5 of n2) {
+ if (o5 < f && ++i > 2147483647 && s("overflow"), o5 == f) {
+ let n3 = i;
+ for (let o6 = 36; ; o6 += 36) {
+ const s2 = o6 <= l ? 1 : o6 >= l + 26 ? 26 : o6 - l;
+ if (n3 < s2) {
+ break;
+ }
+ const u2 = n3 - s2;
+ const f2 = 36 - s2;
+ t3.push(r(c(s2 + u2 % f2, 0))), n3 = e(u2 / f2);
+ }
+ t3.push(r(c(n3, 0))), l = u(i, a, p == h), i = 0, ++p;
+ }
+ }
+ ++i, ++f;
+ }
+ return t3.join("");
+ }(t2) : t2;
+ });
+}
+
+const HASH_RE = /#/g;
+const AMPERSAND_RE = /&/g;
+const SLASH_RE = /\//g;
+const EQUAL_RE = /=/g;
+const IM_RE = /\?/g;
+const PLUS_RE = /\+/g;
+const ENC_CARET_RE = /%5e/gi;
+const ENC_BACKTICK_RE = /%60/gi;
+const ENC_CURLY_OPEN_RE = /%7b/gi;
+const ENC_PIPE_RE = /%7c/gi;
+const ENC_CURLY_CLOSE_RE = /%7d/gi;
+const ENC_SPACE_RE = /%20/gi;
+const ENC_SLASH_RE = /%2f/gi;
+const ENC_ENC_SLASH_RE = /%252f/gi;
+function encode(text) {
+ return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
+}
+function encodeHash(text) {
+ return encode(text).replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
+}
+function encodeQueryValue(input) {
+ return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^");
+}
+function encodeQueryKey(text) {
+ return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function encodePath(text) {
+ return encode(text).replace(HASH_RE, "%23").replace(IM_RE, "%3F").replace(ENC_ENC_SLASH_RE, "%2F").replace(AMPERSAND_RE, "%26").replace(PLUS_RE, "%2B");
+}
+function encodeParam(text) {
+ return encodePath(text).replace(SLASH_RE, "%2F");
+}
+function decode(text = "") {
+ try {
+ return decodeURIComponent("" + text);
+ } catch {
+ return "" + text;
+ }
+}
+function decodePath(text) {
+ return decode(text.replace(ENC_SLASH_RE, "%252F"));
+}
+function decodeQueryKey(text) {
+ return decode(text.replace(PLUS_RE, " "));
+}
+function decodeQueryValue(text) {
+ return decode(text.replace(PLUS_RE, " "));
+}
+function encodeHost(name = "") {
+ return toASCII(name);
+}
+
+function parseQuery(parametersString = "") {
+ const object = {};
+ if (parametersString[0] === "?") {
+ parametersString = parametersString.slice(1);
+ }
+ for (const parameter of parametersString.split("&")) {
+ const s = parameter.match(/([^=]+)=?(.*)/) || [];
+ if (s.length < 2) {
+ continue;
+ }
+ const key = decodeQueryKey(s[1]);
+ if (key === "__proto__" || key === "constructor") {
+ continue;
+ }
+ const value = decodeQueryValue(s[2] || "");
+ if (object[key] === void 0) {
+ object[key] = value;
+ } else if (Array.isArray(object[key])) {
+ object[key].push(value);
+ } else {
+ object[key] = [object[key], value];
+ }
+ }
+ return object;
+}
+function encodeQueryItem(key, value) {
+ if (typeof value === "number" || typeof value === "boolean") {
+ value = String(value);
+ }
+ if (!value) {
+ return encodeQueryKey(key);
+ }
+ if (Array.isArray(value)) {
+ return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
+ }
+ return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
+}
+function stringifyQuery(query) {
+ return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+ __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+ return value;
+};
+class $URL {
+ constructor(input = "") {
+ __publicField(this, "protocol");
+ __publicField(this, "host");
+ __publicField(this, "auth");
+ __publicField(this, "pathname");
+ __publicField(this, "query", {});
+ __publicField(this, "hash");
+ if (typeof input !== "string") {
+ throw new TypeError(
+ `URL input should be string received ${typeof input} (${input})`
+ );
+ }
+ const parsed = parseURL(input);
+ this.protocol = decode(parsed.protocol);
+ this.host = decode(parsed.host);
+ this.auth = decode(parsed.auth);
+ this.pathname = decodePath(parsed.pathname);
+ this.query = parseQuery(parsed.search);
+ this.hash = decode(parsed.hash);
+ }
+ get hostname() {
+ return parseHost(this.host).hostname;
+ }
+ get port() {
+ return parseHost(this.host).port || "";
+ }
+ get username() {
+ return parseAuth(this.auth).username;
+ }
+ get password() {
+ return parseAuth(this.auth).password || "";
+ }
+ get hasProtocol() {
+ return this.protocol.length;
+ }
+ get isAbsolute() {
+ return this.hasProtocol || this.pathname[0] === "/";
+ }
+ get search() {
+ const q = stringifyQuery(this.query);
+ return q.length > 0 ? "?" + q : "";
+ }
+ get searchParams() {
+ const p = new URLSearchParams();
+ for (const name in this.query) {
+ const value = this.query[name];
+ if (Array.isArray(value)) {
+ for (const v of value) {
+ p.append(name, v);
+ }
+ } else {
+ p.append(
+ name,
+ typeof value === "string" ? value : JSON.stringify(value)
+ );
+ }
+ }
+ return p;
+ }
+ get origin() {
+ return (this.protocol ? this.protocol + "//" : "") + encodeHost(this.host);
+ }
+ get fullpath() {
+ return encodePath(this.pathname) + this.search + encodeHash(this.hash);
+ }
+ get encodedAuth() {
+ if (!this.auth) {
+ return "";
+ }
+ const { username, password } = parseAuth(this.auth);
+ return encodeURIComponent(username) + (password ? ":" + encodeURIComponent(password) : "");
+ }
+ get href() {
+ const auth = this.encodedAuth;
+ const originWithAuth = (this.protocol ? this.protocol + "//" : "") + (auth ? auth + "@" : "") + encodeHost(this.host);
+ return this.hasProtocol && this.isAbsolute ? originWithAuth + this.fullpath : this.fullpath;
+ }
+ append(url) {
+ if (url.hasProtocol) {
+ throw new Error("Cannot append a URL with protocol");
+ }
+ Object.assign(this.query, url.query);
+ if (url.pathname) {
+ this.pathname = withTrailingSlash(this.pathname) + withoutLeadingSlash(url.pathname);
+ }
+ if (url.hash) {
+ this.hash = url.hash;
+ }
+ }
+ toJSON() {
+ return this.href;
+ }
+ toString() {
+ return this.href;
+ }
+}
+
+function isRelative(inputString) {
+ return ["./", "../"].some((string_) => inputString.startsWith(string_));
+}
+const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+function hasProtocol(inputString, opts = {}) {
+ if (typeof opts === "boolean") {
+ opts = { acceptRelative: opts };
+ }
+ if (opts.strict) {
+ return PROTOCOL_STRICT_REGEX.test(inputString);
+ }
+ return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+}
+const PROTOCOL_SCRIPT_RE = /^[\s\0]*(blob|data|javascript|vbscript):$/i;
+function isScriptProtocol(protocol) {
+ return !!protocol && PROTOCOL_SCRIPT_RE.test(protocol);
+}
+const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+ if (!respectQueryAndFragment) {
+ return input.endsWith("/");
+ }
+ return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+ if (!respectQueryAndFragment) {
+ return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+ }
+ if (!hasTrailingSlash(input, true)) {
+ return input || "/";
+ }
+ let path = input;
+ let fragment = "";
+ const fragmentIndex = input.indexOf("#");
+ if (fragmentIndex >= 0) {
+ path = input.slice(0, fragmentIndex);
+ fragment = input.slice(fragmentIndex);
+ }
+ const [s0, ...s] = path.split("?");
+ return (s0.slice(0, -1) || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+ if (!respectQueryAndFragment) {
+ return input.endsWith("/") ? input : input + "/";
+ }
+ if (hasTrailingSlash(input, true)) {
+ return input || "/";
+ }
+ let path = input;
+ let fragment = "";
+ const fragmentIndex = input.indexOf("#");
+ if (fragmentIndex >= 0) {
+ path = input.slice(0, fragmentIndex);
+ fragment = input.slice(fragmentIndex);
+ if (!path) {
+ return fragment;
+ }
+ }
+ const [s0, ...s] = path.split("?");
+ return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function hasLeadingSlash(input = "") {
+ return input.startsWith("/");
+}
+function withoutLeadingSlash(input = "") {
+ return (hasLeadingSlash(input) ? input.slice(1) : input) || "/";
+}
+function withLeadingSlash(input = "") {
+ return hasLeadingSlash(input) ? input : "/" + input;
+}
+function cleanDoubleSlashes(input = "") {
+ return input.split("://").map((string_) => string_.replace(/\/{2,}/g, "/")).join("://");
+}
+function withBase(input, base) {
+ if (isEmptyURL(base) || hasProtocol(input)) {
+ return input;
+ }
+ const _base = withoutTrailingSlash(base);
+ if (input.startsWith(_base)) {
+ return input;
+ }
+ return joinURL(_base, input);
+}
+function withoutBase(input, base) {
+ if (isEmptyURL(base)) {
+ return input;
+ }
+ const _base = withoutTrailingSlash(base);
+ if (!input.startsWith(_base)) {
+ return input;
+ }
+ const trimmed = input.slice(_base.length);
+ return trimmed[0] === "/" ? trimmed : "/" + trimmed;
+}
+function withQuery(input, query) {
+ const parsed = parseURL(input);
+ const mergedQuery = { ...parseQuery(parsed.search), ...query };
+ parsed.search = stringifyQuery(mergedQuery);
+ return stringifyParsedURL(parsed);
+}
+function getQuery(input) {
+ return parseQuery(parseURL(input).search);
+}
+function isEmptyURL(url) {
+ return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+ return url && url !== "/";
+}
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function joinURL(base, ...input) {
+ let url = base || "";
+ for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
+ if (url) {
+ const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+ url = withTrailingSlash(url) + _segment;
+ } else {
+ url = segment;
+ }
+ }
+ return url;
+}
+function withHttp(input) {
+ return withProtocol(input, "http://");
+}
+function withHttps(input) {
+ return withProtocol(input, "https://");
+}
+function withoutProtocol(input) {
+ return withProtocol(input, "");
+}
+function withProtocol(input, protocol) {
+ const match = input.match(PROTOCOL_REGEX);
+ if (!match) {
+ return protocol + input;
+ }
+ return protocol + input.slice(match[0].length);
+}
+function createURL(input) {
+ return new $URL(input);
+}
+function normalizeURL(input) {
+ return createURL(input).toString();
+}
+function resolveURL(base, ...input) {
+ const url = createURL(base);
+ for (const index of input.filter((url2) => isNonEmptyURL(url2))) {
+ url.append(createURL(index));
+ }
+ return url.toString();
+}
+function isSamePath(p1, p2) {
+ return decode(withoutTrailingSlash(p1)) === decode(withoutTrailingSlash(p2));
+}
+function isEqual(a, b, options = {}) {
+ if (!options.trailingSlash) {
+ a = withTrailingSlash(a);
+ b = withTrailingSlash(b);
+ }
+ if (!options.leadingSlash) {
+ a = withLeadingSlash(a);
+ b = withLeadingSlash(b);
+ }
+ if (!options.encoding) {
+ a = decode(a);
+ b = decode(b);
+ }
+ return a === b;
+}
+
+function parseURL(input = "", defaultProto) {
+ const _specialProtoMatch = input.match(
+ /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
+ );
+ if (_specialProtoMatch) {
+ const [, _proto, _pathname = ""] = _specialProtoMatch;
+ return {
+ protocol: _proto.toLowerCase(),
+ pathname: _pathname,
+ href: _proto + _pathname,
+ auth: "",
+ host: "",
+ search: "",
+ hash: ""
+ };
+ }
+ if (!hasProtocol(input, { acceptRelative: true })) {
+ return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
+ }
+ const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+ const [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
+ const { pathname, search, hash } = parsePath(
+ path.replace(/\/(?=[A-Za-z]:)/, "")
+ );
+ return {
+ protocol: protocol.toLowerCase(),
+ auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
+ host,
+ pathname,
+ search,
+ hash
+ };
+}
+function parsePath(input = "") {
+ const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+ return {
+ pathname,
+ search,
+ hash
+ };
+}
+function parseAuth(input = "") {
+ const [username, password] = input.split(":");
+ return {
+ username: decode(username),
+ password: decode(password)
+ };
+}
+function parseHost(input = "") {
+ const [hostname, port] = (input.match(/([^/:]*):?(\d+)?/) || []).splice(1);
+ return {
+ hostname: decode(hostname),
+ port
+ };
+}
+function stringifyParsedURL(parsed) {
+ const pathname = parsed.pathname || "";
+ const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
+ const hash = parsed.hash || "";
+ const auth = parsed.auth ? parsed.auth + "@" : "";
+ const host = parsed.host || "";
+ const proto = parsed.protocol ? parsed.protocol + "//" : "";
+ return proto + auth + host + pathname + search + hash;
+}
+const FILENAME_STRICT_REGEX = /\/([^/]+\.[^/]+)$/;
+const FILENAME_REGEX = /\/([^/]+)$/;
+function parseFilename(input = "", { strict }) {
+ const { pathname } = parseURL(input);
+ const matches = strict ? pathname.match(FILENAME_STRICT_REGEX) : pathname.match(FILENAME_REGEX);
+ return matches ? matches[1] : void 0;
+}
+
+export { $URL, cleanDoubleSlashes, createURL, decode, decodePath, decodeQueryKey, decodeQueryValue, encode, encodeHash, encodeHost, encodeParam, encodePath, encodeQueryItem, encodeQueryKey, encodeQueryValue, getQuery, hasLeadingSlash, hasProtocol, hasTrailingSlash, isEmptyURL, isEqual, isNonEmptyURL, isRelative, isSamePath, isScriptProtocol, joinURL, normalizeURL, parseAuth, parseFilename, parseHost, parsePath, parseQuery, parseURL, resolveURL, stringifyParsedURL, stringifyQuery, withBase, withHttp, withHttps, withLeadingSlash, withProtocol, withQuery, withTrailingSlash, withoutBase, withoutLeadingSlash, withoutProtocol, withoutTrailingSlash };
diff --git a/.output/server/node_modules/unhead/dist/index.mjs b/.output/server/node_modules/unhead/dist/index.mjs
new file mode 100644
index 0000000..80a13aa
--- /dev/null
+++ b/.output/server/node_modules/unhead/dist/index.mjs
@@ -0,0 +1,637 @@
+import { createHooks } from 'hookable';
+import { DomPlugin } from '@unhead/dom';
+import { defineHeadPlugin, tagDedupeKey, tagWeight, HasElementTags, hashCode, NetworkEvents, SortModifiers, processTemplateParams, resolveTitleTemplate, IsBrowser, normaliseEntryTags, composableNames, whitelistSafeInput, unpackMeta } from '@unhead/shared';
+export { composableNames } from '@unhead/shared';
+
+const UsesMergeStrategy = ["templateParams", "htmlAttrs", "bodyAttrs"];
+const DedupePlugin = defineHeadPlugin({
+ hooks: {
+ "tag:normalise": function({ tag }) {
+ ["hid", "vmid", "key"].forEach((key) => {
+ if (tag.props[key]) {
+ tag.key = tag.props[key];
+ delete tag.props[key];
+ }
+ });
+ const generatedKey = tagDedupeKey(tag);
+ const dedupe = generatedKey || (tag.key ? `${tag.tag}:${tag.key}` : false);
+ if (dedupe)
+ tag._d = dedupe;
+ },
+ "tags:resolve": function(ctx) {
+ const deduping = {};
+ ctx.tags.forEach((tag) => {
+ const dedupeKey = (tag.key ? `${tag.tag}:${tag.key}` : tag._d) || tag._p;
+ const dupedTag = deduping[dedupeKey];
+ if (dupedTag) {
+ let strategy = tag?.tagDuplicateStrategy;
+ if (!strategy && UsesMergeStrategy.includes(tag.tag))
+ strategy = "merge";
+ if (strategy === "merge") {
+ const oldProps = dupedTag.props;
+ ["class", "style"].forEach((key) => {
+ if (tag.props[key] && oldProps[key]) {
+ if (key === "style" && !oldProps[key].endsWith(";"))
+ oldProps[key] += ";";
+ tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
+ }
+ });
+ deduping[dedupeKey].props = {
+ ...oldProps,
+ ...tag.props
+ };
+ return;
+ } else if (tag._e === dupedTag._e) {
+ dupedTag._duped = dupedTag._duped || [];
+ tag._d = `${dupedTag._d}:${dupedTag._duped.length + 1}`;
+ dupedTag._duped.push(tag);
+ return;
+ } else if (tagWeight(tag) > tagWeight(dupedTag)) {
+ return;
+ }
+ }
+ const propCount = Object.keys(tag.props).length + (tag.innerHTML ? 1 : 0) + (tag.textContent ? 1 : 0);
+ if (HasElementTags.includes(tag.tag) && propCount === 0) {
+ delete deduping[dedupeKey];
+ return;
+ }
+ deduping[dedupeKey] = tag;
+ });
+ const newTags = [];
+ Object.values(deduping).forEach((tag) => {
+ const dupes = tag._duped;
+ delete tag._duped;
+ newTags.push(tag);
+ if (dupes)
+ newTags.push(...dupes);
+ });
+ ctx.tags = newTags;
+ ctx.tags = ctx.tags.filter((t) => !(t.tag === "meta" && (t.props.name || t.props.property) && !t.props.content));
+ }
+ }
+});
+
+const PayloadPlugin = defineHeadPlugin({
+ mode: "server",
+ hooks: {
+ "tags:resolve": function(ctx) {
+ const payload = {};
+ ctx.tags.filter((tag) => ["titleTemplate", "templateParams", "title"].includes(tag.tag) && tag._m === "server").forEach((tag) => {
+ payload[tag.tag] = tag.tag.startsWith("title") ? tag.textContent : tag.props;
+ });
+ Object.keys(payload).length && ctx.tags.push({
+ tag: "script",
+ innerHTML: JSON.stringify(payload),
+ props: { id: "unhead:payload", type: "application/json" }
+ });
+ }
+ }
+});
+
+const ValidEventTags = ["script", "link", "bodyAttrs"];
+function stripEventHandlers(tag) {
+ const props = {};
+ const eventHandlers = {};
+ Object.entries(tag.props).forEach(([key, value]) => {
+ if (key.startsWith("on") && typeof value === "function") {
+ if (NetworkEvents.includes(key))
+ props[key] = `this.dataset.${key} = true`;
+ eventHandlers[key] = value;
+ } else {
+ props[key] = value;
+ }
+ });
+ return { props, eventHandlers };
+}
+const EventHandlersPlugin = defineHeadPlugin((head) => ({
+ hooks: {
+ "tags:resolve": function(ctx) {
+ for (const tag of ctx.tags) {
+ if (ValidEventTags.includes(tag.tag)) {
+ const { props, eventHandlers } = stripEventHandlers(tag);
+ tag.props = props;
+ if (Object.keys(eventHandlers).length) {
+ if (tag.props.src || tag.props.href)
+ tag.key = tag.key || hashCode(tag.props.src || tag.props.href);
+ tag._eventHandlers = eventHandlers;
+ }
+ }
+ }
+ },
+ "dom:renderTag": function(ctx, dom, track) {
+ if (!ctx.tag._eventHandlers)
+ return;
+ const $eventListenerTarget = ctx.tag.tag === "bodyAttrs" ? dom.defaultView : ctx.$el;
+ Object.entries(ctx.tag._eventHandlers).forEach(([k, value]) => {
+ const sdeKey = `${ctx.tag._d || ctx.tag._p}:${k}`;
+ const eventName = k.slice(2).toLowerCase();
+ const eventDedupeKey = `data-h-${eventName}`;
+ track(ctx.id, sdeKey, () => {
+ });
+ if (ctx.$el.hasAttribute(eventDedupeKey))
+ return;
+ ctx.$el.setAttribute(eventDedupeKey, "");
+ let observer;
+ const handler = (e) => {
+ value(e);
+ observer?.disconnect();
+ };
+ if (k in ctx.$el.dataset) {
+ handler(new Event(k.replace("on", "")));
+ } else if (NetworkEvents.includes(k) && typeof MutationObserver !== "undefined") {
+ observer = new MutationObserver((e) => {
+ const hasAttr = e.some((m) => m.attributeName === `data-${k}`);
+ if (hasAttr) {
+ handler(new Event(k.replace("on", "")));
+ observer?.disconnect();
+ }
+ });
+ observer.observe(ctx.$el, {
+ attributes: true
+ });
+ } else {
+ $eventListenerTarget.addEventListener(eventName, handler);
+ }
+ track(ctx.id, sdeKey, () => {
+ observer?.disconnect();
+ $eventListenerTarget.removeEventListener(eventName, handler);
+ ctx.$el.removeAttribute(eventDedupeKey);
+ });
+ });
+ }
+ }
+}));
+
+const DupeableTags = ["link", "style", "script", "noscript"];
+const HashKeyedPlugin = defineHeadPlugin({
+ hooks: {
+ "tag:normalise": ({ tag }) => {
+ if (tag.key && DupeableTags.includes(tag.tag)) {
+ tag.props["data-hid"] = tag._h = hashCode(tag.key);
+ }
+ }
+ }
+});
+
+const SortPlugin = defineHeadPlugin({
+ hooks: {
+ "tags:resolve": (ctx) => {
+ const tagPositionForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
+ for (const { prefix, offset } of SortModifiers) {
+ for (const tag of ctx.tags.filter((tag2) => typeof tag2.tagPriority === "string" && tag2.tagPriority.startsWith(prefix))) {
+ const position = tagPositionForKey(
+ tag.tagPriority.replace(prefix, "")
+ );
+ if (typeof position !== "undefined")
+ tag._p = position + offset;
+ }
+ }
+ ctx.tags.sort((a, b) => a._p - b._p).sort((a, b) => tagWeight(a) - tagWeight(b));
+ }
+ }
+});
+
+const SupportedAttrs = {
+ meta: "content",
+ link: "href",
+ htmlAttrs: "lang"
+};
+const TemplateParamsPlugin = defineHeadPlugin((head) => ({
+ hooks: {
+ "tags:resolve": (ctx) => {
+ const { tags } = ctx;
+ const title = tags.find((tag) => tag.tag === "title")?.textContent;
+ const idx = tags.findIndex((tag) => tag.tag === "templateParams");
+ const params = idx !== -1 ? tags[idx].props : {};
+ const sep = params.separator || "|";
+ delete params.separator;
+ params.pageTitle = processTemplateParams(params.pageTitle || title || "", params, sep);
+ for (const tag of tags.filter((t) => t.processTemplateParams !== false)) {
+ const v = SupportedAttrs[tag.tag];
+ if (v && typeof tag.props[v] === "string") {
+ tag.props[v] = processTemplateParams(tag.props[v], params, sep);
+ } else if (tag.processTemplateParams === true || ["titleTemplate", "title"].includes(tag.tag)) {
+ ["innerHTML", "textContent"].forEach((p) => {
+ if (typeof tag[p] === "string")
+ tag[p] = processTemplateParams(tag[p], params, sep);
+ });
+ }
+ }
+ head._templateParams = params;
+ head._separator = sep;
+ ctx.tags = tags.filter((tag) => tag.tag !== "templateParams");
+ }
+ }
+}));
+
+const TitleTemplatePlugin = defineHeadPlugin({
+ hooks: {
+ "tags:resolve": (ctx) => {
+ const { tags } = ctx;
+ let titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
+ const titleIdx = tags.findIndex((i) => i.tag === "title");
+ if (titleIdx !== -1 && titleTemplateIdx !== -1) {
+ const newTitle = resolveTitleTemplate(
+ tags[titleTemplateIdx].textContent,
+ tags[titleIdx].textContent
+ );
+ if (newTitle !== null) {
+ tags[titleIdx].textContent = newTitle || tags[titleIdx].textContent;
+ } else {
+ delete tags[titleIdx];
+ }
+ } else if (titleTemplateIdx !== -1) {
+ const newTitle = resolveTitleTemplate(
+ tags[titleTemplateIdx].textContent
+ );
+ if (newTitle !== null) {
+ tags[titleTemplateIdx].textContent = newTitle;
+ tags[titleTemplateIdx].tag = "title";
+ titleTemplateIdx = -1;
+ }
+ }
+ if (titleTemplateIdx !== -1) {
+ delete tags[titleTemplateIdx];
+ }
+ ctx.tags = tags.filter(Boolean);
+ }
+ }
+});
+
+const XSSPlugin = defineHeadPlugin({
+ hooks: {
+ "tags:afterResolve": function(ctx) {
+ for (const tag of ctx.tags) {
+ if (typeof tag.innerHTML === "string") {
+ if (tag.innerHTML && ["application/ld+json", "application/json"].includes(tag.props.type)) {
+ tag.innerHTML = tag.innerHTML.replace(/</g, "\\u003C");
+ } else {
+ tag.innerHTML = tag.innerHTML.replace(new RegExp(`</${tag.tag}`, "g"), `<\\/${tag.tag}`);
+ }
+ }
+ }
+ }
+ }
+});
+
+let activeHead;
+// @__NO_SIDE_EFFECTS__
+function createHead(options = {}) {
+ const head = createHeadCore(options);
+ head.use(DomPlugin());
+ return activeHead = head;
+}
+// @__NO_SIDE_EFFECTS__
+function createServerHead(options = {}) {
+ return activeHead = createHeadCore(options);
+}
+function filterMode(mode, ssr) {
+ return !mode || mode === "server" && ssr || mode === "client" && !ssr;
+}
+function createHeadCore(options = {}) {
+ const hooks = createHooks();
+ hooks.addHooks(options.hooks || {});
+ options.document = options.document || (IsBrowser ? document : void 0);
+ const ssr = !options.document;
+ const updated = () => {
+ head.dirty = true;
+ hooks.callHook("entries:updated", head);
+ };
+ let entryCount = 0;
+ let entries = [];
+ const plugins = [];
+ const head = {
+ plugins,
+ dirty: false,
+ resolvedOptions: options,
+ hooks,
+ headEntries() {
+ return entries;
+ },
+ use(p) {
+ const plugin = typeof p === "function" ? p(head) : p;
+ if (!plugin.key || !plugins.some((p2) => p2.key === plugin.key)) {
+ plugins.push(plugin);
+ filterMode(plugin.mode, ssr) && hooks.addHooks(plugin.hooks || {});
+ }
+ },
+ push(input, entryOptions) {
+ delete entryOptions?.head;
+ const entry = {
+ _i: entryCount++,
+ input,
+ ...entryOptions
+ };
+ if (filterMode(entry.mode, ssr)) {
+ entries.push(entry);
+ updated();
+ }
+ return {
+ dispose() {
+ entries = entries.filter((e) => e._i !== entry._i);
+ hooks.callHook("entries:updated", head);
+ updated();
+ },
+ // a patch is the same as creating a new entry, just a nice DX
+ patch(input2) {
+ entries = entries.map((e) => {
+ if (e._i === entry._i) {
+ e.input = entry.input = input2;
+ }
+ return e;
+ });
+ updated();
+ }
+ };
+ },
+ async resolveTags() {
+ const resolveCtx = { tags: [], entries: [...entries] };
+ await hooks.callHook("entries:resolve", resolveCtx);
+ for (const entry of resolveCtx.entries) {
+ const resolved = entry.resolvedInput || entry.input;
+ entry.resolvedInput = await (entry.transform ? entry.transform(resolved) : resolved);
+ if (entry.resolvedInput) {
+ for (const tag of await normaliseEntryTags(entry)) {
+ const tagCtx = { tag, entry, resolvedOptions: head.resolvedOptions };
+ await hooks.callHook("tag:normalise", tagCtx);
+ resolveCtx.tags.push(tagCtx.tag);
+ }
+ }
+ }
+ await hooks.callHook("tags:beforeResolve", resolveCtx);
+ await hooks.callHook("tags:resolve", resolveCtx);
+ await hooks.callHook("tags:afterResolve", resolveCtx);
+ return resolveCtx.tags;
+ },
+ ssr
+ };
+ [
+ DedupePlugin,
+ PayloadPlugin,
+ EventHandlersPlugin,
+ HashKeyedPlugin,
+ SortPlugin,
+ TemplateParamsPlugin,
+ TitleTemplatePlugin,
+ XSSPlugin,
+ ...options?.plugins || []
+ ].forEach((p) => head.use(p));
+ head.hooks.callHook("init", head);
+ return head;
+}
+
+// @__NO_SIDE_EFFECTS__
+function HashHydrationPlugin() {
+ return defineHeadPlugin({});
+}
+
+const importRe = /@import/;
+// @__NO_SIDE_EFFECTS__
+function CapoPlugin(options) {
+ return defineHeadPlugin({
+ hooks: {
+ "tags:beforeResolve": function({ tags }) {
+ for (const tag of tags) {
+ if (tag.tagPosition && tag.tagPosition !== "head")
+ continue;
+ tag.tagPriority = tag.tagPriority || tagWeight(tag);
+ if (tag.tagPriority !== 100)
+ continue;
+ const isTruthy = (val) => val === "" || val === true;
+ const isScript = tag.tag === "script";
+ const isLink = tag.tag === "link";
+ if (isScript && isTruthy(tag.props.async)) {
+ tag.tagPriority = 30;
+ } else if (tag.tag === "style" && tag.innerHTML && importRe.test(tag.innerHTML)) {
+ tag.tagPriority = 40;
+ } else if (isScript && tag.props.src && !isTruthy(tag.props.defer) && !isTruthy(tag.props.async) && tag.props.type !== "module" && !tag.props.type?.endsWith("json")) {
+ tag.tagPriority = 50;
+ } else if (isLink && tag.props.rel === "stylesheet" || tag.tag === "style") {
+ tag.tagPriority = 60;
+ } else if (isLink && ["preload", "modulepreload"].includes(tag.props.rel)) {
+ tag.tagPriority = 70;
+ } else if (isScript && isTruthy(tag.props.defer) && tag.props.src && !isTruthy(tag.props.async)) {
+ tag.tagPriority = 80;
+ } else if (isLink && ["prefetch", "dns-prefetch", "prerender"].includes(tag.props.rel)) {
+ tag.tagPriority = 90;
+ }
+ }
+ options?.track && tags.push({
+ tag: "htmlAttrs",
+ props: {
+ "data-capo": ""
+ }
+ });
+ }
+ }
+ });
+}
+
+const unheadComposablesImports = [
+ {
+ from: "unhead",
+ imports: composableNames
+ }
+];
+
+function getActiveHead() {
+ return activeHead;
+}
+
+function useHead(input, options = {}) {
+ const head = options.head || getActiveHead();
+ return head?.push(input, options);
+}
+
+function useHeadSafe(input, options = {}) {
+ return useHead(input, {
+ ...options || {},
+ transform: whitelistSafeInput
+ });
+}
+
+function useServerHead(input, options = {}) {
+ return useHead(input, { ...options, mode: "server" });
+}
+
+function useServerHeadSafe(input, options = {}) {
+ return useHeadSafe(input, { ...options, mode: "server" });
+}
+
+function useSeoMeta(input, options) {
+ const { title, titleTemplate, ...meta } = input;
+ return useHead({
+ title,
+ titleTemplate,
+ // we need to input the meta so the reactivity will be resolved
+ // @ts-expect-error runtime type
+ _flatMeta: meta
+ }, {
+ ...options,
+ transform(t) {
+ const meta2 = unpackMeta({ ...t._flatMeta });
+ delete t._flatMeta;
+ return {
+ // @ts-expect-error runtime type
+ ...t,
+ meta: meta2
+ };
+ }
+ });
+}
+
+function useServerSeoMeta(input, options) {
+ return useSeoMeta(input, {
+ ...options || {},
+ mode: "server"
+ });
+}
+
+const UseScriptDefaults = {
+ defer: true,
+ fetchpriority: "low"
+};
+function useScript(input, _options) {
+ const options = _options || {};
+ const head = options.head || getActiveHead();
+ if (!head)
+ throw new Error("No active head found, please provide a head instance or use the useHead composable");
+ const id = input.key || hashCode(input.src || (typeof input.innerHTML === "string" ? input.innerHTML : ""));
+ const key = `use-script.${id}`;
+ if (head._scripts?.[id])
+ return head._scripts[id];
+ async function transform(entry) {
+ const script2 = await (options.transform || ((input2) => input2))(entry.script[0]);
+ const ctx = { script: script2 };
+ await head.hooks.callHook("script:transform", ctx);
+ return { script: [ctx.script] };
+ }
+ function maybeHintEarlyConnection(rel) {
+ if (
+ // opt-out
+ options.skipEarlyConnections || !input.src.includes("//") || !head.ssr
+ )
+ return;
+ const key2 = `use-script.${id}.early-connection`;
+ head.push({
+ link: [{ key: key2, rel, href: new URL(input.src).origin }]
+ }, { mode: "server" });
+ }
+ const script = {
+ id,
+ status: "awaitingLoad",
+ loaded: false,
+ remove() {
+ if (script.status === "loaded") {
+ script.entry?.dispose();
+ script.status = "removed";
+ head.hooks.callHook(`script:updated`, hookCtx);
+ delete head._scripts?.[id];
+ return true;
+ }
+ return false;
+ },
+ waitForLoad() {
+ return new Promise((resolve) => {
+ if (script.status === "loaded")
+ resolve(options.use());
+ function watchForScriptLoaded({ script: script2 }) {
+ if (script2.id === id && script2.status === "loaded") {
+ resolve(options.use?.());
+ head.hooks.removeHook("script:updated", watchForScriptLoaded);
+ }
+ }
+ head.hooks.hook("script:updated", watchForScriptLoaded);
+ });
+ },
+ load() {
+ if (script.status !== "awaitingLoad")
+ return script.waitForLoad();
+ script.status = "loading";
+ head.hooks.callHook(`script:updated`, hookCtx);
+ script.entry = head.push({
+ script: [
+ // async by default
+ { ...UseScriptDefaults, ...input, key }
+ ]
+ }, {
+ ...options,
+ // @ts-expect-error untyped
+ transform,
+ head
+ });
+ return script.waitForLoad();
+ }
+ };
+ const hookCtx = { script };
+ NetworkEvents.forEach((fn) => {
+ const _fn = typeof input[fn] === "function" ? input[fn].bind({}) : null;
+ input[fn] = (e) => {
+ script.status = fn === "onload" ? "loaded" : fn === "onerror" ? "error" : "loading";
+ head.hooks.callHook(`script:updated`, hookCtx);
+ _fn && _fn(e);
+ };
+ });
+ let trigger = options.trigger;
+ if (trigger) {
+ const isIdle = trigger === "idle";
+ if (isIdle) {
+ if (head.ssr)
+ trigger = "manual";
+ else
+ trigger = new Promise((resolve) => requestIdleCallback(() => resolve()));
+ }
+ trigger === "manual" && (trigger = new Promise(() => {
+ }));
+ trigger instanceof Promise && trigger.then(script.load);
+ maybeHintEarlyConnection(isIdle ? "preconnect" : "dns-prefetch");
+ } else {
+ script.load();
+ maybeHintEarlyConnection("preconnect");
+ }
+ function resolveInnerHtmlLoad(ctx) {
+ if (ctx.tag.key === key) {
+ if (ctx.tag.innerHTML) {
+ setTimeout(
+ () => {
+ script.status = "loaded";
+ head.hooks.callHook("script:updated", hookCtx);
+ typeof input.onload === "function" && input.onload(new Event("load"));
+ },
+ 5
+ /* give inline script a chance to run */
+ );
+ }
+ head.hooks.removeHook("dom:renderTag", resolveInnerHtmlLoad);
+ }
+ }
+ head.hooks.hook("dom:renderTag", resolveInnerHtmlLoad);
+ const instance = new Proxy({}, {
+ get(_, fn) {
+ const stub = options.stub?.({ script, fn });
+ if (stub)
+ return stub;
+ if (fn === "$script")
+ return script;
+ return (...args) => {
+ if (head.ssr || !options.use)
+ return;
+ if (script.loaded) {
+ const api = options.use();
+ return api[fn](...args);
+ } else {
+ return script.waitForLoad().then(
+ (api) => {
+ api[fn](...args);
+ }
+ );
+ }
+ };
+ }
+ });
+ head._scripts = head._scripts || {};
+ head._scripts[id] = instance;
+ return instance;
+}
+
+export { CapoPlugin, HashHydrationPlugin, createHead, createHeadCore, createServerHead, getActiveHead, unheadComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
diff --git a/.output/server/node_modules/vue-bundle-renderer/dist/runtime.mjs b/.output/server/node_modules/vue-bundle-renderer/dist/runtime.mjs
new file mode 100644
index 0000000..7a59541
--- /dev/null
+++ b/.output/server/node_modules/vue-bundle-renderer/dist/runtime.mjs
@@ -0,0 +1,196 @@
+import { withLeadingSlash } from 'ufo';
+
+function createRendererContext({ manifest, buildAssetsURL }) {
+ const ctx = {
+ // Manifest
+ buildAssetsURL: buildAssetsURL || withLeadingSlash,
+ manifest: void 0,
+ updateManifest,
+ // Internal cache
+ _dependencies: void 0,
+ _dependencySets: void 0,
+ _entrypoints: void 0
+ };
+ function updateManifest(manifest2) {
+ const manifestEntries = Object.entries(manifest2);
+ ctx.manifest = manifest2;
+ ctx._dependencies = {};
+ ctx._dependencySets = {};
+ ctx._entrypoints = manifestEntries.filter((e) => e[1].isEntry).map(([module]) => module);
+ }
+ updateManifest(manifest);
+ return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+ if (rendererContext._dependencies[id]) {
+ return rendererContext._dependencies[id];
+ }
+ const dependencies = rendererContext._dependencies[id] = {
+ scripts: {},
+ styles: {},
+ preload: {},
+ prefetch: {}
+ };
+ const meta = rendererContext.manifest[id];
+ if (!meta) {
+ return dependencies;
+ }
+ if (meta.file) {
+ dependencies.preload[id] = meta;
+ if (meta.isEntry || meta.sideEffects) {
+ dependencies.scripts[id] = meta;
+ }
+ }
+ for (const css of meta.css || []) {
+ dependencies.styles[css] = dependencies.preload[css] = dependencies.prefetch[css] = rendererContext.manifest[css];
+ }
+ for (const asset of meta.assets || []) {
+ dependencies.preload[asset] = dependencies.prefetch[asset] = rendererContext.manifest[asset];
+ }
+ for (const depId of meta.imports || []) {
+ const depDeps = getModuleDependencies(depId, rendererContext);
+ Object.assign(dependencies.styles, depDeps.styles);
+ Object.assign(dependencies.preload, depDeps.preload);
+ Object.assign(dependencies.prefetch, depDeps.prefetch);
+ }
+ const filteredPreload = {};
+ for (const id2 in dependencies.preload) {
+ const dep = dependencies.preload[id2];
+ if (dep.preload) {
+ filteredPreload[id2] = dep;
+ }
+ }
+ dependencies.preload = filteredPreload;
+ return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+ const cacheKey = Array.from(ids).sort().join(",");
+ if (rendererContext._dependencySets[cacheKey]) {
+ return rendererContext._dependencySets[cacheKey];
+ }
+ const allDeps = {
+ scripts: {},
+ styles: {},
+ preload: {},
+ prefetch: {}
+ };
+ for (const id of ids) {
+ const deps = getModuleDependencies(id, rendererContext);
+ Object.assign(allDeps.scripts, deps.scripts);
+ Object.assign(allDeps.styles, deps.styles);
+ Object.assign(allDeps.preload, deps.preload);
+ Object.assign(allDeps.prefetch, deps.prefetch);
+ for (const dynamicDepId of rendererContext.manifest[id]?.dynamicImports || []) {
+ const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+ Object.assign(allDeps.prefetch, dynamicDeps.scripts);
+ Object.assign(allDeps.prefetch, dynamicDeps.styles);
+ Object.assign(allDeps.prefetch, dynamicDeps.preload);
+ }
+ }
+ const filteredPrefetch = {};
+ for (const id in allDeps.prefetch) {
+ const dep = allDeps.prefetch[id];
+ if (dep.prefetch) {
+ filteredPrefetch[id] = dep;
+ }
+ }
+ allDeps.prefetch = filteredPrefetch;
+ for (const id in allDeps.preload) {
+ delete allDeps.prefetch[id];
+ }
+ for (const style in allDeps.styles) {
+ delete allDeps.preload[style];
+ delete allDeps.prefetch[style];
+ }
+ rendererContext._dependencySets[cacheKey] = allDeps;
+ return allDeps;
+}
+function getRequestDependencies(ssrContext, rendererContext) {
+ if (ssrContext._requestDependencies) {
+ return ssrContext._requestDependencies;
+ }
+ const ids = new Set(Array.from([
+ ...rendererContext._entrypoints,
+ ...ssrContext.modules || ssrContext._registeredComponents || []
+ ]));
+ const deps = getAllDependencies(ids, rendererContext);
+ ssrContext._requestDependencies = deps;
+ return deps;
+}
+function renderStyles(ssrContext, rendererContext) {
+ const { styles } = getRequestDependencies(ssrContext, rendererContext);
+ return Object.values(styles).map(
+ (resource) => renderLinkToString({ rel: "stylesheet", href: rendererContext.buildAssetsURL(resource.file) })
+ ).join("");
+}
+function getResources(ssrContext, rendererContext) {
+ return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext) {
+ return getResources(ssrContext, rendererContext).map(renderLinkToString).join("");
+}
+function renderResourceHeaders(ssrContext, rendererContext) {
+ return {
+ link: getResources(ssrContext, rendererContext).map(renderLinkToHeader).join(", ")
+ };
+}
+function getPreloadLinks(ssrContext, rendererContext) {
+ const { preload } = getRequestDependencies(ssrContext, rendererContext);
+ return Object.values(preload).map((resource) => ({
+ rel: resource.module ? "modulepreload" : "preload",
+ as: resource.resourceType,
+ type: resource.mimeType ?? null,
+ crossorigin: resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+ href: rendererContext.buildAssetsURL(resource.file)
+ }));
+}
+function getPrefetchLinks(ssrContext, rendererContext) {
+ const { prefetch } = getRequestDependencies(ssrContext, rendererContext);
+ return Object.values(prefetch).map((resource) => ({
+ rel: "prefetch",
+ as: resource.resourceType,
+ type: resource.mimeType ?? null,
+ crossorigin: resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+ href: rendererContext.buildAssetsURL(resource.file)
+ }));
+}
+function renderScripts(ssrContext, rendererContext) {
+ const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+ return Object.values(scripts).map((resource) => renderScriptToString({
+ type: resource.module ? "module" : null,
+ src: rendererContext.buildAssetsURL(resource.file),
+ defer: resource.module ? null : "",
+ crossorigin: ""
+ })).join("");
+}
+function createRenderer(createApp, renderOptions) {
+ const rendererContext = createRendererContext(renderOptions);
+ return {
+ rendererContext,
+ async renderToString(ssrContext) {
+ ssrContext._registeredComponents = ssrContext._registeredComponents || /* @__PURE__ */ new Set();
+ const _createApp = await Promise.resolve(createApp).then((r) => r.default || r);
+ const app = await _createApp(ssrContext);
+ const html = await renderOptions.renderToString(app, ssrContext);
+ const wrap = (fn) => () => fn(ssrContext, rendererContext);
+ return {
+ html,
+ renderResourceHeaders: wrap(renderResourceHeaders),
+ renderResourceHints: wrap(renderResourceHints),
+ renderStyles: wrap(renderStyles),
+ renderScripts: wrap(renderScripts)
+ };
+ }
+ };
+}
+function renderScriptToString(attrs) {
+ return `<script${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}><\/script>`;
+}
+function renderLinkToString(attrs) {
+ return `<link${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}>`;
+}
+function renderLinkToHeader(attrs) {
+ return `<${attrs.href}>${Object.entries(attrs).map(([key, value]) => key === "href" || value === null ? "" : value ? `; ${key}="${value}"` : `; ${key}`).join("")}`;
+}
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };
diff --git a/.output/server/node_modules/vue/dist/vue.cjs.js b/.output/server/node_modules/vue/dist/vue.cjs.js
new file mode 100644
index 0000000..7d00eb5
--- /dev/null
+++ b/.output/server/node_modules/vue/dist/vue.cjs.js
@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var runtimeDom = require('@vue/runtime-dom');
+var shared = require('@vue/shared');
+
+function _interopNamespaceDefault(e) {
+ var n = Object.create(null);
+ if (e) {
+ for (var k in e) {
+ n[k] = e[k];
+ }
+ }
+ n.default = e;
+ return Object.freeze(n);
+}
+
+var runtimeDom__namespace = /*#__PURE__*/_interopNamespaceDefault(runtimeDom);
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function compileToFunction(template, options) {
+ if (!shared.isString(template)) {
+ if (template.nodeType) {
+ template = template.innerHTML;
+ } else {
+ runtimeDom.warn(`invalid template option: `, template);
+ return shared.NOOP;
+ }
+ }
+ const key = template;
+ const cached = compileCache[key];
+ if (cached) {
+ return cached;
+ }
+ if (template[0] === "#") {
+ const el = document.querySelector(template);
+ if (!el) {
+ runtimeDom.warn(`Template element not found or is empty: ${template}`);
+ }
+ template = el ? el.innerHTML : ``;
+ }
+ const opts = shared.extend(
+ {
+ hoistStatic: true,
+ onError: onError ,
+ onWarn: (e) => onError(e, true)
+ },
+ options
+ );
+ if (!opts.isCustomElement && typeof customElements !== "undefined") {
+ opts.isCustomElement = (tag) => !!customElements.get(tag);
+ }
+ const { code } = compilerDom.compile(template, opts);
+ function onError(err, asWarning = false) {
+ const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
+ const codeFrame = err.loc && shared.generateCodeFrame(
+ template,
+ err.loc.start.offset,
+ err.loc.end.offset
+ );
+ runtimeDom.warn(codeFrame ? `${message}
+${codeFrame}` : message);
+ }
+ const render = new Function("Vue", code)(runtimeDom__namespace);
+ render._rc = true;
+ return compileCache[key] = render;
+}
+runtimeDom.registerRuntimeCompiler(compileToFunction);
+
+exports.compile = compileToFunction;
+Object.keys(runtimeDom).forEach(function (k) {
+ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
+});
diff --git a/.output/server/node_modules/vue/dist/vue.cjs.prod.js b/.output/server/node_modules/vue/dist/vue.cjs.prod.js
new file mode 100644
index 0000000..a23c7fc
--- /dev/null
+++ b/.output/server/node_modules/vue/dist/vue.cjs.prod.js
@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var runtimeDom = require('@vue/runtime-dom');
+var shared = require('@vue/shared');
+
+function _interopNamespaceDefault(e) {
+ var n = Object.create(null);
+ if (e) {
+ for (var k in e) {
+ n[k] = e[k];
+ }
+ }
+ n.default = e;
+ return Object.freeze(n);
+}
+
+var runtimeDom__namespace = /*#__PURE__*/_interopNamespaceDefault(runtimeDom);
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function compileToFunction(template, options) {
+ if (!shared.isString(template)) {
+ if (template.nodeType) {
+ template = template.innerHTML;
+ } else {
+ return shared.NOOP;
+ }
+ }
+ const key = template;
+ const cached = compileCache[key];
+ if (cached) {
+ return cached;
+ }
+ if (template[0] === "#") {
+ const el = document.querySelector(template);
+ template = el ? el.innerHTML : ``;
+ }
+ const opts = shared.extend(
+ {
+ hoistStatic: true,
+ onError: void 0,
+ onWarn: shared.NOOP
+ },
+ options
+ );
+ if (!opts.isCustomElement && typeof customElements !== "undefined") {
+ opts.isCustomElement = (tag) => !!customElements.get(tag);
+ }
+ const { code } = compilerDom.compile(template, opts);
+ const render = new Function("Vue", code)(runtimeDom__namespace);
+ render._rc = true;
+ return compileCache[key] = render;
+}
+runtimeDom.registerRuntimeCompiler(compileToFunction);
+
+exports.compile = compileToFunction;
+Object.keys(runtimeDom).forEach(function (k) {
+ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
+});