n8n-editor-ui 1.119.1 → 1.120.1

package/dist/assets/vue-legacy-Cj7LJTPA.js

@@ -0,0 +1,4579 @@
+;
+(function () {
+  System.register(["./chunk-legacy-Re9CbdfL.js", "./vue.runtime.esm-bundler-legacy-Bq05oSFs.js"], function (_export, _context) {
+    "use strict";
+
+    var __toCommonJS, __esm, __export, __commonJS, toHandlerKey, NOOP, EMPTY_OBJ, generateCodeFrame, capitalize, camelize, extend, init_runtime_dom_esm_bundler, parseStringStyle, isObject, isReservedProp, isSVGTag, makeMap, isVoidTag, isOn, isSymbol, isArray, isHTMLTag, isString, NO, isBuiltInDirective, runtime_dom_esm_bundler_exports, isMathMLTag, init_shared_esm_bundler, shared_esm_bundler_exports, FRAGMENT, TELEPORT, SUSPENSE, KEEP_ALIVE, BASE_TRANSITION, OPEN_BLOCK, CREATE_BLOCK, CREATE_ELEMENT_BLOCK, CREATE_VNODE, CREATE_ELEMENT_VNODE, CREATE_COMMENT, CREATE_TEXT, CREATE_STATIC, RESOLVE_COMPONENT, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_FILTER, WITH_DIRECTIVES, RENDER_LIST, RENDER_SLOT, CREATE_SLOTS, TO_DISPLAY_STRING, MERGE_PROPS, NORMALIZE_CLASS, NORMALIZE_STYLE, NORMALIZE_PROPS, GUARD_REACTIVE_PROPS, TO_HANDLERS, CAMELIZE, CAPITALIZE, TO_HANDLER_KEY, SET_BLOCK_TRACKING, PUSH_SCOPE_ID, POP_SCOPE_ID, WITH_CTX, UNREF, IS_REF, WITH_MEMO, IS_MEMO_SAME, helperNameMap, Namespaces, NodeTypes, ElementTypes, ConstantTypes, locStub, defaultDelimitersOpen, defaultDelimitersClose, Sequences, Tokenizer, CompilerDeprecationTypes, deprecationData, ErrorCodes, errorMessages, isFunctionType, isStaticProperty, isStaticPropertyKey, TS_NODE_TYPES, isStaticExp, nonIdentifierRE, isSimpleIdentifier, validFirstIdentCharRE, validIdentCharRE, whitespaceRE, getExpSource, isMemberExpressionBrowser, isMemberExpressionNode, isMemberExpression, fnExpRE, isFnExpressionBrowser, isFnExpressionNode, isFnExpression, propsHelperSet, forAliasRE, defaultParserOptions, currentOptions, currentRoot, currentInput, currentOpenTag, currentProp, currentAttrValue, currentAttrStartIndex, currentAttrEndIndex, inPre, inVPre, currentVPreBoundary, stack, tokenizer, forIteratorRE, stripParensRE, specialTemplateDir, windowsNewlineRE, allowHoistedHelperSet, PURE_ANNOTATION, aliasHelper, transformExpression, transformIf, transformBind, transformBindShorthand, injectPrefix, transformFor, defaultFallback, trackSlotScopes, trackVForSlotScopes, buildClientSlotFn, directiveImportMap, transformElement, transformSlotOutlet, transformOn, transformText, seen$1, transformOnce, transformModel, validDivisionCharRE, transformFilter, seen, transformMemo, BindingTypes, noopDirectiveTransform, init_compiler_core_esm_bundler, compiler_dom_esm_bundler_exports, V_MODEL_RADIO, V_MODEL_CHECKBOX, V_MODEL_TEXT, V_MODEL_SELECT, V_MODEL_DYNAMIC, V_ON_WITH_MODIFIERS, V_ON_WITH_KEYS, V_SHOW, TRANSITION, TRANSITION_GROUP, decoder, parserOptions, transformStyle, parseInlineCSS, DOMErrorCodes, DOMErrorMessages, transformVHtml, transformVText, transformModel$1, isEventOptionModifier, isNonKeyModifier, maybeKeyModifier, isKeyboardEvent, resolveModifiers, transformClick, transformOn$1, transformShow, ignoreSideEffectTags, DOMNodeTransforms, DOMDirectiveTransforms, init_compiler_dom_esm_bundler, require_vue_cjs_prod, require_vue;
+    //#region ../../../node_modules/.pnpm/@vue+compiler-core@3.5.13/node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js
+    function registerRuntimeHelpers(helpers) {
+      Object.getOwnPropertySymbols(helpers).forEach(s => {
+        helperNameMap[s] = helpers[s];
+      });
+    }
+    function createRoot(children, source = "") {
+      return {
+        type: 0,
+        source,
+        children,
+        helpers: /* @__PURE__ */new Set(),
+        components: [],
+        directives: [],
+        hoists: [],
+        imports: [],
+        cached: [],
+        temps: 0,
+        codegenNode: void 0,
+        loc: locStub
+      };
+    }
+    function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent$1 = false, loc = locStub) {
+      if (context) {
+        if (isBlock) {
+          context.helper(OPEN_BLOCK);
+          context.helper(getVNodeBlockHelper(context.inSSR, isComponent$1));
+        } else context.helper(getVNodeHelper(context.inSSR, isComponent$1));
+        if (directives) context.helper(WITH_DIRECTIVES);
+      }
+      return {
+        type: 13,
+        tag,
+        props,
+        children,
+        patchFlag,
+        dynamicProps,
+        directives,
+        isBlock,
+        disableTracking,
+        isComponent: isComponent$1,
+        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: 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: 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, needPauseTracking = false, inVOnce = false) {
+      return {
+        type: 20,
+        index,
+        value,
+        needPauseTracking,
+        inVOnce,
+        needArraySpread: false,
+        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$1) {
+      return ssr || isComponent$1 ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
+    }
+    function getVNodeBlockHelper(ssr, isComponent$1) {
+      return ssr || isComponent$1 ? 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));
+      }
+    }
+    function isTagStartChar(c) {
+      return c >= 97 && c <= 122 || c >= 65 && c <= 90;
+    }
+    function isWhitespace(c) {
+      return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
+    }
+    function isEndOfTagSection(c) {
+      return c === 47 || c === 62 || isWhitespace(c);
+    }
+    function toCharCodes(str) {
+      const ret = new Uint8Array(str.length);
+      for (let i = 0; i < str.length; i++) ret[i] = str.charCodeAt(i);
+      return ret;
+    }
+    function getCompatValue(key, {
+      compatConfig
+    }) {
+      const value = compatConfig && compatConfig[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) {
+      return isCompatEnabled(key, context);
+    }
+    function warnDeprecation(key, context, loc, ...args) {
+      if (getCompatValue(key, context) === "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);
+    }
+    function defaultOnError(error) {
+      throw error;
+    }
+    function defaultOnWarn(msg) {}
+    function createCompilerError(code, loc, messages, additionalMessage) {
+      const msg = `https://vuejs.org/error-reference/#compiler-${code}`;
+      const error = new SyntaxError(String(msg));
+      error.code = code;
+      error.loc = loc;
+      return error;
+    }
+    function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */Object.create(null)) {}
+    function isReferencedIdentifier(id, 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 isInNewExpression(parentStack) {
+      let i = parentStack.length;
+      while (i--) {
+        const p = parentStack[i];
+        if (p.type === "NewExpression") return true;else if (p.type !== "MemberExpression") 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 (isForStatement(stmt)) walkForStatement(stmt, true, onIdent);
+    }
+    function isForStatement(stmt) {
+      return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
+    }
+    function walkForStatement(stmt, isVar, onIdent) {
+      const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+      if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) 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 unwrapTSNode(node) {
+      if (TS_NODE_TYPES.includes(node.type)) return unwrapTSNode(node.expression);else return node;
+    }
+    function isCoreComponent(tag) {
+      switch (tag) {
+        case "Teleport":
+        case "teleport":
+          return TELEPORT;
+        case "Suspense":
+        case "suspense":
+          return SUSPENSE;
+        case "KeepAlive":
+        case "keep-alive":
+          return KEEP_ALIVE;
+        case "BaseTransition":
+        case "base-transition":
+          return BASE_TRANSITION;
+      }
+    }
+    function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
+      return advancePositionWithMutation({
+        offset: pos.offset,
+        line: pos.line,
+        column: pos.column
+      }, 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) && (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 || p.arg.type !== 4 || !p.arg.isStatic));
+    }
+    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;
+    }
+    function getUnnormalizedProps(props, callPath = []) {
+      if (props && !isString(props) && props.type === 14) {
+        const callee = props.callee;
+        if (!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 && !isString(props) && props.type === 14) {
+        const ret = getUnnormalizedProps(props);
+        props = ret[0];
+        callPath = ret[1];
+        parentCall = callPath[callPath.length - 1];
+      }
+      if (props == null || isString(props)) propsWithInjection = createObjectExpression([prop]);else if (props.type === 14) {
+        const first = props.arguments[0];
+        if (!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 => isObject(c) && hasScopeRef(c, ids));
+        case 5:
+        case 12:
+          return hasScopeRef(node.content, ids);
+        case 2:
+        case 3:
+        case 20:
+          return false;
+        default:
+          return false;
+      }
+    }
+    function getMemoedVNodeCall(node) {
+      if (node.type === 14 && node.callee === WITH_MEMO) return node.arguments[1].returns;else return node;
+    }
+    function parseForExpression(input) {
+      const loc = input.loc;
+      const exp = input.content;
+      const inMatch = exp.match(forAliasRE);
+      if (!inMatch) return;
+      const [, LHS, RHS] = inMatch;
+      const createAliasExpression = (content, offset, asParam = false) => {
+        const start = loc.start.offset + offset;
+        return createExp(content, false, getLoc(start, start + content.length), 0, asParam ? 1 : 0);
+      };
+      const result = {
+        source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
+        value: void 0,
+        key: void 0,
+        index: void 0,
+        finalized: false
+      };
+      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(keyContent, keyOffset, true);
+        }
+        if (iteratorMatch[2]) {
+          const indexContent = iteratorMatch[2].trim();
+          if (indexContent) result.index = createAliasExpression(indexContent, exp.indexOf(indexContent, result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length), true);
+        }
+      }
+      if (valueContent) result.value = createAliasExpression(valueContent, trimmedOffset, true);
+      return result;
+    }
+    function getSlice(start, end) {
+      return currentInput.slice(start, end);
+    }
+    function endOpenTag(end) {
+      if (tokenizer.inSFCRoot) currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
+      addNode(currentOpenTag);
+      const {
+        tag,
+        ns
+      } = currentOpenTag;
+      if (ns === 0 && currentOptions.isPreTag(tag)) inPre++;
+      if (currentOptions.isVoidTag(tag)) onCloseTag(currentOpenTag, end);else {
+        stack.unshift(currentOpenTag);
+        if (ns === 1 || ns === 2) tokenizer.inXML = true;
+      }
+      currentOpenTag = null;
+    }
+    function onText(content, start, end) {
+      {
+        const tag = stack[0] && stack[0].tag;
+        if (tag !== "script" && tag !== "style" && content.includes("&")) content = currentOptions.decodeEntities(content, false);
+      }
+      const parent = stack[0] || currentRoot;
+      const lastNode = parent.children[parent.children.length - 1];
+      if (lastNode && lastNode.type === 2) {
+        lastNode.content += content;
+        setLocEnd(lastNode.loc, end);
+      } else parent.children.push({
+        type: 2,
+        content,
+        loc: getLoc(start, end)
+      });
+    }
+    function onCloseTag(el, end, isImplied = false) {
+      if (isImplied) setLocEnd(el.loc, backTrack(end, 60));else setLocEnd(el.loc, lookAhead(end, 62) + 1);
+      if (tokenizer.inSFCRoot) {
+        if (el.children.length) el.innerLoc.end = extend({}, el.children[el.children.length - 1].loc.end);else el.innerLoc.end = extend({}, el.innerLoc.start);
+        el.innerLoc.source = getSlice(el.innerLoc.start.offset, el.innerLoc.end.offset);
+      }
+      const {
+        tag,
+        ns,
+        children
+      } = el;
+      if (!inVPre) {
+        if (tag === "slot") el.tagType = 2;else if (isFragmentTemplate(el)) el.tagType = 3;else if (isComponent(el)) el.tagType = 1;
+      }
+      if (!tokenizer.inRCDATA) el.children = condenseWhitespace(children);
+      if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
+        const first = children[0];
+        if (first && first.type === 2) first.content = first.content.replace(/^\r?\n/, "");
+      }
+      if (ns === 0 && currentOptions.isPreTag(tag)) inPre--;
+      if (currentVPreBoundary === el) {
+        inVPre = tokenizer.inVPre = false;
+        currentVPreBoundary = null;
+      }
+      if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) tokenizer.inXML = false;
+      {
+        const props = el.props;
+        if (!tokenizer.inSFCRoot && isCompatEnabled("COMPILER_NATIVE_TEMPLATE", currentOptions) && el.tag === "template" && !isFragmentTemplate(el)) {
+          const parent = stack[0] || currentRoot;
+          const index = parent.children.indexOf(el);
+          parent.children.splice(index, 1, ...el.children);
+        }
+        const inlineTemplateProp = props.find(p => p.type === 6 && p.name === "inline-template");
+        if (inlineTemplateProp && checkCompatEnabled("COMPILER_INLINE_TEMPLATE", currentOptions, inlineTemplateProp.loc) && el.children.length) inlineTemplateProp.value = {
+          type: 2,
+          content: getSlice(el.children[0].loc.start.offset, el.children[el.children.length - 1].loc.end.offset),
+          loc: inlineTemplateProp.loc
+        };
+      }
+    }
+    function lookAhead(index, c) {
+      let i = index;
+      while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
+      return i;
+    }
+    function backTrack(index, c) {
+      let i = index;
+      while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
+      return i;
+    }
+    function isFragmentTemplate({
+      tag,
+      props
+    }) {
+      if (tag === "template") {
+        for (let i = 0; i < props.length; i++) if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) return true;
+      }
+      return false;
+    }
+    function isComponent({
+      tag,
+      props
+    }) {
+      if (currentOptions.isCustomElement(tag)) return false;
+      if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.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", currentOptions, p.loc)) return true;
+          }
+        } else if (p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions, p.loc)) return true;
+      }
+      return false;
+    }
+    function isUpperCase(c) {
+      return c > 64 && c < 91;
+    }
+    function condenseWhitespace(nodes, tag) {
+      const shouldCondense = currentOptions.whitespace !== "preserve";
+      let removedWhitespace = false;
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node.type === 2) if (!inPre) {
+          if (isAllWhitespace(node.content)) {
+            const prev = nodes[i - 1] && nodes[i - 1].type;
+            const next = nodes[i + 1] && nodes[i + 1].type;
+            if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
+              removedWhitespace = true;
+              nodes[i] = null;
+            } else node.content = " ";
+          } else if (shouldCondense) node.content = condense(node.content);
+        } else node.content = node.content.replace(windowsNewlineRE, "\n");
+      }
+      return removedWhitespace ? nodes.filter(Boolean) : nodes;
+    }
+    function isAllWhitespace(str) {
+      for (let i = 0; i < str.length; i++) if (!isWhitespace(str.charCodeAt(i))) return false;
+      return true;
+    }
+    function hasNewlineChar(str) {
+      for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
+        if (c === 10 || c === 13) return true;
+      }
+      return false;
+    }
+    function condense(str) {
+      let ret = "";
+      let prevCharIsWhitespace = false;
+      for (let i = 0; i < str.length; i++) if (isWhitespace(str.charCodeAt(i))) {
+        if (!prevCharIsWhitespace) {
+          ret += " ";
+          prevCharIsWhitespace = true;
+        }
+      } else {
+        ret += str[i];
+        prevCharIsWhitespace = false;
+      }
+      return ret;
+    }
+    function addNode(node) {
+      (stack[0] || currentRoot).children.push(node);
+    }
+    function getLoc(start, end) {
+      return {
+        start: tokenizer.getPos(start),
+        end: end == null ? end : tokenizer.getPos(end),
+        source: end == null ? end : getSlice(start, end)
+      };
+    }
+    function cloneLoc(loc) {
+      return getLoc(loc.start.offset, loc.end.offset);
+    }
+    function setLocEnd(loc, end) {
+      loc.end = tokenizer.getPos(end);
+      loc.source = getSlice(loc.start.offset, end);
+    }
+    function dirToAttr(dir) {
+      const attr = {
+        type: 6,
+        name: dir.rawName,
+        nameLoc: getLoc(dir.loc.start.offset, dir.loc.start.offset + dir.rawName.length),
+        value: void 0,
+        loc: dir.loc
+      };
+      if (dir.exp) {
+        const loc = dir.exp.loc;
+        if (loc.end.offset < dir.loc.end.offset) {
+          loc.start.offset--;
+          loc.start.column--;
+          loc.end.offset++;
+          loc.end.column++;
+        }
+        attr.value = {
+          type: 2,
+          content: dir.exp.content,
+          loc
+        };
+      }
+      return attr;
+    }
+    function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0) {
+      return createSimpleExpression(content, isStatic, loc, constType);
+    }
+    function emitError(code, index, message) {
+      currentOptions.onError(createCompilerError(code, getLoc(index, index), void 0, message));
+    }
+    function reset() {
+      tokenizer.reset();
+      currentOpenTag = null;
+      currentProp = null;
+      currentAttrValue = "";
+      currentAttrStartIndex = -1;
+      currentAttrEndIndex = -1;
+      stack.length = 0;
+    }
+    function baseParse(input, options) {
+      reset();
+      currentInput = input;
+      currentOptions = extend({}, defaultParserOptions);
+      if (options) {
+        let key;
+        for (key in options) if (options[key] != null) currentOptions[key] = options[key];
+      }
+      tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
+      tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
+      const delimiters = options && options.delimiters;
+      if (delimiters) {
+        tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
+        tokenizer.delimiterClose = toCharCodes(delimiters[1]);
+      }
+      const root = currentRoot = createRoot([], input);
+      tokenizer.parse(currentInput);
+      root.loc = getLoc(0, input.length);
+      root.children = condenseWhitespace(root.children);
+      currentRoot = null;
+      return root;
+    }
+    function cacheStatic(root, context) {
+      walk(root, void 0, context, isSingleElementRoot(root, root.children[0]));
+    }
+    function isSingleElementRoot(root, child) {
+      const {
+        children
+      } = root;
+      return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
+    }
+    function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
+      const {
+        children
+      } = node;
+      const toCache = [];
+      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;
+              toCache.push(child);
+              continue;
+            }
+          } else {
+            const codegenNode = child.codegenNode;
+            if (codegenNode.type === 13) {
+              const flag = codegenNode.patchFlag;
+              if ((flag === void 0 || 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);
+            }
+          }
+        } else if (child.type === 12) {
+          if ((doNotHoistNode ? 0 : getConstantType(child, context)) >= 2) {
+            toCache.push(child);
+            continue;
+          }
+        }
+        if (child.type === 1) {
+          const isComponent$1 = child.tagType === 1;
+          if (isComponent$1) context.scopes.vSlot++;
+          walk(child, node, context, false, inFor);
+          if (isComponent$1) context.scopes.vSlot--;
+        } else if (child.type === 11) walk(child, node, context, child.children.length === 1, true);else if (child.type === 9) for (let i2 = 0; i2 < child.branches.length; i2++) walk(child.branches[i2], node, context, child.branches[i2].children.length === 1, inFor);
+      }
+      let cachedAsArray = false;
+      if (toCache.length === children.length && node.type === 1) {
+        if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
+          node.codegenNode.children = getCacheExpression(createArrayExpression(node.codegenNode.children));
+          cachedAsArray = true;
+        } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
+          const slot = getSlotNode(node.codegenNode, "default");
+          if (slot) {
+            slot.returns = getCacheExpression(createArrayExpression(slot.returns));
+            cachedAsArray = true;
+          }
+        } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
+          const slotName = findDir(node, "slot", true);
+          const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
+          if (slot) {
+            slot.returns = getCacheExpression(createArrayExpression(slot.returns));
+            cachedAsArray = true;
+          }
+        }
+      }
+      if (!cachedAsArray) for (const child of toCache) child.codegenNode = context.cache(child.codegenNode);
+      function getCacheExpression(value) {
+        const exp = context.cache(value);
+        if (inFor && context.hmr) exp.needArraySpread = true;
+        return exp;
+      }
+      function getSlotNode(node2, name) {
+        if (node2.children && !isArray(node2.children) && node2.children.type === 15) {
+          const slot = node2.children.properties.find(p => p.key === name || p.key.content === name);
+          return slot && slot.value;
+        }
+      }
+      if (toCache.length && context.transformHoist) context.transformHoist(children, context, node);
+    }
+    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" && node.tag !== "math") return 0;
+          if (codegenNode.patchFlag === void 0) {
+            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++) if (node.props[i].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 (isString(child) || isSymbol(child)) continue;
+            const childType = getConstantType(child, context);
+            if (childType === 0) return 0;else if (childType < returnType) returnType = childType;
+          }
+          return returnType;
+        case 20:
+          return 2;
+        default:
+          return 0;
+      }
+    }
+    function getConstantTypeOfHelperCall(value, context) {
+      if (value.type === 14 && !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 createTransformContext(root, {
+      filename = "",
+      prefixIdentifiers = false,
+      hoistStatic = false,
+      hmr = false,
+      cacheHandlers = false,
+      nodeTransforms = [],
+      directiveTransforms = {},
+      transformHoist = null,
+      isBuiltInComponent = NOOP,
+      isCustomElement = NOOP,
+      expressionPlugins = [],
+      scopeId = null,
+      slotted = true,
+      ssr = false,
+      inSSR = false,
+      ssrCssVars = ``,
+      bindingMetadata = EMPTY_OBJ,
+      inline = false,
+      isTS = false,
+      onError = defaultOnError,
+      onWarn = defaultOnWarn,
+      compatConfig
+    }) {
+      const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
+      const context = {
+        filename,
+        selfName: nameMatch && capitalize(camelize(nameMatch[1])),
+        prefixIdentifiers,
+        hoistStatic,
+        hmr,
+        cacheHandlers,
+        nodeTransforms,
+        directiveTransforms,
+        transformHoist,
+        isBuiltInComponent,
+        isCustomElement,
+        expressionPlugins,
+        scopeId,
+        slotted,
+        ssr,
+        inSSR,
+        ssrCssVars,
+        bindingMetadata,
+        inline,
+        isTS,
+        onError,
+        onWarn,
+        compatConfig,
+        root,
+        helpers: /* @__PURE__ */new Map(),
+        components: /* @__PURE__ */new Set(),
+        directives: /* @__PURE__ */new Set(),
+        hoists: [],
+        imports: [],
+        cached: [],
+        constantCache: /* @__PURE__ */new WeakMap(),
+        temps: 0,
+        identifiers: /* @__PURE__ */Object.create(null),
+        scopes: {
+          vFor: 0,
+          vSlot: 0,
+          vPre: 0,
+          vOnce: 0
+        },
+        parent: null,
+        grandParent: null,
+        currentNode: root,
+        childIndex: 0,
+        inVOnce: false,
+        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: NOOP,
+        addIdentifiers(exp) {},
+        removeIdentifiers(exp) {},
+        hoist(exp) {
+          if (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, inVOnce = false) {
+          const cacheExp = createCacheExpression(context.cached.length, exp, isVNode, inVOnce);
+          context.cached.push(cacheExp);
+          return cacheExp;
+        }
+      };
+      context.filters = /* @__PURE__ */new Set();
+      return context;
+    }
+    function transform(root, options) {
+      const context = createTransformContext(root, options);
+      traverseNode(root, context);
+      if (options.hoistStatic) cacheStatic(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.transformed = true;
+      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) root.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, root.children, 64, void 0, void 0, true, void 0, false);
+    }
+    function traverseChildren(parent, context) {
+      let i = 0;
+      const nodeRemoved = () => {
+        i--;
+      };
+      for (; i < parent.children.length; i++) {
+        const child = parent.children[i];
+        if (isString(child)) continue;
+        context.grandParent = context.parent;
+        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 (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 = 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;
+        }
+      };
+    }
+    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.source,
+        code: ``,
+        column: 1,
+        line: 1,
+        offset: 0,
+        indentLevel: 0,
+        pure: false,
+        map: void 0,
+        helper(key) {
+          return `_${helperNameMap[key]}`;
+        },
+        push(code, newlineIndex = -2, node) {
+          context.code += code;
+        },
+        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), 0);
+      }
+      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";
+      genFunctionPreamble(ast, context);
+      push(`function ${ssr ? `ssrRender` : `render`}(${(ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"]).join(", ")}) {`);
+      indent();
+      if (useWithBlock) {
+        push(`with (_ctx) {`);
+        indent();
+        if (hasHelpers) {
+          push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
+`, -1);
+          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(`
+`, 0);
+        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: ``,
+        map: context.map ? context.map.toJSON() : void 0
+      };
+    }
+    function genFunctionPreamble(ast, context) {
+      const {
+        ssr,
+        prefixIdentifiers,
+        push,
+        newline,
+        runtimeModuleName,
+        runtimeGlobalName,
+        ssrRuntimeModuleName
+      } = context;
+      const VueBinding = runtimeGlobalName;
+      const helpers = Array.from(ast.helpers);
+      if (helpers.length > 0) {
+        push(`const _Vue = ${VueBinding}
+`, -1);
+        if (ast.hoists.length) push(`const { ${[CREATE_VNODE, CREATE_ELEMENT_VNODE, CREATE_COMMENT, CREATE_TEXT, CREATE_STATIC].filter(helper => helpers.includes(helper)).map(aliasHelper).join(", ")} } = _Vue
+`, -1);
+      }
+      genHoists(ast.hoists, context);
+      newline();
+      push(`return `);
+    }
+    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
+      } = context;
+      newline();
+      for (let i = 0; i < hoists.length; i++) {
+        const exp = hoists[i];
+        if (exp) {
+          push(`const _hoisted_${i + 1} = `);
+          genNode(exp, context);
+          newline();
+        }
+      }
+      context.pure = false;
+    }
+    function genNodeListAsArray(nodes, context) {
+      const multilines = nodes.length > 3 || false;
+      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 (isString(node)) push(node, -3);else if (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 (isString(node)) {
+        context.push(node, -3);
+        return;
+      }
+      if (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:
+          break;
+        case 23:
+          break;
+        case 24:
+          break;
+        case 25:
+          break;
+        case 26:
+          break;
+        case 10:
+          break;
+        default:
+      }
+    }
+    function genText(node, context) {
+      context.push(JSON.stringify(node.content), -3, node);
+    }
+    function genExpression(node, context) {
+      const {
+        content,
+        isStatic
+      } = node;
+      context.push(isStatic ? JSON.stringify(content) : content, -3, 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 (isString(child)) context.push(child, -3);else genNode(child, context);
+      }
+    }
+    function genExpressionAsPropertyKey(node, context) {
+      const {
+        push
+      } = context;
+      if (node.type === 8) {
+        push(`[`);
+        genCompoundExpression(node, context);
+        push(`]`);
+      } else if (node.isStatic) push(isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content), -2, node);else push(`[${node.content}]`, -3, node);
+    }
+    function genComment(node, context) {
+      const {
+        push,
+        helper,
+        pure
+      } = context;
+      if (pure) push(PURE_ANNOTATION);
+      push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, -3, node);
+    }
+    function genVNodeCall(node, context) {
+      const {
+        push,
+        helper,
+        pure
+      } = context;
+      const {
+        tag,
+        props,
+        children,
+        patchFlag,
+        dynamicProps,
+        directives,
+        isBlock,
+        disableTracking,
+        isComponent: isComponent$1
+      } = node;
+      let patchFlagString;
+      if (patchFlag) patchFlagString = String(patchFlag);
+      if (directives) push(helper(WITH_DIRECTIVES) + `(`);
+      if (isBlock) push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
+      if (pure) push(PURE_ANNOTATION);
+      push(helper(isBlock ? getVNodeBlockHelper(context.inSSR, isComponent$1) : getVNodeHelper(context.inSSR, isComponent$1)) + `(`, -2, node);
+      genNodeList(genNullableArgs([tag, props, children, patchFlagString, 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 = isString(node.callee) ? node.callee : helper(node.callee);
+      if (pure) push(PURE_ANNOTATION);
+      push(callee + `(`, -2, node);
+      genNodeList(node.arguments, context);
+      push(`)`);
+    }
+    function genObjectExpression(node, context) {
+      const {
+        push,
+        indent,
+        deindent,
+        newline
+      } = context;
+      const {
+        properties
+      } = node;
+      if (!properties.length) {
+        push(`{}`, -2, node);
+        return;
+      }
+      const multilines = properties.length > 1 || false;
+      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(`(`, -2, node);
+      if (isArray(params)) genNodeList(params, context);else if (params) genNode(params, context);
+      push(`) => `);
+      if (newline || body) {
+        push(`{`);
+        indent();
+      }
+      if (returns) {
+        if (newline) push(`return `);
+        if (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);
+    }
+    function genCacheExpression(node, context) {
+      const {
+        push,
+        helper,
+        indent,
+        deindent,
+        newline
+      } = context;
+      const {
+        needPauseTracking,
+        needArraySpread
+      } = node;
+      if (needArraySpread) push(`[...(`);
+      push(`_cache[${node.index}] || (`);
+      if (needPauseTracking) {
+        indent();
+        push(`${helper(SET_BLOCK_TRACKING)}(-1`);
+        if (node.inVOnce) push(`, true`);
+        push(`),`);
+        newline();
+        push(`(`);
+      }
+      push(`_cache[${node.index}] = `);
+      genNode(node.value, context);
+      if (needPauseTracking) {
+        push(`).cacheIndex = ${node.index},`);
+        newline();
+        push(`${helper(SET_BLOCK_TRACKING)}(1),`);
+        newline();
+        push(`_cache[${node.index}]`);
+        deindent();
+      }
+      push(`)`);
+      if (needArraySpread) push(`)]`);
+    }
+    function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
+      return node;
+    }
+    function stringifyExpression(exp) {
+      if (isString(exp)) return exp;else if (exp.type === 4) return exp.content;else return exp.children.map(stringifyExpression).join("");
+    }
+    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 (dir.name === "if") {
+        const branch = createIfBranch(node, dir);
+        const ifNode = {
+          type: 9,
+          loc: cloneLoc(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);
+            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), 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];
+      if (children.length !== 1 || firstChild.type !== 1) {
+        if (children.length === 1 && firstChild.type === 11) {
+          const vnodeCall = firstChild.codegenNode;
+          injectProp(vnodeCall, keyProperty, context);
+          return vnodeCall;
+        } else return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, 64, 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 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;
+    }
+    function processFor(node, dir, context, processCodegen) {
+      if (!dir.exp) {
+        context.onError(createCompilerError(31, dir.loc));
+        return;
+      }
+      const parseResult = dir.forParseResult;
+      if (!parseResult) {
+        context.onError(createCompilerError(32, dir.loc));
+        return;
+      }
+      finalizeForParseResult(parseResult, context);
+      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++;
+      const onExit = processCodegen && processCodegen(forNode);
+      return () => {
+        scopes.vFor--;
+        if (onExit) onExit();
+      };
+    }
+    function finalizeForParseResult(result, context) {
+      if (result.finalized) return;
+      result.finalized = true;
+    }
+    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));
+    }
+    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;
+      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, 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)) {
+          let j = i;
+          let prev;
+          while (j--) {
+            prev = children[j];
+            if (prev.type !== 3) break;
+          }
+          if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
+            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.forParseResult;
+          if (parseResult) {
+            finalizeForParseResult(parseResult, context);
+            dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [parseResult.source, createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true)]));
+          } 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 && 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(`_`, 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);
+    }
+    function resolveComponentType(node, context, ssr = false) {
+      let {
+        tag
+      } = node;
+      const isExplicitDynamic = isComponentTag(tag);
+      const isProp = findProp(node, "is", false, true);
+      if (isProp) {
+        if (isExplicitDynamic || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context)) {
+          let exp;
+          if (isProp.type === 6) exp = isProp.value && createSimpleExpression(isProp.value.content, true);else {
+            exp = isProp.exp;
+            if (!exp) exp = createSimpleExpression(`is`, false, isProp.arg.loc);
+          }
+          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 builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
+      if (builtIn) {
+        if (!ssr) context.helper(builtIn);
+        return builtIn;
+      }
+      context.helper(RESOLVE_COMPONENT);
+      context.components.add(tag);
+      return toValidAssetId(tag, `component`);
+    }
+    function buildProps(node, context, props = node.props, isComponent$1, 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 pushRefVForMarker = () => {
+        if (context.scopes.vFor > 0) properties.push(createObjectProperty(createSimpleExpression("ref_for", true), createSimpleExpression("true")));
+      };
+      const analyzePatchFlag = ({
+        key,
+        value
+      }) => {
+        if (isStaticExp(key)) {
+          const name = key.content;
+          const isEventHandler = isOn(name);
+          if (isEventHandler && (!isComponent$1 || isDynamicComponent) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue" && !isReservedProp(name)) hasHydrationEventBinding = true;
+          if (isEventHandler && isReservedProp(name)) hasVnodeHook = true;
+          if (isEventHandler && value.type === 14) value = value.arguments[0];
+          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$1 && (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,
+            nameLoc,
+            value
+          } = prop;
+          let isStatic = true;
+          if (name === "ref") {
+            hasRef = true;
+            pushRefVForMarker();
+          }
+          if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
+          properties.push(createObjectProperty(createSimpleExpression(name, true, nameLoc), 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$1) 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 (isVBind && isStaticArgOf(arg, "key") || isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")) shouldUseBlock = true;
+          if (isVBind && isStaticArgOf(arg, "ref")) pushRefVForMarker();
+          if (!arg && (isVBind || isVOn)) {
+            hasDynamicKeys = true;
+            if (exp) {
+              if (isVBind) {
+                pushRefVForMarker();
+                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$1 ? [exp] : [exp, `true`]
+              });
+            } else context.onError(createCompilerError(isVBind ? 34 : 35, loc));
+            continue;
+          }
+          if (isVBind && modifiers.some(mod => mod.content === "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 (isSymbol(needRuntime)) directiveImportMap.set(prop, needRuntime);
+            }
+          } else if (!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$1) patchFlag |= 2;
+        if (hasStyleBinding && !isComponent$1) 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 && (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || 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" || 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 {
+        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";
+    }
+    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 = camelize(p.name);
+            nonNameProps.push(p);
+          }
+        } else if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
+          if (p.exp) slotName = p.exp;else if (p.arg && p.arg.type === 4) slotName = p.exp = createSimpleExpression(camelize(p.arg.content), false, p.arg.loc);
+        } else {
+          if (p.name === "bind" && p.arg && isStaticExp(p.arg)) p.arg.content = 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
+      };
+    }
+    function createTransformProps(props = []) {
+      return {
+        props
+      };
+    }
+    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 && 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;
+        node.ast = void 0;
+      }
+    }
+    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}`;
+      }
+    }
+    function getBaseTransformPreset(prefixIdentifiers) {
+      return [[transformOnce, transformIf, transformMemo, transformFor, ...[transformFilter], ...[], transformSlotOutlet, transformElement, trackSlotScopes, transformText], {
+        on: transformOn,
+        bind: transformBind,
+        model: transformModel
+      }];
+    }
+    function baseCompile(source, options = {}) {
+      const onError = options.onError || defaultOnError;
+      const isModuleMode = options.mode === "module";
+      if (options.prefixIdentifiers === true) onError(createCompilerError(47));else if (isModuleMode) onError(createCompilerError(48));
+      const prefixIdentifiers = false;
+      if (options.cacheHandlers) onError(createCompilerError(49));
+      if (options.scopeId && !isModuleMode) onError(createCompilerError(50));
+      const resolvedOptions = extend({}, options, {
+        prefixIdentifiers
+      });
+      const ast = isString(source) ? baseParse(source, resolvedOptions) : source;
+      const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
+      transform(ast, extend({}, resolvedOptions, {
+        nodeTransforms: [...nodeTransforms, ...(options.nodeTransforms || [])],
+        directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {})
+      }));
+      return generate(ast, resolvedOptions);
+    }
+    function decodeHtmlBrowser(raw, asAttr = false) {
+      if (!decoder) decoder = document.createElement("div");
+      if (asAttr) {
+        decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
+        return decoder.children[0].getAttribute("foo");
+      } else {
+        decoder.innerHTML = raw;
+        return decoder.textContent;
+      }
+    }
+    function createDOMCompilerError(code, loc) {
+      return createCompilerError(code, loc, void 0);
+    }
+    function compile(src, options = {}) {
+      return baseCompile(src, extend({}, parserOptions, options, {
+        nodeTransforms: [ignoreSideEffectTags, ...DOMNodeTransforms, ...(options.nodeTransforms || [])],
+        directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
+        transformHoist: null
+      }));
+    }
+    function parse(template, options = {}) {
+      return baseParse(template, extend({}, parserOptions, options));
+    }
+    return {
+      setters: [function (_chunkLegacy001Js) {
+        __toCommonJS = _chunkLegacy001Js.a;
+        __esm = _chunkLegacy001Js.n;
+        __export = _chunkLegacy001Js.r;
+        __commonJS = _chunkLegacy001Js.t;
+      }, function (_vueRuntimeEsmBundlerLegacy003Js) {
+        toHandlerKey = _vueRuntimeEsmBundlerLegacy003Js.Cn;
+        NOOP = _vueRuntimeEsmBundlerLegacy003Js.Jt;
+        EMPTY_OBJ = _vueRuntimeEsmBundlerLegacy003Js.Kt;
+        generateCodeFrame = _vueRuntimeEsmBundlerLegacy003Js.Qt;
+        capitalize = _vueRuntimeEsmBundlerLegacy003Js.Xt;
+        camelize = _vueRuntimeEsmBundlerLegacy003Js.Yt;
+        extend = _vueRuntimeEsmBundlerLegacy003Js.Zt;
+        init_runtime_dom_esm_bundler = _vueRuntimeEsmBundlerLegacy003Js.a;
+        parseStringStyle = _vueRuntimeEsmBundlerLegacy003Js.bn;
+        isObject = _vueRuntimeEsmBundlerLegacy003Js.cn;
+        isReservedProp = _vueRuntimeEsmBundlerLegacy003Js.dn;
+        isSVGTag = _vueRuntimeEsmBundlerLegacy003Js.fn;
+        makeMap = _vueRuntimeEsmBundlerLegacy003Js.gn;
+        isVoidTag = _vueRuntimeEsmBundlerLegacy003Js.hn;
+        isOn = _vueRuntimeEsmBundlerLegacy003Js.ln;
+        isSymbol = _vueRuntimeEsmBundlerLegacy003Js.mn;
+        isArray = _vueRuntimeEsmBundlerLegacy003Js.nn;
+        isHTMLTag = _vueRuntimeEsmBundlerLegacy003Js.on;
+        isString = _vueRuntimeEsmBundlerLegacy003Js.pn;
+        NO = _vueRuntimeEsmBundlerLegacy003Js.qt;
+        isBuiltInDirective = _vueRuntimeEsmBundlerLegacy003Js.rn;
+        runtime_dom_esm_bundler_exports = _vueRuntimeEsmBundlerLegacy003Js.s;
+        isMathMLTag = _vueRuntimeEsmBundlerLegacy003Js.sn;
+        init_shared_esm_bundler = _vueRuntimeEsmBundlerLegacy003Js.tn;
+        shared_esm_bundler_exports = _vueRuntimeEsmBundlerLegacy003Js.xn;
+      }],
+      execute: function () {
+        init_compiler_core_esm_bundler = __esm({
+          "../../../node_modules/.pnpm/@vue+compiler-core@3.5.13/node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js": () => {
+            init_shared_esm_bundler();
+            FRAGMENT = Symbol(``);
+            TELEPORT = Symbol(``);
+            SUSPENSE = Symbol(``);
+            KEEP_ALIVE = Symbol(``);
+            BASE_TRANSITION = Symbol(``);
+            OPEN_BLOCK = Symbol(``);
+            CREATE_BLOCK = Symbol(``);
+            CREATE_ELEMENT_BLOCK = Symbol(``);
+            CREATE_VNODE = Symbol(``);
+            CREATE_ELEMENT_VNODE = Symbol(``);
+            CREATE_COMMENT = Symbol(``);
+            CREATE_TEXT = Symbol(``);
+            CREATE_STATIC = Symbol(``);
+            RESOLVE_COMPONENT = Symbol(``);
+            RESOLVE_DYNAMIC_COMPONENT = Symbol(``);
+            RESOLVE_DIRECTIVE = Symbol(``);
+            RESOLVE_FILTER = Symbol(``);
+            WITH_DIRECTIVES = Symbol(``);
+            RENDER_LIST = Symbol(``);
+            RENDER_SLOT = Symbol(``);
+            CREATE_SLOTS = Symbol(``);
+            TO_DISPLAY_STRING = Symbol(``);
+            MERGE_PROPS = Symbol(``);
+            NORMALIZE_CLASS = Symbol(``);
+            NORMALIZE_STYLE = Symbol(``);
+            NORMALIZE_PROPS = Symbol(``);
+            GUARD_REACTIVE_PROPS = Symbol(``);
+            TO_HANDLERS = Symbol(``);
+            CAMELIZE = Symbol(``);
+            CAPITALIZE = Symbol(``);
+            TO_HANDLER_KEY = Symbol(``);
+            SET_BLOCK_TRACKING = Symbol(``);
+            PUSH_SCOPE_ID = Symbol(``);
+            POP_SCOPE_ID = Symbol(``);
+            WITH_CTX = Symbol(``);
+            UNREF = Symbol(``);
+            IS_REF = Symbol(``);
+            WITH_MEMO = Symbol(``);
+            IS_MEMO_SAME = Symbol(``);
+            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`
+            };
+            Namespaces = {
+              "HTML": 0,
+              "0": "HTML",
+              "SVG": 1,
+              "1": "SVG",
+              "MATH_ML": 2,
+              "2": "MATH_ML"
+            };
+            NodeTypes = {
+              "ROOT": 0,
+              "0": "ROOT",
+              "ELEMENT": 1,
+              "1": "ELEMENT",
+              "TEXT": 2,
+              "2": "TEXT",
+              "COMMENT": 3,
+              "3": "COMMENT",
+              "SIMPLE_EXPRESSION": 4,
+              "4": "SIMPLE_EXPRESSION",
+              "INTERPOLATION": 5,
+              "5": "INTERPOLATION",
+              "ATTRIBUTE": 6,
+              "6": "ATTRIBUTE",
+              "DIRECTIVE": 7,
+              "7": "DIRECTIVE",
+              "COMPOUND_EXPRESSION": 8,
+              "8": "COMPOUND_EXPRESSION",
+              "IF": 9,
+              "9": "IF",
+              "IF_BRANCH": 10,
+              "10": "IF_BRANCH",
+              "FOR": 11,
+              "11": "FOR",
+              "TEXT_CALL": 12,
+              "12": "TEXT_CALL",
+              "VNODE_CALL": 13,
+              "13": "VNODE_CALL",
+              "JS_CALL_EXPRESSION": 14,
+              "14": "JS_CALL_EXPRESSION",
+              "JS_OBJECT_EXPRESSION": 15,
+              "15": "JS_OBJECT_EXPRESSION",
+              "JS_PROPERTY": 16,
+              "16": "JS_PROPERTY",
+              "JS_ARRAY_EXPRESSION": 17,
+              "17": "JS_ARRAY_EXPRESSION",
+              "JS_FUNCTION_EXPRESSION": 18,
+              "18": "JS_FUNCTION_EXPRESSION",
+              "JS_CONDITIONAL_EXPRESSION": 19,
+              "19": "JS_CONDITIONAL_EXPRESSION",
+              "JS_CACHE_EXPRESSION": 20,
+              "20": "JS_CACHE_EXPRESSION",
+              "JS_BLOCK_STATEMENT": 21,
+              "21": "JS_BLOCK_STATEMENT",
+              "JS_TEMPLATE_LITERAL": 22,
+              "22": "JS_TEMPLATE_LITERAL",
+              "JS_IF_STATEMENT": 23,
+              "23": "JS_IF_STATEMENT",
+              "JS_ASSIGNMENT_EXPRESSION": 24,
+              "24": "JS_ASSIGNMENT_EXPRESSION",
+              "JS_SEQUENCE_EXPRESSION": 25,
+              "25": "JS_SEQUENCE_EXPRESSION",
+              "JS_RETURN_STATEMENT": 26,
+              "26": "JS_RETURN_STATEMENT"
+            };
+            ElementTypes = {
+              "ELEMENT": 0,
+              "0": "ELEMENT",
+              "COMPONENT": 1,
+              "1": "COMPONENT",
+              "SLOT": 2,
+              "2": "SLOT",
+              "TEMPLATE": 3,
+              "3": "TEMPLATE"
+            };
+            ConstantTypes = {
+              "NOT_CONSTANT": 0,
+              "0": "NOT_CONSTANT",
+              "CAN_SKIP_PATCH": 1,
+              "1": "CAN_SKIP_PATCH",
+              "CAN_CACHE": 2,
+              "2": "CAN_CACHE",
+              "CAN_STRINGIFY": 3,
+              "3": "CAN_STRINGIFY"
+            };
+            locStub = {
+              start: {
+                line: 1,
+                column: 1,
+                offset: 0
+              },
+              end: {
+                line: 1,
+                column: 1,
+                offset: 0
+              },
+              source: ""
+            };
+            defaultDelimitersOpen = new Uint8Array([123, 123]);
+            defaultDelimitersClose = new Uint8Array([125, 125]);
+            Sequences = {
+              Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
+              CdataEnd: new Uint8Array([93, 93, 62]),
+              CommentEnd: new Uint8Array([45, 45, 62]),
+              ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
+              StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
+              TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
+              TextareaEnd: new Uint8Array([60, 47, 116, 101, 120, 116, 97, 114, 101, 97])
+            };
+            Tokenizer = class {
+              constructor(stack$1, cbs) {
+                this.stack = stack$1;
+                this.cbs = cbs;
+                /** The current state the tokenizer is in. */
+                this.state = 1;
+                /** The read buffer. */
+                this.buffer = "";
+                /** The beginning of the section that is currently being read. */
+                this.sectionStart = 0;
+                /** The index within the buffer that we are currently looking at. */
+                this.index = 0;
+                /** The start of the last entity. */
+                this.entityStart = 0;
+                /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
+                this.baseState = 1;
+                /** For special parsing behavior inside of script and style tags. */
+                this.inRCDATA = false;
+                /** For disabling RCDATA tags handling */
+                this.inXML = false;
+                /** For disabling interpolation parsing in v-pre */
+                this.inVPre = false;
+                /** Record newline positions for fast line / column calculation */
+                this.newlines = [];
+                this.mode = 0;
+                this.delimiterOpen = defaultDelimitersOpen;
+                this.delimiterClose = defaultDelimitersClose;
+                this.delimiterIndex = -1;
+                this.currentSequence = void 0;
+                this.sequenceIndex = 0;
+              }
+              get inSFCRoot() {
+                return this.mode === 2 && this.stack.length === 0;
+              }
+              reset() {
+                this.state = 1;
+                this.mode = 0;
+                this.buffer = "";
+                this.sectionStart = 0;
+                this.index = 0;
+                this.baseState = 1;
+                this.inRCDATA = false;
+                this.currentSequence = void 0;
+                this.newlines.length = 0;
+                this.delimiterOpen = defaultDelimitersOpen;
+                this.delimiterClose = defaultDelimitersClose;
+              }
+              /**
+              * Generate Position object with line / column information using recorded
+              * newline positions. We know the index is always going to be an already
+              * processed index, so all the newlines up to this index should have been
+              * recorded.
+              */
+              getPos(index) {
+                let line = 1;
+                let column = index + 1;
+                for (let i = this.newlines.length - 1; i >= 0; i--) {
+                  const newlineIndex = this.newlines[i];
+                  if (index > newlineIndex) {
+                    line = i + 2;
+                    column = index - newlineIndex;
+                    break;
+                  }
+                }
+                return {
+                  column,
+                  line,
+                  offset: index
+                };
+              }
+              peek() {
+                return this.buffer.charCodeAt(this.index + 1);
+              }
+              stateText(c) {
+                if (c === 60) {
+                  if (this.index > this.sectionStart) this.cbs.ontext(this.sectionStart, this.index);
+                  this.state = 5;
+                  this.sectionStart = this.index;
+                } else if (!this.inVPre && c === this.delimiterOpen[0]) {
+                  this.state = 2;
+                  this.delimiterIndex = 0;
+                  this.stateInterpolationOpen(c);
+                }
+              }
+              stateInterpolationOpen(c) {
+                if (c === this.delimiterOpen[this.delimiterIndex]) {
+                  if (this.delimiterIndex === this.delimiterOpen.length - 1) {
+                    const start = this.index + 1 - this.delimiterOpen.length;
+                    if (start > this.sectionStart) this.cbs.ontext(this.sectionStart, start);
+                    this.state = 3;
+                    this.sectionStart = start;
+                  } else this.delimiterIndex++;
+                } else if (this.inRCDATA) {
+                  this.state = 32;
+                  this.stateInRCDATA(c);
+                } else {
+                  this.state = 1;
+                  this.stateText(c);
+                }
+              }
+              stateInterpolation(c) {
+                if (c === this.delimiterClose[0]) {
+                  this.state = 4;
+                  this.delimiterIndex = 0;
+                  this.stateInterpolationClose(c);
+                }
+              }
+              stateInterpolationClose(c) {
+                if (c === this.delimiterClose[this.delimiterIndex]) {
+                  if (this.delimiterIndex === this.delimiterClose.length - 1) {
+                    this.cbs.oninterpolation(this.sectionStart, this.index + 1);
+                    if (this.inRCDATA) this.state = 32;else this.state = 1;
+                    this.sectionStart = this.index + 1;
+                  } else this.delimiterIndex++;
+                } else {
+                  this.state = 3;
+                  this.stateInterpolation(c);
+                }
+              }
+              stateSpecialStartSequence(c) {
+                const isEnd = this.sequenceIndex === this.currentSequence.length;
+                if (!(isEnd ? isEndOfTagSection(c) : (c | 32) === this.currentSequence[this.sequenceIndex])) this.inRCDATA = false;else if (!isEnd) {
+                  this.sequenceIndex++;
+                  return;
+                }
+                this.sequenceIndex = 0;
+                this.state = 6;
+                this.stateInTagName(c);
+              }
+              /** Look for an end tag. For <title> and <textarea>, also decode entities. */
+              stateInRCDATA(c) {
+                if (this.sequenceIndex === this.currentSequence.length) {
+                  if (c === 62 || isWhitespace(c)) {
+                    const endOfText = this.index - this.currentSequence.length;
+                    if (this.sectionStart < endOfText) {
+                      const actualIndex = this.index;
+                      this.index = endOfText;
+                      this.cbs.ontext(this.sectionStart, endOfText);
+                      this.index = actualIndex;
+                    }
+                    this.sectionStart = endOfText + 2;
+                    this.stateInClosingTagName(c);
+                    this.inRCDATA = false;
+                    return;
+                  }
+                  this.sequenceIndex = 0;
+                }
+                if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;else if (this.sequenceIndex === 0) {
+                  if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
+                    if (!this.inVPre && c === this.delimiterOpen[0]) {
+                      this.state = 2;
+                      this.delimiterIndex = 0;
+                      this.stateInterpolationOpen(c);
+                    }
+                  } else if (this.fastForwardTo(60)) this.sequenceIndex = 1;
+                } else this.sequenceIndex = Number(c === 60);
+              }
+              stateCDATASequence(c) {
+                if (c === Sequences.Cdata[this.sequenceIndex]) {
+                  if (++this.sequenceIndex === Sequences.Cdata.length) {
+                    this.state = 28;
+                    this.currentSequence = Sequences.CdataEnd;
+                    this.sequenceIndex = 0;
+                    this.sectionStart = this.index + 1;
+                  }
+                } else {
+                  this.sequenceIndex = 0;
+                  this.state = 23;
+                  this.stateInDeclaration(c);
+                }
+              }
+              /**
+              * When we wait for one specific character, we can speed things up
+              * by skipping through the buffer until we find it.
+              *
+              * @returns Whether the character was found.
+              */
+              fastForwardTo(c) {
+                while (++this.index < this.buffer.length) {
+                  const cc = this.buffer.charCodeAt(this.index);
+                  if (cc === 10) this.newlines.push(this.index);
+                  if (cc === c) return true;
+                }
+                this.index = this.buffer.length - 1;
+                return false;
+              }
+              /**
+              * Comments and CDATA end with `-->` and `]]>`.
+              *
+              * Their common qualities are:
+              * - Their end sequences have a distinct character they start with.
+              * - That character is then repeated, so we have to check multiple repeats.
+              * - All characters but the start character of the sequence can be skipped.
+              */
+              stateInCommentLike(c) {
+                if (c === this.currentSequence[this.sequenceIndex]) {
+                  if (++this.sequenceIndex === this.currentSequence.length) {
+                    if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, this.index - 2);else this.cbs.oncomment(this.sectionStart, this.index - 2);
+                    this.sequenceIndex = 0;
+                    this.sectionStart = this.index + 1;
+                    this.state = 1;
+                  }
+                } else if (this.sequenceIndex === 0) {
+                  if (this.fastForwardTo(this.currentSequence[0])) this.sequenceIndex = 1;
+                } else if (c !== this.currentSequence[this.sequenceIndex - 1]) this.sequenceIndex = 0;
+              }
+              startSpecial(sequence, offset) {
+                this.enterRCDATA(sequence, offset);
+                this.state = 31;
+              }
+              enterRCDATA(sequence, offset) {
+                this.inRCDATA = true;
+                this.currentSequence = sequence;
+                this.sequenceIndex = offset;
+              }
+              stateBeforeTagName(c) {
+                if (c === 33) {
+                  this.state = 22;
+                  this.sectionStart = this.index + 1;
+                } else if (c === 63) {
+                  this.state = 24;
+                  this.sectionStart = this.index + 1;
+                } else if (isTagStartChar(c)) {
+                  this.sectionStart = this.index;
+                  if (this.mode === 0) this.state = 6;else if (this.inSFCRoot) this.state = 34;else if (!this.inXML) {
+                    if (c === 116) this.state = 30;else this.state = c === 115 ? 29 : 6;
+                  } else this.state = 6;
+                } else if (c === 47) this.state = 8;else {
+                  this.state = 1;
+                  this.stateText(c);
+                }
+              }
+              stateInTagName(c) {
+                if (isEndOfTagSection(c)) this.handleTagName(c);
+              }
+              stateInSFCRootTagName(c) {
+                if (isEndOfTagSection(c)) {
+                  const tag = this.buffer.slice(this.sectionStart, this.index);
+                  if (tag !== "template") this.enterRCDATA(toCharCodes(`</` + tag), 0);
+                  this.handleTagName(c);
+                }
+              }
+              handleTagName(c) {
+                this.cbs.onopentagname(this.sectionStart, this.index);
+                this.sectionStart = -1;
+                this.state = 11;
+                this.stateBeforeAttrName(c);
+              }
+              stateBeforeClosingTagName(c) {
+                if (isWhitespace(c)) ;else if (c === 62) {
+                  this.state = 1;
+                  this.sectionStart = this.index + 1;
+                } else {
+                  this.state = isTagStartChar(c) ? 9 : 27;
+                  this.sectionStart = this.index;
+                }
+              }
+              stateInClosingTagName(c) {
+                if (c === 62 || isWhitespace(c)) {
+                  this.cbs.onclosetag(this.sectionStart, this.index);
+                  this.sectionStart = -1;
+                  this.state = 10;
+                  this.stateAfterClosingTagName(c);
+                }
+              }
+              stateAfterClosingTagName(c) {
+                if (c === 62) {
+                  this.state = 1;
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              stateBeforeAttrName(c) {
+                if (c === 62) {
+                  this.cbs.onopentagend(this.index);
+                  if (this.inRCDATA) this.state = 32;else this.state = 1;
+                  this.sectionStart = this.index + 1;
+                } else if (c === 47) this.state = 7;else if (c === 60 && this.peek() === 47) {
+                  this.cbs.onopentagend(this.index);
+                  this.state = 5;
+                  this.sectionStart = this.index;
+                } else if (!isWhitespace(c)) this.handleAttrStart(c);
+              }
+              handleAttrStart(c) {
+                if (c === 118 && this.peek() === 45) {
+                  this.state = 13;
+                  this.sectionStart = this.index;
+                } else if (c === 46 || c === 58 || c === 64 || c === 35) {
+                  this.cbs.ondirname(this.index, this.index + 1);
+                  this.state = 14;
+                  this.sectionStart = this.index + 1;
+                } else {
+                  this.state = 12;
+                  this.sectionStart = this.index;
+                }
+              }
+              stateInSelfClosingTag(c) {
+                if (c === 62) {
+                  this.cbs.onselfclosingtag(this.index);
+                  this.state = 1;
+                  this.sectionStart = this.index + 1;
+                  this.inRCDATA = false;
+                } else if (!isWhitespace(c)) {
+                  this.state = 11;
+                  this.stateBeforeAttrName(c);
+                }
+              }
+              stateInAttrName(c) {
+                if (c === 61 || isEndOfTagSection(c)) {
+                  this.cbs.onattribname(this.sectionStart, this.index);
+                  this.handleAttrNameEnd(c);
+                }
+              }
+              stateInDirName(c) {
+                if (c === 61 || isEndOfTagSection(c)) {
+                  this.cbs.ondirname(this.sectionStart, this.index);
+                  this.handleAttrNameEnd(c);
+                } else if (c === 58) {
+                  this.cbs.ondirname(this.sectionStart, this.index);
+                  this.state = 14;
+                  this.sectionStart = this.index + 1;
+                } else if (c === 46) {
+                  this.cbs.ondirname(this.sectionStart, this.index);
+                  this.state = 16;
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              stateInDirArg(c) {
+                if (c === 61 || isEndOfTagSection(c)) {
+                  this.cbs.ondirarg(this.sectionStart, this.index);
+                  this.handleAttrNameEnd(c);
+                } else if (c === 91) this.state = 15;else if (c === 46) {
+                  this.cbs.ondirarg(this.sectionStart, this.index);
+                  this.state = 16;
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              stateInDynamicDirArg(c) {
+                if (c === 93) this.state = 14;else if (c === 61 || isEndOfTagSection(c)) {
+                  this.cbs.ondirarg(this.sectionStart, this.index + 1);
+                  this.handleAttrNameEnd(c);
+                }
+              }
+              stateInDirModifier(c) {
+                if (c === 61 || isEndOfTagSection(c)) {
+                  this.cbs.ondirmodifier(this.sectionStart, this.index);
+                  this.handleAttrNameEnd(c);
+                } else if (c === 46) {
+                  this.cbs.ondirmodifier(this.sectionStart, this.index);
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              handleAttrNameEnd(c) {
+                this.sectionStart = this.index;
+                this.state = 17;
+                this.cbs.onattribnameend(this.index);
+                this.stateAfterAttrName(c);
+              }
+              stateAfterAttrName(c) {
+                if (c === 61) this.state = 18;else if (c === 47 || c === 62) {
+                  this.cbs.onattribend(0, this.sectionStart);
+                  this.sectionStart = -1;
+                  this.state = 11;
+                  this.stateBeforeAttrName(c);
+                } else if (!isWhitespace(c)) {
+                  this.cbs.onattribend(0, this.sectionStart);
+                  this.handleAttrStart(c);
+                }
+              }
+              stateBeforeAttrValue(c) {
+                if (c === 34) {
+                  this.state = 19;
+                  this.sectionStart = this.index + 1;
+                } else if (c === 39) {
+                  this.state = 20;
+                  this.sectionStart = this.index + 1;
+                } else if (!isWhitespace(c)) {
+                  this.sectionStart = this.index;
+                  this.state = 21;
+                  this.stateInAttrValueNoQuotes(c);
+                }
+              }
+              handleInAttrValue(c, quote) {
+                if (c === quote || this.fastForwardTo(quote)) {
+                  this.cbs.onattribdata(this.sectionStart, this.index);
+                  this.sectionStart = -1;
+                  this.cbs.onattribend(quote === 34 ? 3 : 2, this.index + 1);
+                  this.state = 11;
+                }
+              }
+              stateInAttrValueDoubleQuotes(c) {
+                this.handleInAttrValue(c, 34);
+              }
+              stateInAttrValueSingleQuotes(c) {
+                this.handleInAttrValue(c, 39);
+              }
+              stateInAttrValueNoQuotes(c) {
+                if (isWhitespace(c) || c === 62) {
+                  this.cbs.onattribdata(this.sectionStart, this.index);
+                  this.sectionStart = -1;
+                  this.cbs.onattribend(1, this.index);
+                  this.state = 11;
+                  this.stateBeforeAttrName(c);
+                } else if (c === 39 || c === 60 || c === 61 || c === 96) this.cbs.onerr(18, this.index);
+              }
+              stateBeforeDeclaration(c) {
+                if (c === 91) {
+                  this.state = 26;
+                  this.sequenceIndex = 0;
+                } else this.state = c === 45 ? 25 : 23;
+              }
+              stateInDeclaration(c) {
+                if (c === 62 || this.fastForwardTo(62)) {
+                  this.state = 1;
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              stateInProcessingInstruction(c) {
+                if (c === 62 || this.fastForwardTo(62)) {
+                  this.cbs.onprocessinginstruction(this.sectionStart, this.index);
+                  this.state = 1;
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              stateBeforeComment(c) {
+                if (c === 45) {
+                  this.state = 28;
+                  this.currentSequence = Sequences.CommentEnd;
+                  this.sequenceIndex = 2;
+                  this.sectionStart = this.index + 1;
+                } else this.state = 23;
+              }
+              stateInSpecialComment(c) {
+                if (c === 62 || this.fastForwardTo(62)) {
+                  this.cbs.oncomment(this.sectionStart, this.index);
+                  this.state = 1;
+                  this.sectionStart = this.index + 1;
+                }
+              }
+              stateBeforeSpecialS(c) {
+                if (c === Sequences.ScriptEnd[3]) this.startSpecial(Sequences.ScriptEnd, 4);else if (c === Sequences.StyleEnd[3]) this.startSpecial(Sequences.StyleEnd, 4);else {
+                  this.state = 6;
+                  this.stateInTagName(c);
+                }
+              }
+              stateBeforeSpecialT(c) {
+                if (c === Sequences.TitleEnd[3]) this.startSpecial(Sequences.TitleEnd, 4);else if (c === Sequences.TextareaEnd[3]) this.startSpecial(Sequences.TextareaEnd, 4);else {
+                  this.state = 6;
+                  this.stateInTagName(c);
+                }
+              }
+              startEntity() {}
+              stateInEntity() {}
+              /**
+              * Iterates through the buffer, calling the function corresponding to the current state.
+              *
+              * States that are more likely to be hit are higher up, as a performance improvement.
+              */
+              parse(input) {
+                this.buffer = input;
+                while (this.index < this.buffer.length) {
+                  const c = this.buffer.charCodeAt(this.index);
+                  if (c === 10) this.newlines.push(this.index);
+                  switch (this.state) {
+                    case 1:
+                      this.stateText(c);
+                      break;
+                    case 2:
+                      this.stateInterpolationOpen(c);
+                      break;
+                    case 3:
+                      this.stateInterpolation(c);
+                      break;
+                    case 4:
+                      this.stateInterpolationClose(c);
+                      break;
+                    case 31:
+                      this.stateSpecialStartSequence(c);
+                      break;
+                    case 32:
+                      this.stateInRCDATA(c);
+                      break;
+                    case 26:
+                      this.stateCDATASequence(c);
+                      break;
+                    case 19:
+                      this.stateInAttrValueDoubleQuotes(c);
+                      break;
+                    case 12:
+                      this.stateInAttrName(c);
+                      break;
+                    case 13:
+                      this.stateInDirName(c);
+                      break;
+                    case 14:
+                      this.stateInDirArg(c);
+                      break;
+                    case 15:
+                      this.stateInDynamicDirArg(c);
+                      break;
+                    case 16:
+                      this.stateInDirModifier(c);
+                      break;
+                    case 28:
+                      this.stateInCommentLike(c);
+                      break;
+                    case 27:
+                      this.stateInSpecialComment(c);
+                      break;
+                    case 11:
+                      this.stateBeforeAttrName(c);
+                      break;
+                    case 6:
+                      this.stateInTagName(c);
+                      break;
+                    case 34:
+                      this.stateInSFCRootTagName(c);
+                      break;
+                    case 9:
+                      this.stateInClosingTagName(c);
+                      break;
+                    case 5:
+                      this.stateBeforeTagName(c);
+                      break;
+                    case 17:
+                      this.stateAfterAttrName(c);
+                      break;
+                    case 20:
+                      this.stateInAttrValueSingleQuotes(c);
+                      break;
+                    case 18:
+                      this.stateBeforeAttrValue(c);
+                      break;
+                    case 8:
+                      this.stateBeforeClosingTagName(c);
+                      break;
+                    case 10:
+                      this.stateAfterClosingTagName(c);
+                      break;
+                    case 29:
+                      this.stateBeforeSpecialS(c);
+                      break;
+                    case 30:
+                      this.stateBeforeSpecialT(c);
+                      break;
+                    case 21:
+                      this.stateInAttrValueNoQuotes(c);
+                      break;
+                    case 7:
+                      this.stateInSelfClosingTag(c);
+                      break;
+                    case 23:
+                      this.stateInDeclaration(c);
+                      break;
+                    case 22:
+                      this.stateBeforeDeclaration(c);
+                      break;
+                    case 25:
+                      this.stateBeforeComment(c);
+                      break;
+                    case 24:
+                      this.stateInProcessingInstruction(c);
+                      break;
+                    case 33:
+                      this.stateInEntity();
+                      break;
+                  }
+                  this.index++;
+                }
+                this.cleanup();
+                this.finish();
+              }
+              /**
+              * Remove data that has already been consumed from the buffer.
+              */
+              cleanup() {
+                if (this.sectionStart !== this.index) {
+                  if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
+                    this.cbs.ontext(this.sectionStart, this.index);
+                    this.sectionStart = this.index;
+                  } else if (this.state === 19 || this.state === 20 || this.state === 21) {
+                    this.cbs.onattribdata(this.sectionStart, this.index);
+                    this.sectionStart = this.index;
+                  }
+                }
+              }
+              finish() {
+                this.handleTrailingData();
+                this.cbs.onend();
+              }
+              /** Handle any trailing data. */
+              handleTrailingData() {
+                const endIndex = this.buffer.length;
+                if (this.sectionStart >= endIndex) return;
+                if (this.state === 28) {
+                  if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, endIndex);else this.cbs.oncomment(this.sectionStart, endIndex);
+                } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ;else this.cbs.ontext(this.sectionStart, endIndex);
+              }
+              emitCodePoint(cp, consumed) {}
+            };
+            CompilerDeprecationTypes = {
+              "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
+              "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
+              "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
+              "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
+              "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
+              "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
+              "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
+              "COMPILER_FILTERS": "COMPILER_FILTERS"
+            };
+            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_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_FILTERS"]: {
+                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`
+              }
+            };
+            ErrorCodes = {
+              "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
+              "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
+              "CDATA_IN_HTML_CONTENT": 1,
+              "1": "CDATA_IN_HTML_CONTENT",
+              "DUPLICATE_ATTRIBUTE": 2,
+              "2": "DUPLICATE_ATTRIBUTE",
+              "END_TAG_WITH_ATTRIBUTES": 3,
+              "3": "END_TAG_WITH_ATTRIBUTES",
+              "END_TAG_WITH_TRAILING_SOLIDUS": 4,
+              "4": "END_TAG_WITH_TRAILING_SOLIDUS",
+              "EOF_BEFORE_TAG_NAME": 5,
+              "5": "EOF_BEFORE_TAG_NAME",
+              "EOF_IN_CDATA": 6,
+              "6": "EOF_IN_CDATA",
+              "EOF_IN_COMMENT": 7,
+              "7": "EOF_IN_COMMENT",
+              "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
+              "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
+              "EOF_IN_TAG": 9,
+              "9": "EOF_IN_TAG",
+              "INCORRECTLY_CLOSED_COMMENT": 10,
+              "10": "INCORRECTLY_CLOSED_COMMENT",
+              "INCORRECTLY_OPENED_COMMENT": 11,
+              "11": "INCORRECTLY_OPENED_COMMENT",
+              "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
+              "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
+              "MISSING_ATTRIBUTE_VALUE": 13,
+              "13": "MISSING_ATTRIBUTE_VALUE",
+              "MISSING_END_TAG_NAME": 14,
+              "14": "MISSING_END_TAG_NAME",
+              "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
+              "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
+              "NESTED_COMMENT": 16,
+              "16": "NESTED_COMMENT",
+              "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
+              "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
+              "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
+              "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
+              "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
+              "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
+              "UNEXPECTED_NULL_CHARACTER": 20,
+              "20": "UNEXPECTED_NULL_CHARACTER",
+              "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
+              "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
+              "UNEXPECTED_SOLIDUS_IN_TAG": 22,
+              "22": "UNEXPECTED_SOLIDUS_IN_TAG",
+              "X_INVALID_END_TAG": 23,
+              "23": "X_INVALID_END_TAG",
+              "X_MISSING_END_TAG": 24,
+              "24": "X_MISSING_END_TAG",
+              "X_MISSING_INTERPOLATION_END": 25,
+              "25": "X_MISSING_INTERPOLATION_END",
+              "X_MISSING_DIRECTIVE_NAME": 26,
+              "26": "X_MISSING_DIRECTIVE_NAME",
+              "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
+              "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
+              "X_V_IF_NO_EXPRESSION": 28,
+              "28": "X_V_IF_NO_EXPRESSION",
+              "X_V_IF_SAME_KEY": 29,
+              "29": "X_V_IF_SAME_KEY",
+              "X_V_ELSE_NO_ADJACENT_IF": 30,
+              "30": "X_V_ELSE_NO_ADJACENT_IF",
+              "X_V_FOR_NO_EXPRESSION": 31,
+              "31": "X_V_FOR_NO_EXPRESSION",
+              "X_V_FOR_MALFORMED_EXPRESSION": 32,
+              "32": "X_V_FOR_MALFORMED_EXPRESSION",
+              "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
+              "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
+              "X_V_BIND_NO_EXPRESSION": 34,
+              "34": "X_V_BIND_NO_EXPRESSION",
+              "X_V_ON_NO_EXPRESSION": 35,
+              "35": "X_V_ON_NO_EXPRESSION",
+              "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
+              "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
+              "X_V_SLOT_MIXED_SLOT_USAGE": 37,
+              "37": "X_V_SLOT_MIXED_SLOT_USAGE",
+              "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
+              "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
+              "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
+              "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
+              "X_V_SLOT_MISPLACED": 40,
+              "40": "X_V_SLOT_MISPLACED",
+              "X_V_MODEL_NO_EXPRESSION": 41,
+              "41": "X_V_MODEL_NO_EXPRESSION",
+              "X_V_MODEL_MALFORMED_EXPRESSION": 42,
+              "42": "X_V_MODEL_MALFORMED_EXPRESSION",
+              "X_V_MODEL_ON_SCOPE_VARIABLE": 43,
+              "43": "X_V_MODEL_ON_SCOPE_VARIABLE",
+              "X_V_MODEL_ON_PROPS": 44,
+              "44": "X_V_MODEL_ON_PROPS",
+              "X_INVALID_EXPRESSION": 45,
+              "45": "X_INVALID_EXPRESSION",
+              "X_KEEP_ALIVE_INVALID_CHILDREN": 46,
+              "46": "X_KEEP_ALIVE_INVALID_CHILDREN",
+              "X_PREFIX_ID_NOT_SUPPORTED": 47,
+              "47": "X_PREFIX_ID_NOT_SUPPORTED",
+              "X_MODULE_MODE_NOT_SUPPORTED": 48,
+              "48": "X_MODULE_MODE_NOT_SUPPORTED",
+              "X_CACHE_HANDLER_NOT_SUPPORTED": 49,
+              "49": "X_CACHE_HANDLER_NOT_SUPPORTED",
+              "X_SCOPE_ID_NOT_SUPPORTED": 50,
+              "50": "X_SCOPE_ID_NOT_SUPPORTED",
+              "X_VNODE_HOOKS": 51,
+              "51": "X_VNODE_HOOKS",
+              "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
+              "52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
+              "__EXTEND_POINT__": 53,
+              "53": "__EXTEND_POINT__"
+            };
+            errorMessages = {
+              [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 '&lt;' 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.",
+              [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.",
+              [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.`,
+              [52]: `v-bind with same-name shorthand only allows static argument.`,
+              [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.`,
+              [51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
+              [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.`,
+              [53]: ``
+            };
+            isFunctionType = node => {
+              return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+            };
+            isStaticProperty = node => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
+            isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+            TS_NODE_TYPES = ["TSAsExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "TSSatisfiesExpression"];
+            isStaticExp = p => p.type === 4 && p.isStatic;
+            nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
+            isSimpleIdentifier = name => !nonIdentifierRE.test(name);
+            validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
+            validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
+            whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
+            getExpSource = exp => exp.type === 4 ? exp.content : exp.loc.source;
+            isMemberExpressionBrowser = exp => {
+              const path = getExpSource(exp).trim().replace(whitespaceRE, s => s.trim());
+              let state = 0;
+              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:
+                    if (char === "[") {
+                      stateStack.push(state);
+                      state = 1;
+                      currentOpenBracketCount++;
+                    } else if (char === "(") {
+                      stateStack.push(state);
+                      state = 2;
+                      currentOpenParensCount++;
+                    } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) return false;
+                    break;
+                  case 1:
+                    if (char === `'` || char === `"` || char === "`") {
+                      stateStack.push(state);
+                      state = 3;
+                      currentStringType = char;
+                    } else if (char === `[`) currentOpenBracketCount++;else if (char === `]`) {
+                      if (! --currentOpenBracketCount) state = stateStack.pop();
+                    }
+                    break;
+                  case 2:
+                    if (char === `'` || char === `"` || char === "`") {
+                      stateStack.push(state);
+                      state = 3;
+                      currentStringType = char;
+                    } else if (char === `(`) currentOpenParensCount++;else if (char === `)`) {
+                      if (i === path.length - 1) return false;
+                      if (! --currentOpenParensCount) state = stateStack.pop();
+                    }
+                    break;
+                  case 3:
+                    if (char === currentStringType) {
+                      state = stateStack.pop();
+                      currentStringType = null;
+                    }
+                    break;
+                }
+              }
+              return !currentOpenBracketCount && !currentOpenParensCount;
+            };
+            isMemberExpressionNode = NOOP;
+            isMemberExpression = isMemberExpressionBrowser;
+            fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+            isFnExpressionBrowser = exp => fnExpRE.test(getExpSource(exp));
+            isFnExpressionNode = NOOP;
+            isFnExpression = isFnExpressionBrowser;
+            propsHelperSet = /* @__PURE__ */new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
+            forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
+            defaultParserOptions = {
+              parseMode: "base",
+              ns: 0,
+              delimiters: [`{{`, `}}`],
+              getNamespace: () => 0,
+              isVoidTag: NO,
+              isPreTag: NO,
+              isIgnoreNewlineTag: NO,
+              isCustomElement: NO,
+              onError: defaultOnError,
+              onWarn: defaultOnWarn,
+              comments: false,
+              prefixIdentifiers: false
+            };
+            currentOptions = defaultParserOptions;
+            currentRoot = null;
+            currentInput = "";
+            currentOpenTag = null;
+            currentProp = null;
+            currentAttrValue = "";
+            currentAttrStartIndex = -1;
+            currentAttrEndIndex = -1;
+            inPre = 0;
+            inVPre = false;
+            currentVPreBoundary = null;
+            stack = [];
+            tokenizer = new Tokenizer(stack, {
+              onerr: emitError,
+              ontext(start, end) {
+                onText(getSlice(start, end), start, end);
+              },
+              ontextentity(char, start, end) {
+                onText(char, start, end);
+              },
+              oninterpolation(start, end) {
+                if (inVPre) return onText(getSlice(start, end), start, end);
+                let innerStart = start + tokenizer.delimiterOpen.length;
+                let innerEnd = end - tokenizer.delimiterClose.length;
+                while (isWhitespace(currentInput.charCodeAt(innerStart))) innerStart++;
+                while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) innerEnd--;
+                let exp = getSlice(innerStart, innerEnd);
+                if (exp.includes("&")) exp = currentOptions.decodeEntities(exp, false);
+                addNode({
+                  type: 5,
+                  content: createExp(exp, false, getLoc(innerStart, innerEnd)),
+                  loc: getLoc(start, end)
+                });
+              },
+              onopentagname(start, end) {
+                const name = getSlice(start, end);
+                currentOpenTag = {
+                  type: 1,
+                  tag: name,
+                  ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
+                  tagType: 0,
+                  props: [],
+                  children: [],
+                  loc: getLoc(start - 1, end),
+                  codegenNode: void 0
+                };
+              },
+              onopentagend(end) {
+                endOpenTag(end);
+              },
+              onclosetag(start, end) {
+                const name = getSlice(start, end);
+                if (!currentOptions.isVoidTag(name)) {
+                  let found = false;
+                  for (let i = 0; i < stack.length; i++) if (stack[i].tag.toLowerCase() === name.toLowerCase()) {
+                    found = true;
+                    if (i > 0) emitError(24, stack[0].loc.start.offset);
+                    for (let j = 0; j <= i; j++) onCloseTag(stack.shift(), end, j < i);
+                    break;
+                  }
+                  if (!found) emitError(23, backTrack(start, 60));
+                }
+              },
+              onselfclosingtag(end) {
+                const name = currentOpenTag.tag;
+                currentOpenTag.isSelfClosing = true;
+                endOpenTag(end);
+                if (stack[0] && stack[0].tag === name) onCloseTag(stack.shift(), end);
+              },
+              onattribname(start, end) {
+                currentProp = {
+                  type: 6,
+                  name: getSlice(start, end),
+                  nameLoc: getLoc(start, end),
+                  value: void 0,
+                  loc: getLoc(start)
+                };
+              },
+              ondirname(start, end) {
+                const raw = getSlice(start, end);
+                const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
+                if (!inVPre && name === "") emitError(26, start);
+                if (inVPre || name === "") currentProp = {
+                  type: 6,
+                  name: raw,
+                  nameLoc: getLoc(start, end),
+                  value: void 0,
+                  loc: getLoc(start)
+                };else {
+                  currentProp = {
+                    type: 7,
+                    name,
+                    rawName: raw,
+                    exp: void 0,
+                    arg: void 0,
+                    modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
+                    loc: getLoc(start)
+                  };
+                  if (name === "pre") {
+                    inVPre = tokenizer.inVPre = true;
+                    currentVPreBoundary = currentOpenTag;
+                    const props = currentOpenTag.props;
+                    for (let i = 0; i < props.length; i++) if (props[i].type === 7) props[i] = dirToAttr(props[i]);
+                  }
+                }
+              },
+              ondirarg(start, end) {
+                if (start === end) return;
+                const arg = getSlice(start, end);
+                if (inVPre) {
+                  currentProp.name += arg;
+                  setLocEnd(currentProp.nameLoc, end);
+                } else {
+                  const isStatic = arg[0] !== `[`;
+                  currentProp.arg = createExp(isStatic ? arg : arg.slice(1, -1), isStatic, getLoc(start, end), isStatic ? 3 : 0);
+                }
+              },
+              ondirmodifier(start, end) {
+                const mod = getSlice(start, end);
+                if (inVPre) {
+                  currentProp.name += "." + mod;
+                  setLocEnd(currentProp.nameLoc, end);
+                } else if (currentProp.name === "slot") {
+                  const arg = currentProp.arg;
+                  if (arg) {
+                    arg.content += "." + mod;
+                    setLocEnd(arg.loc, end);
+                  }
+                } else {
+                  const exp = createSimpleExpression(mod, true, getLoc(start, end));
+                  currentProp.modifiers.push(exp);
+                }
+              },
+              onattribdata(start, end) {
+                currentAttrValue += getSlice(start, end);
+                if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
+                currentAttrEndIndex = end;
+              },
+              onattribentity(char, start, end) {
+                currentAttrValue += char;
+                if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
+                currentAttrEndIndex = end;
+              },
+              onattribnameend(end) {
+                const start = currentProp.loc.start.offset;
+                const name = getSlice(start, end);
+                if (currentProp.type === 7) currentProp.rawName = name;
+                if (currentOpenTag.props.some(p => (p.type === 7 ? p.rawName : p.name) === name)) emitError(2, start);
+              },
+              onattribend(quote, end) {
+                if (currentOpenTag && currentProp) {
+                  setLocEnd(currentProp.loc, end);
+                  if (quote !== 0) {
+                    if (currentAttrValue.includes("&")) currentAttrValue = currentOptions.decodeEntities(currentAttrValue, true);
+                    if (currentProp.type === 6) {
+                      if (currentProp.name === "class") currentAttrValue = condense(currentAttrValue).trim();
+                      if (quote === 1 && !currentAttrValue) emitError(13, end);
+                      currentProp.value = {
+                        type: 2,
+                        content: currentAttrValue,
+                        loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
+                      };
+                      if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
+                    } else {
+                      currentProp.exp = createExp(currentAttrValue, false, getLoc(currentAttrStartIndex, currentAttrEndIndex), 0, 0);
+                      if (currentProp.name === "for") currentProp.forParseResult = parseForExpression(currentProp.exp);
+                      let syncIndex = -1;
+                      if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex(mod => mod.content === "sync")) > -1 && checkCompatEnabled("COMPILER_V_BIND_SYNC", currentOptions, currentProp.loc, currentProp.rawName)) {
+                        currentProp.name = "model";
+                        currentProp.modifiers.splice(syncIndex, 1);
+                      }
+                    }
+                  }
+                  if (currentProp.type !== 7 || currentProp.name !== "pre") currentOpenTag.props.push(currentProp);
+                }
+                currentAttrValue = "";
+                currentAttrStartIndex = currentAttrEndIndex = -1;
+              },
+              oncomment(start, end) {
+                if (currentOptions.comments) addNode({
+                  type: 3,
+                  content: getSlice(start, end),
+                  loc: getLoc(start - 4, end + 3)
+                });
+              },
+              onend() {
+                const end = currentInput.length;
+                for (let index = 0; index < stack.length; index++) {
+                  onCloseTag(stack[index], end - 1);
+                  emitError(24, stack[index].loc.start.offset);
+                }
+              },
+              oncdata(start, end) {
+                if (stack[0].ns !== 0) onText(getSlice(start, end), start, end);else emitError(1, start - 9);
+              },
+              onprocessinginstruction(start) {
+                if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) emitError(21, start - 1);
+              }
+            });
+            forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+            stripParensRE = /^\(|\)$/g;
+            specialTemplateDir = /* @__PURE__ */new Set(["if", "else", "else-if", "for", "slot"]);
+            windowsNewlineRE = /\r\n/g;
+            allowHoistedHelperSet = /* @__PURE__ */new Set([NORMALIZE_CLASS, NORMALIZE_STYLE, NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
+            PURE_ANNOTATION = `/*@__PURE__*/`;
+            aliasHelper = s => `${helperNameMap[s]}: _${helperNameMap[s]}`;
+            "" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b");
+            transformExpression = (node, context) => {
+              if (node.type === 5) node.content = processExpression(node.content, context);else if (node.type === 1) {
+                const memo = findDir(node, "memo");
+                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) && !(memo && arg && arg.type === 4 && arg.content === "key")) dir.exp = processExpression(exp, context, dir.name === "slot");
+                    if (arg && arg.type === 4 && !arg.isStatic) dir.arg = processExpression(arg, context);
+                  }
+                }
+              }
+            };
+            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);
+                  }
+                };
+              });
+            });
+            transformBind = (dir, _node, context) => {
+              const {
+                modifiers,
+                loc
+              } = dir;
+              const arg = dir.arg;
+              let {
+                exp
+              } = dir;
+              if (exp && exp.type === 4 && !exp.content.trim()) exp = void 0;
+              if (!exp) {
+                if (arg.type !== 4 || !arg.isStatic) {
+                  context.onError(createCompilerError(52, arg.loc));
+                  return {
+                    props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
+                  };
+                }
+                transformBindShorthand(dir);
+                exp = dir.exp;
+              }
+              if (arg.type !== 4) {
+                arg.children.unshift(`(`);
+                arg.children.push(`) || ""`);
+              } else if (!arg.isStatic) arg.content = `${arg.content} || ""`;
+              if (modifiers.some(mod => mod.content === "camel")) if (arg.type === 4) {
+                if (arg.isStatic) arg.content = 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.some(mod => mod.content === "prop")) injectPrefix(arg, ".");
+                if (modifiers.some(mod => mod.content === "attr")) injectPrefix(arg, "^");
+              }
+              return {
+                props: [createObjectProperty(arg, exp)]
+              };
+            };
+            transformBindShorthand = (dir, context) => {
+              const arg = dir.arg;
+              dir.exp = createSimpleExpression(camelize(arg.content), false, arg.loc);
+            };
+            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(`)`);
+              }
+            };
+            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`, false, true);
+                if (keyProp && keyProp.type === 7 && !keyProp.exp) transformBindShorthand(keyProp);
+                let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
+                const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
+                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;
+                  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);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.length)));
+                    context.cached.push(null);
+                  } else renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true));
+                };
+              });
+            });
+            defaultFallback = createSimpleExpression(`undefined`, false);
+            trackSlotScopes = (node, context) => {
+              if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
+                const vSlot = findDir(node, "slot");
+                if (vSlot) {
+                  vSlot.exp;
+                  context.scopes.vSlot++;
+                  return () => {
+                    context.scopes.vSlot--;
+                  };
+                }
+              }
+            };
+            trackVForSlotScopes = (node, context) => {
+              let vFor;
+              if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
+                const result = vFor.forParseResult;
+                if (result) {
+                  finalizeForParseResult(result, context);
+                  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);
+                  };
+                }
+              }
+            };
+            buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(props, children, false, true, children.length ? children[0].loc : loc);
+            directiveImportMap = /* @__PURE__ */new WeakMap();
+            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$1 = node.tagType === 1;
+                let vnodeTag = isComponent$1 ? resolveComponentType(node, context) : `"${tag}"`;
+                const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
+                let vnodeProps;
+                let vnodeChildren;
+                let patchFlag = 0;
+                let vnodeDynamicProps;
+                let dynamicPropNames;
+                let vnodeDirectives;
+                let shouldUseBlock = isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent$1 && (tag === "svg" || tag === "foreignObject" || tag === "math");
+                if (props.length > 0) {
+                  const propsBuildResult = buildProps(node, context, void 0, isComponent$1, 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 (isComponent$1 && vnodeTag !== TELEPORT && vnodeTag !== KEEP_ALIVE) {
+                    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 (dynamicPropNames && dynamicPropNames.length) vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
+                node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, patchFlag === 0 ? void 0 : patchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false, isComponent$1, node.loc);
+              };
+            };
+            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);
+              }
+            };
+            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)}`;
+                  eventName = createSimpleExpression(node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? toHandlerKey(camelize(rawName)) : `on:${rawName}`, 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);
+                const isInlineStatement = !(isMemberExp || isFnExpression(exp));
+                const hasMultipleStatements = exp.content.includes(`;`);
+                if (isInlineStatement || shouldCache && isMemberExp) exp = createCompoundExpression([`${isInlineStatement ? `$event` : `(...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;
+            };
+            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 || children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && !node.props.find(p => p.type === 7 && !context.directiveTransforms[p.name]) && !(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)
+                    };
+                  }
+                }
+              };
+            };
+            seen$1 = /* @__PURE__ */new WeakSet();
+            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, true);
+                };
+              }
+            };
+            transformModel = (dir, node, context) => {
+              const {
+                exp,
+                arg
+              } = dir;
+              if (!exp) {
+                context.onError(createCompilerError(41, dir.loc));
+                return createTransformProps();
+              }
+              const rawExp = exp.loc.source.trim();
+              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();
+              }
+              if (!expString.trim() || !isMemberExpression(exp) && true) {
+                context.onError(createCompilerError(42, exp.loc));
+                return createTransformProps();
+              }
+              const propName = arg ? arg : createSimpleExpression("modelValue", true);
+              const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(["\"onUpdate:\" + ", arg]) : `onUpdate:modelValue`;
+              let assignmentExp;
+              assignmentExp = createCompoundExpression([`${context.isTS ? `($event: any)` : `$event`} => ((`, exp, `) = $event)`]);
+              const props = [createObjectProperty(propName, dir.exp), createObjectProperty(eventName, assignmentExp)];
+              if (dir.modifiers.length && node.tagType === 1) {
+                const modifiers = dir.modifiers.map(m => m.content).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);
+            };
+            validDivisionCharRE = /[\w).+\-_$\]]/;
+            transformFilter = (node, context) => {
+              if (!isCompatEnabled("COMPILER_FILTERS", context)) return;
+              if (node.type === 5) rewriteFilter(node.content, context);else if (node.type === 1) node.props.forEach(prop => {
+                if (prop.type === 7 && prop.name !== "for" && prop.exp) rewriteFilter(prop.exp, context);
+              });
+            };
+            seen = /* @__PURE__ */new WeakSet();
+            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.length)]);
+                    context.cached.push(null);
+                  }
+                };
+              }
+            };
+            BindingTypes = {
+              "DATA": "data",
+              "PROPS": "props",
+              "PROPS_ALIASED": "props-aliased",
+              "SETUP_LET": "setup-let",
+              "SETUP_CONST": "setup-const",
+              "SETUP_REACTIVE_CONST": "setup-reactive-const",
+              "SETUP_MAYBE_REF": "setup-maybe-ref",
+              "SETUP_REF": "setup-ref",
+              "OPTIONS": "options",
+              "LITERAL_CONST": "literal-const"
+            };
+            noopDirectiveTransform = () => ({
+              props: []
+            });
+          }
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/@vue+compiler-dom@3.5.13/node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js
+        compiler_dom_esm_bundler_exports = /* @__PURE__ */__export({
+          BASE_TRANSITION: () => BASE_TRANSITION,
+          BindingTypes: () => BindingTypes,
+          CAMELIZE: () => CAMELIZE,
+          CAPITALIZE: () => CAPITALIZE,
+          CREATE_BLOCK: () => CREATE_BLOCK,
+          CREATE_COMMENT: () => CREATE_COMMENT,
+          CREATE_ELEMENT_BLOCK: () => CREATE_ELEMENT_BLOCK,
+          CREATE_ELEMENT_VNODE: () => CREATE_ELEMENT_VNODE,
+          CREATE_SLOTS: () => CREATE_SLOTS,
+          CREATE_STATIC: () => CREATE_STATIC,
+          CREATE_TEXT: () => CREATE_TEXT,
+          CREATE_VNODE: () => CREATE_VNODE,
+          CompilerDeprecationTypes: () => CompilerDeprecationTypes,
+          ConstantTypes: () => ConstantTypes,
+          DOMDirectiveTransforms: () => DOMDirectiveTransforms,
+          DOMErrorCodes: () => DOMErrorCodes,
+          DOMErrorMessages: () => DOMErrorMessages,
+          DOMNodeTransforms: () => DOMNodeTransforms,
+          ElementTypes: () => ElementTypes,
+          ErrorCodes: () => ErrorCodes,
+          FRAGMENT: () => FRAGMENT,
+          GUARD_REACTIVE_PROPS: () => GUARD_REACTIVE_PROPS,
+          IS_MEMO_SAME: () => IS_MEMO_SAME,
+          IS_REF: () => IS_REF,
+          KEEP_ALIVE: () => KEEP_ALIVE,
+          MERGE_PROPS: () => MERGE_PROPS,
+          NORMALIZE_CLASS: () => NORMALIZE_CLASS,
+          NORMALIZE_PROPS: () => NORMALIZE_PROPS,
+          NORMALIZE_STYLE: () => NORMALIZE_STYLE,
+          Namespaces: () => Namespaces,
+          NodeTypes: () => NodeTypes,
+          OPEN_BLOCK: () => OPEN_BLOCK,
+          POP_SCOPE_ID: () => POP_SCOPE_ID,
+          PUSH_SCOPE_ID: () => PUSH_SCOPE_ID,
+          RENDER_LIST: () => RENDER_LIST,
+          RENDER_SLOT: () => RENDER_SLOT,
+          RESOLVE_COMPONENT: () => RESOLVE_COMPONENT,
+          RESOLVE_DIRECTIVE: () => RESOLVE_DIRECTIVE,
+          RESOLVE_DYNAMIC_COMPONENT: () => RESOLVE_DYNAMIC_COMPONENT,
+          RESOLVE_FILTER: () => RESOLVE_FILTER,
+          SET_BLOCK_TRACKING: () => SET_BLOCK_TRACKING,
+          SUSPENSE: () => SUSPENSE,
+          TELEPORT: () => TELEPORT,
+          TO_DISPLAY_STRING: () => TO_DISPLAY_STRING,
+          TO_HANDLERS: () => TO_HANDLERS,
+          TO_HANDLER_KEY: () => TO_HANDLER_KEY,
+          TRANSITION: () => TRANSITION,
+          TRANSITION_GROUP: () => TRANSITION_GROUP,
+          TS_NODE_TYPES: () => TS_NODE_TYPES,
+          UNREF: () => UNREF,
+          V_MODEL_CHECKBOX: () => V_MODEL_CHECKBOX,
+          V_MODEL_DYNAMIC: () => V_MODEL_DYNAMIC,
+          V_MODEL_RADIO: () => V_MODEL_RADIO,
+          V_MODEL_SELECT: () => V_MODEL_SELECT,
+          V_MODEL_TEXT: () => V_MODEL_TEXT,
+          V_ON_WITH_KEYS: () => V_ON_WITH_KEYS,
+          V_ON_WITH_MODIFIERS: () => V_ON_WITH_MODIFIERS,
+          V_SHOW: () => V_SHOW,
+          WITH_CTX: () => WITH_CTX,
+          WITH_DIRECTIVES: () => WITH_DIRECTIVES,
+          WITH_MEMO: () => WITH_MEMO,
+          advancePositionWithClone: () => advancePositionWithClone,
+          advancePositionWithMutation: () => advancePositionWithMutation,
+          assert: () => assert,
+          baseCompile: () => baseCompile,
+          baseParse: () => baseParse,
+          buildDirectiveArgs: () => buildDirectiveArgs,
+          buildProps: () => buildProps,
+          buildSlots: () => buildSlots,
+          checkCompatEnabled: () => checkCompatEnabled,
+          compile: () => compile,
+          convertToBlock: () => convertToBlock,
+          createArrayExpression: () => createArrayExpression,
+          createAssignmentExpression: () => createAssignmentExpression,
+          createBlockStatement: () => createBlockStatement,
+          createCacheExpression: () => createCacheExpression,
+          createCallExpression: () => createCallExpression,
+          createCompilerError: () => createCompilerError,
+          createCompoundExpression: () => createCompoundExpression,
+          createConditionalExpression: () => createConditionalExpression,
+          createDOMCompilerError: () => createDOMCompilerError,
+          createForLoopParams: () => createForLoopParams,
+          createFunctionExpression: () => createFunctionExpression,
+          createIfStatement: () => createIfStatement,
+          createInterpolation: () => createInterpolation,
+          createObjectExpression: () => createObjectExpression,
+          createObjectProperty: () => createObjectProperty,
+          createReturnStatement: () => createReturnStatement,
+          createRoot: () => createRoot,
+          createSequenceExpression: () => createSequenceExpression,
+          createSimpleExpression: () => createSimpleExpression,
+          createStructuralDirectiveTransform: () => createStructuralDirectiveTransform,
+          createTemplateLiteral: () => createTemplateLiteral,
+          createTransformContext: () => createTransformContext,
+          createVNodeCall: () => createVNodeCall,
+          errorMessages: () => errorMessages,
+          extractIdentifiers: () => extractIdentifiers,
+          findDir: () => findDir,
+          findProp: () => findProp,
+          forAliasRE: () => forAliasRE,
+          generate: () => generate,
+          generateCodeFrame: () => generateCodeFrame,
+          getBaseTransformPreset: () => getBaseTransformPreset,
+          getConstantType: () => getConstantType,
+          getMemoedVNodeCall: () => getMemoedVNodeCall,
+          getVNodeBlockHelper: () => getVNodeBlockHelper,
+          getVNodeHelper: () => getVNodeHelper,
+          hasDynamicKeyVBind: () => hasDynamicKeyVBind,
+          hasScopeRef: () => hasScopeRef,
+          helperNameMap: () => helperNameMap,
+          injectProp: () => injectProp,
+          isCoreComponent: () => isCoreComponent,
+          isFnExpression: () => isFnExpression,
+          isFnExpressionBrowser: () => isFnExpressionBrowser,
+          isFnExpressionNode: () => isFnExpressionNode,
+          isFunctionType: () => isFunctionType,
+          isInDestructureAssignment: () => isInDestructureAssignment,
+          isInNewExpression: () => isInNewExpression,
+          isMemberExpression: () => isMemberExpression,
+          isMemberExpressionBrowser: () => isMemberExpressionBrowser,
+          isMemberExpressionNode: () => isMemberExpressionNode,
+          isReferencedIdentifier: () => isReferencedIdentifier,
+          isSimpleIdentifier: () => isSimpleIdentifier,
+          isSlotOutlet: () => isSlotOutlet,
+          isStaticArgOf: () => isStaticArgOf,
+          isStaticExp: () => isStaticExp,
+          isStaticProperty: () => isStaticProperty,
+          isStaticPropertyKey: () => isStaticPropertyKey,
+          isTemplateNode: () => isTemplateNode,
+          isText: () => isText$1,
+          isVSlot: () => isVSlot,
+          locStub: () => locStub,
+          noopDirectiveTransform: () => noopDirectiveTransform,
+          parse: () => parse,
+          parserOptions: () => parserOptions,
+          processExpression: () => processExpression,
+          processFor: () => processFor,
+          processIf: () => processIf,
+          processSlotOutlet: () => processSlotOutlet,
+          registerRuntimeHelpers: () => registerRuntimeHelpers,
+          resolveComponentType: () => resolveComponentType,
+          stringifyExpression: () => stringifyExpression,
+          toValidAssetId: () => toValidAssetId,
+          trackSlotScopes: () => trackSlotScopes,
+          trackVForSlotScopes: () => trackVForSlotScopes,
+          transform: () => transform,
+          transformBind: () => transformBind,
+          transformElement: () => transformElement,
+          transformExpression: () => transformExpression,
+          transformModel: () => transformModel,
+          transformOn: () => transformOn,
+          transformStyle: () => transformStyle,
+          traverseNode: () => traverseNode,
+          unwrapTSNode: () => unwrapTSNode,
+          walkBlockDeclarations: () => walkBlockDeclarations,
+          walkFunctionParams: () => walkFunctionParams,
+          walkIdentifiers: () => walkIdentifiers,
+          warnDeprecation: () => warnDeprecation
+        });
+        init_compiler_dom_esm_bundler = __esm({
+          "../../../node_modules/.pnpm/@vue+compiler-dom@3.5.13/node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js": () => {
+            init_compiler_core_esm_bundler();
+            init_compiler_core_esm_bundler();
+            init_shared_esm_bundler();
+            V_MODEL_RADIO = Symbol(``);
+            V_MODEL_CHECKBOX = Symbol(``);
+            V_MODEL_TEXT = Symbol(``);
+            V_MODEL_SELECT = Symbol(``);
+            V_MODEL_DYNAMIC = Symbol(``);
+            V_ON_WITH_MODIFIERS = Symbol(``);
+            V_ON_WITH_KEYS = Symbol(``);
+            V_SHOW = Symbol(``);
+            TRANSITION = Symbol(``);
+            TRANSITION_GROUP = Symbol(``);
+            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`
+            });
+            ;
+            parserOptions = {
+              parseMode: "html",
+              isVoidTag,
+              isNativeTag: tag => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
+              isPreTag: tag => tag === "pre",
+              isIgnoreNewlineTag: tag => tag === "pre" || tag === "textarea",
+              decodeEntities: decodeHtmlBrowser,
+              isBuiltInComponent: tag => {
+                if (tag === "Transition" || tag === "transition") return TRANSITION;else if (tag === "TransitionGroup" || tag === "transition-group") return TRANSITION_GROUP;
+              },
+              getNamespace(tag, parent, rootNamespace) {
+                let ns = parent ? parent.ns : rootNamespace;
+                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;
+              }
+            };
+            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: createSimpleExpression(`style`, true, p.loc),
+                  exp: parseInlineCSS(p.value.content, p.loc),
+                  modifiers: [],
+                  loc: p.loc
+                };
+              });
+            };
+            parseInlineCSS = (cssText, loc) => {
+              const normalized = parseStringStyle(cssText);
+              return createSimpleExpression(JSON.stringify(normalized), false, loc, 3);
+            };
+            DOMErrorCodes = {
+              "X_V_HTML_NO_EXPRESSION": 53,
+              "53": "X_V_HTML_NO_EXPRESSION",
+              "X_V_HTML_WITH_CHILDREN": 54,
+              "54": "X_V_HTML_WITH_CHILDREN",
+              "X_V_TEXT_NO_EXPRESSION": 55,
+              "55": "X_V_TEXT_NO_EXPRESSION",
+              "X_V_TEXT_WITH_CHILDREN": 56,
+              "56": "X_V_TEXT_WITH_CHILDREN",
+              "X_V_MODEL_ON_INVALID_ELEMENT": 57,
+              "57": "X_V_MODEL_ON_INVALID_ELEMENT",
+              "X_V_MODEL_ARG_ON_ELEMENT": 58,
+              "58": "X_V_MODEL_ARG_ON_ELEMENT",
+              "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
+              "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+              "X_V_MODEL_UNNECESSARY_VALUE": 60,
+              "60": "X_V_MODEL_UNNECESSARY_VALUE",
+              "X_V_SHOW_NO_EXPRESSION": 61,
+              "61": "X_V_SHOW_NO_EXPRESSION",
+              "X_TRANSITION_INVALID_CHILDREN": 62,
+              "62": "X_TRANSITION_INVALID_CHILDREN",
+              "X_IGNORED_SIDE_EFFECT_TAG": 63,
+              "63": "X_IGNORED_SIDE_EFFECT_TAG",
+              "__EXTEND_POINT__": 64,
+              "64": "__EXTEND_POINT__"
+            };
+            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.`
+            };
+            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: [createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression("", true))]
+              };
+            };
+            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: [createObjectProperty(createSimpleExpression(`textContent`, true), exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc) : createSimpleExpression("", true))]
+              };
+            };
+            transformModel$1 = (dir, node, context) => {
+              const baseResult = 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 = 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:
+                        break;
+                    }
+                  } else if (hasDynamicKeyVBind(node)) directiveToUse = V_MODEL_DYNAMIC;
+                } else if (tag === "select") directiveToUse = V_MODEL_SELECT;
+                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;
+            };
+            isEventOptionModifier = /* @__PURE__ */makeMap(`passive,once,capture`);
+            isNonKeyModifier = /* @__PURE__ */makeMap(`stop,prevent,self,ctrl,shift,alt,meta,exact,middle`);
+            maybeKeyModifier = /* @__PURE__ */makeMap("left,right");
+            isKeyboardEvent = /* @__PURE__ */makeMap(`onkeyup,onkeydown,onkeypress`);
+            resolveModifiers = (key, modifiers, context, loc) => {
+              const keyModifiers = [];
+              const nonKeyModifiers = [];
+              const eventOptionModifiers = [];
+              for (let i = 0; i < modifiers.length; i++) {
+                const modifier = modifiers[i].content;
+                if (modifier === "native" && checkCompatEnabled("COMPILER_V_ON_NATIVE", context, loc)) eventOptionModifiers.push(modifier);else if (isEventOptionModifier(modifier)) eventOptionModifiers.push(modifier);else if (maybeKeyModifier(modifier)) {
+                  if (isStaticExp(key)) {
+                    if (isKeyboardEvent(key.content.toLowerCase())) 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
+              };
+            };
+            transformClick = (key, event) => {
+              return isStaticExp(key) && key.content.toLowerCase() === "onclick" ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([`(`, key, `) === "onClick" ? "${event}" : (`, key, `)`]) : key;
+            };
+            transformOn$1 = (dir, node, context) => {
+              return 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 = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [handlerExp, JSON.stringify(nonKeyModifiers)]);
+                if (keyModifiers.length && (!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [handlerExp, JSON.stringify(keyModifiers)]);
+                if (eventOptionModifiers.length) {
+                  const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
+                  key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+                }
+                return {
+                  props: [createObjectProperty(key, handlerExp)]
+                };
+              });
+            };
+            transformShow = (dir, node, context) => {
+              const {
+                exp,
+                loc
+              } = dir;
+              if (!exp) context.onError(createDOMCompilerError(61, loc));
+              return {
+                props: [],
+                needRuntime: context.helper(V_SHOW)
+              };
+            };
+            ignoreSideEffectTags = (node, context) => {
+              if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) context.removeNode();
+            };
+            DOMNodeTransforms = [transformStyle, ...[]];
+            DOMDirectiveTransforms = {
+              cloak: noopDirectiveTransform,
+              html: transformVHtml,
+              text: transformVText,
+              model: transformModel$1,
+              on: transformOn$1,
+              show: transformShow
+            };
+          }
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/dist/vue.cjs.prod.js
+        require_vue_cjs_prod = /* @__PURE__ */__commonJS({
+          "../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/dist/vue.cjs.prod.js": exports => {
+            Object.defineProperty(exports, "__esModule", {
+              value: true
+            });
+            var compilerDom = (init_compiler_dom_esm_bundler(), __toCommonJS(compiler_dom_esm_bundler_exports));
+            var runtimeDom = (init_runtime_dom_esm_bundler(), __toCommonJS(runtime_dom_esm_bundler_exports));
+            var shared = (init_shared_esm_bundler(), __toCommonJS(shared_esm_bundler_exports));
+            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);
+            var 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 = shared.genCacheKey(template, options);
+              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];
+            });
+          }
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/index.js
+        _export("t", require_vue = /* @__PURE__ */__commonJS({
+          "../../../node_modules/.pnpm/vue@3.5.13_typescript@5.9.2/node_modules/vue/index.js": (exports, module) => {
+            module.exports = require_vue_cjs_prod();
+          }
+        })); //#endregion
+      }
+    };
+  });
+})();