Initial commit

node_modules/@vue/compiler-core/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@vue/compiler-core/README.md

@@ -0,0 +1 @@
+# @vue/compiler-core

node_modules/@vue/compiler-core/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-core.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-core.cjs.js')
+}

node_modules/@vue/compiler-core/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@vue/compiler-core",
+  "version": "3.5.25",
+  "description": "@vue/compiler-core",
+  "main": "index.js",
+  "module": "dist/compiler-core.esm-bundler.js",
+  "types": "dist/compiler-core.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-core.d.ts",
+      "node": {
+        "production": "./dist/compiler-core.cjs.prod.js",
+        "development": "./dist/compiler-core.cjs.js",
+        "default": "./index.js"
+      },
+      "module": "./dist/compiler-core.esm-bundler.js",
+      "import": "./dist/compiler-core.esm-bundler.js",
+      "require": "./index.js"
+    },
+    "./*": "./*"
+  },
+  "buildOptions": {
+    "name": "VueCompilerCore",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-core"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-core#readme",
+  "dependencies": {
+    "@babel/parser": "^7.28.5",
+    "entities": "^4.5.0",
+    "estree-walker": "^2.0.2",
+    "source-map-js": "^1.2.1",
+    "@vue/shared": "3.5.25"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.28.5"
+  }
+}

node_modules/@vue/compiler-dom/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@vue/compiler-dom/README.md

@@ -0,0 +1 @@
+# @vue/compiler-dom

node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.js

@@ -0,0 +1,934 @@
+/**
+* @vue/compiler-dom v3.5.25
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerCore = require('@vue/compiler-core');
+var shared = require('@vue/shared');
+
+const V_MODEL_RADIO = Symbol(`vModelRadio` );
+const V_MODEL_CHECKBOX = Symbol(
+  `vModelCheckbox` 
+);
+const V_MODEL_TEXT = Symbol(`vModelText` );
+const V_MODEL_SELECT = Symbol(
+  `vModelSelect` 
+);
+const V_MODEL_DYNAMIC = Symbol(
+  `vModelDynamic` 
+);
+const V_ON_WITH_MODIFIERS = Symbol(
+  `vOnModifiersGuard` 
+);
+const V_ON_WITH_KEYS = Symbol(
+  `vOnKeysGuard` 
+);
+const V_SHOW = Symbol(`vShow` );
+const TRANSITION = Symbol(`Transition` );
+const TRANSITION_GROUP = Symbol(
+  `TransitionGroup` 
+);
+compilerCore.registerRuntimeHelpers({
+  [V_MODEL_RADIO]: `vModelRadio`,
+  [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+  [V_MODEL_TEXT]: `vModelText`,
+  [V_MODEL_SELECT]: `vModelSelect`,
+  [V_MODEL_DYNAMIC]: `vModelDynamic`,
+  [V_ON_WITH_MODIFIERS]: `withModifiers`,
+  [V_ON_WITH_KEYS]: `withKeys`,
+  [V_SHOW]: `vShow`,
+  [TRANSITION]: `Transition`,
+  [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+const parserOptions = {
+  parseMode: "html",
+  isVoidTag: shared.isVoidTag,
+  isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),
+  isPreTag: (tag) => tag === "pre",
+  isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
+  decodeEntities: void 0,
+  isBuiltInComponent: (tag) => {
+    if (tag === "Transition" || tag === "transition") {
+      return TRANSITION;
+    } else if (tag === "TransitionGroup" || tag === "transition-group") {
+      return TRANSITION_GROUP;
+    }
+  },
+  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+  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;
+  }
+};
+
+const transformStyle = (node) => {
+  if (node.type === 1) {
+    node.props.forEach((p, i) => {
+      if (p.type === 6 && p.name === "style" && p.value) {
+        node.props[i] = {
+          type: 7,
+          name: `bind`,
+          arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
+          exp: parseInlineCSS(p.value.content, p.loc),
+          modifiers: [],
+          loc: p.loc
+        };
+      }
+    });
+  }
+};
+const parseInlineCSS = (cssText, loc) => {
+  const normalized = shared.parseStringStyle(cssText);
+  return compilerCore.createSimpleExpression(
+    JSON.stringify(normalized),
+    false,
+    loc,
+    3
+  );
+};
+
+function createDOMCompilerError(code, loc) {
+  return compilerCore.createCompilerError(
+    code,
+    loc,
+    DOMErrorMessages 
+  );
+}
+const 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__"
+};
+const DOMErrorMessages = {
+  [53]: `v-html is missing expression.`,
+  [54]: `v-html will override element children.`,
+  [55]: `v-text is missing expression.`,
+  [56]: `v-text will override element children.`,
+  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [58]: `v-model argument is not supported on plain elements.`,
+  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [61]: `v-show is missing expression.`,
+  [62]: `<Transition> expects exactly one child element or component.`,
+  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(53, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(54, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`innerHTML`, true, loc),
+        exp || compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformVText = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(55, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(56, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`textContent`, true),
+        exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
+          context.helperString(compilerCore.TO_DISPLAY_STRING),
+          [exp],
+          loc
+        ) : compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformModel = (dir, node, context) => {
+  const baseResult = compilerCore.transformModel(dir, node, context);
+  if (!baseResult.props.length || node.tagType === 1) {
+    return baseResult;
+  }
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  }
+  function checkDuplicatedValue() {
+    const value = compilerCore.findDir(node, "bind");
+    if (value && compilerCore.isStaticArgOf(value.arg, "value")) {
+      context.onError(
+        createDOMCompilerError(
+          60,
+          value.loc
+        )
+      );
+    }
+  }
+  const { tag } = node;
+  const isCustomElement = context.isCustomElement(tag);
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    let directiveToUse = V_MODEL_TEXT;
+    let isInvalidType = false;
+    if (tag === "input" || isCustomElement) {
+      const type = compilerCore.findProp(node, `type`);
+      if (type) {
+        if (type.type === 7) {
+          directiveToUse = V_MODEL_DYNAMIC;
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              directiveToUse = V_MODEL_RADIO;
+              break;
+            case "checkbox":
+              directiveToUse = V_MODEL_CHECKBOX;
+              break;
+            case "file":
+              isInvalidType = true;
+              context.onError(
+                createDOMCompilerError(
+                  59,
+                  dir.loc
+                )
+              );
+              break;
+            default:
+              checkDuplicatedValue();
+              break;
+          }
+        }
+      } else if (compilerCore.hasDynamicKeyVBind(node)) {
+        directiveToUse = V_MODEL_DYNAMIC;
+      } else {
+        checkDuplicatedValue();
+      }
+    } else if (tag === "select") {
+      directiveToUse = V_MODEL_SELECT;
+    } else {
+      checkDuplicatedValue();
+    }
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse);
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  baseResult.props = baseResult.props.filter(
+    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+  );
+  return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
+  // event propagation management
+  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);
+const 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" && compilerCore.checkCompatEnabled(
+      "COMPILER_V_ON_NATIVE",
+      context,
+      loc
+    )) {
+      eventOptionModifiers.push(modifier);
+    } else if (isEventOptionModifier(modifier)) {
+      eventOptionModifiers.push(modifier);
+    } else {
+      if (maybeKeyModifier(modifier)) {
+        if (compilerCore.isStaticExp(key)) {
+          if (isKeyboardEvent(key.content.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
+  };
+};
+const transformClick = (key, event) => {
+  const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
+  return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
+    `(`,
+    key,
+    `) === "onClick" ? "${event}" : (`,
+    key,
+    `)`
+  ]) : key;
+};
+const transformOn = (dir, node, context) => {
+  return compilerCore.transformOn(dir, node, context, (baseResult) => {
+    const { modifiers } = dir;
+    if (!modifiers.length) return baseResult;
+    let { key, value: handlerExp } = baseResult.props[0];
+    const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+    if (nonKeyModifiers.includes("right")) {
+      key = transformClick(key, `onContextmenu`);
+    }
+    if (nonKeyModifiers.includes("middle")) {
+      key = transformClick(key, `onMouseup`);
+    }
+    if (nonKeyModifiers.length) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+        handlerExp,
+        JSON.stringify(nonKeyModifiers)
+      ]);
+    }
+    if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+    (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
+        handlerExp,
+        JSON.stringify(keyModifiers)
+      ]);
+    }
+    if (eventOptionModifiers.length) {
+      const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
+      key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+    }
+    return {
+      props: [compilerCore.createObjectProperty(key, handlerExp)]
+    };
+  });
+};
+
+const transformShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(61, loc)
+    );
+  }
+  return {
+    props: [],
+    needRuntime: context.helper(V_SHOW)
+  };
+};
+
+const transformTransition = (node, context) => {
+  if (node.type === 1 && node.tagType === 1) {
+    const component = context.isBuiltInComponent(node.tag);
+    if (component === TRANSITION) {
+      return () => {
+        if (!node.children.length) {
+          return;
+        }
+        if (hasMultipleChildren(node)) {
+          context.onError(
+            createDOMCompilerError(
+              62,
+              {
+                start: node.children[0].loc.start,
+                end: node.children[node.children.length - 1].loc.end,
+                source: ""
+              }
+            )
+          );
+        }
+        const child = node.children[0];
+        if (child.type === 1) {
+          for (const p of child.props) {
+            if (p.type === 7 && p.name === "show") {
+              node.props.push({
+                type: 6,
+                name: "persisted",
+                nameLoc: node.loc,
+                value: void 0,
+                loc: node.loc
+              });
+            }
+          }
+        }
+      };
+    }
+  }
+};
+function hasMultipleChildren(node) {
+  const children = node.children = node.children.filter(
+    (c) => !compilerCore.isCommentOrWhitespace(c)
+  );
+  const child = children[0];
+  return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
+}
+
+const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
+const stringifyStatic = (children, context, parent) => {
+  if (context.scopes.vSlot > 0) {
+    return;
+  }
+  const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
+  let nc = 0;
+  let ec = 0;
+  const currentChunk = [];
+  const stringifyCurrentChunk = (currentIndex) => {
+    if (nc >= 20 || ec >= 5) {
+      const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
+        JSON.stringify(
+          currentChunk.map((node) => stringifyNode(node, context)).join("")
+        ).replace(expReplaceRE, `" + $1 + "`),
+        // the 2nd argument indicates the number of DOM nodes this static vnode
+        // will insert / hydrate
+        String(currentChunk.length)
+      ]);
+      const deleteCount = currentChunk.length - 1;
+      if (isParentCached) {
+        children.splice(
+          currentIndex - currentChunk.length,
+          currentChunk.length,
+          // @ts-expect-error
+          staticCall
+        );
+      } else {
+        currentChunk[0].codegenNode.value = staticCall;
+        if (currentChunk.length > 1) {
+          children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+          const cacheIndex = context.cached.indexOf(
+            currentChunk[currentChunk.length - 1].codegenNode
+          );
+          if (cacheIndex > -1) {
+            for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {
+              const c = context.cached[i2];
+              if (c) c.index -= deleteCount;
+            }
+            context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
+          }
+        }
+      }
+      return deleteCount;
+    }
+    return 0;
+  };
+  let i = 0;
+  for (; i < children.length; i++) {
+    const child = children[i];
+    const isCached = isParentCached || getCachedNode(child);
+    if (isCached) {
+      const result = analyzeNode(child);
+      if (result) {
+        nc += result[0];
+        ec += result[1];
+        currentChunk.push(child);
+        continue;
+      }
+    }
+    i -= stringifyCurrentChunk(i);
+    nc = 0;
+    ec = 0;
+    currentChunk.length = 0;
+  }
+  stringifyCurrentChunk(i);
+};
+const getCachedNode = (node) => {
+  if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {
+    return node.codegenNode;
+  }
+};
+const dataAriaRE = /^(?:data|aria)-/;
+const isStringifiableAttr = (name, ns) => {
+  return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
+};
+const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
+  `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
+);
+function analyzeNode(node) {
+  if (node.type === 1 && isNonStringifiable(node.tag)) {
+    return false;
+  }
+  if (node.type === 1 && compilerCore.findDir(node, "once", true)) {
+    return false;
+  }
+  if (node.type === 12) {
+    return [1, 0];
+  }
+  let nc = 1;
+  let ec = node.props.length > 0 ? 1 : 0;
+  let bailed = false;
+  const bail = () => {
+    bailed = true;
+    return false;
+  };
+  function walk(node2) {
+    const isOptionTag = node2.tag === "option" && node2.ns === 0;
+    for (let i = 0; i < node2.props.length; i++) {
+      const p = node2.props[i];
+      if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
+        return bail();
+      }
+      if (p.type === 7 && p.name === "bind") {
+        if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
+          return bail();
+        }
+        if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
+          return bail();
+        }
+        if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) {
+          return bail();
+        }
+      }
+    }
+    for (let i = 0; i < node2.children.length; i++) {
+      nc++;
+      const child = node2.children[i];
+      if (child.type === 1) {
+        if (child.props.length > 0) {
+          ec++;
+        }
+        walk(child);
+        if (bailed) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  return walk(node) ? [nc, ec] : false;
+}
+function stringifyNode(node, context) {
+  if (shared.isString(node)) {
+    return node;
+  }
+  if (shared.isSymbol(node)) {
+    return ``;
+  }
+  switch (node.type) {
+    case 1:
+      return stringifyElement(node, context);
+    case 2:
+      return shared.escapeHtml(node.content);
+    case 3:
+      return `<!--${shared.escapeHtml(node.content)}-->`;
+    case 5:
+      return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
+    case 8:
+      return shared.escapeHtml(evaluateConstant(node));
+    case 12:
+      return stringifyNode(node.content, context);
+    default:
+      return "";
+  }
+}
+function stringifyElement(node, context) {
+  let res = `<${node.tag}`;
+  let innerHTML = "";
+  for (let i = 0; i < node.props.length; i++) {
+    const p = node.props[i];
+    if (p.type === 6) {
+      res += ` ${p.name}`;
+      if (p.value) {
+        res += `="${shared.escapeHtml(p.value.content)}"`;
+      }
+    } else if (p.type === 7) {
+      if (p.name === "bind") {
+        const exp = p.exp;
+        if (exp.content[0] === "_") {
+          res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+          continue;
+        }
+        if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
+          continue;
+        }
+        let evaluated = evaluateConstant(exp);
+        if (evaluated != null) {
+          const arg = p.arg && p.arg.content;
+          if (arg === "class") {
+            evaluated = shared.normalizeClass(evaluated);
+          } else if (arg === "style") {
+            evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+          }
+          res += ` ${p.arg.content}="${shared.escapeHtml(
+            evaluated
+          )}"`;
+        }
+      } else if (p.name === "html") {
+        innerHTML = evaluateConstant(p.exp);
+      } else if (p.name === "text") {
+        innerHTML = shared.escapeHtml(
+          shared.toDisplayString(evaluateConstant(p.exp))
+        );
+      }
+    }
+  }
+  if (context.scopeId) {
+    res += ` ${context.scopeId}`;
+  }
+  res += `>`;
+  if (innerHTML) {
+    res += innerHTML;
+  } else {
+    for (let i = 0; i < node.children.length; i++) {
+      res += stringifyNode(node.children[i], context);
+    }
+  }
+  if (!shared.isVoidTag(node.tag)) {
+    res += `</${node.tag}>`;
+  }
+  return res;
+}
+function evaluateConstant(exp) {
+  if (exp.type === 4) {
+    return new Function(`return (${exp.content})`)();
+  } else {
+    let res = ``;
+    exp.children.forEach((c) => {
+      if (shared.isString(c) || shared.isSymbol(c)) {
+        return;
+      }
+      if (c.type === 2) {
+        res += c.content;
+      } else if (c.type === 5) {
+        res += shared.toDisplayString(evaluateConstant(c.content));
+      } else {
+        res += evaluateConstant(c);
+      }
+    });
+    return res;
+  }
+}
+
+const ignoreSideEffectTags = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+    context.onError(
+      createDOMCompilerError(
+        63,
+        node.loc
+      )
+    );
+    context.removeNode();
+  }
+};
+
+function isValidHTMLNesting(parent, child) {
+  if (parent === "template") {
+    return true;
+  }
+  if (parent in onlyValidChildren) {
+    return onlyValidChildren[parent].has(child);
+  }
+  if (child in onlyValidParents) {
+    return onlyValidParents[child].has(parent);
+  }
+  if (parent in knownInvalidChildren) {
+    if (knownInvalidChildren[parent].has(child)) return false;
+  }
+  if (child in knownInvalidParents) {
+    if (knownInvalidParents[child].has(parent)) return false;
+  }
+  return true;
+}
+const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+const emptySet = /* @__PURE__ */ new Set([]);
+const onlyValidChildren = {
+  head: /* @__PURE__ */ new Set([
+    "base",
+    "basefront",
+    "bgsound",
+    "link",
+    "meta",
+    "title",
+    "noscript",
+    "noframes",
+    "style",
+    "script",
+    "template"
+  ]),
+  optgroup: /* @__PURE__ */ new Set(["option"]),
+  select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]),
+  // table
+  table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
+  tr: /* @__PURE__ */ new Set(["td", "th"]),
+  colgroup: /* @__PURE__ */ new Set(["col"]),
+  tbody: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["tr"]),
+  tfoot: /* @__PURE__ */ new Set(["tr"]),
+  // these elements can not have any children elements
+  script: emptySet,
+  iframe: emptySet,
+  option: emptySet,
+  textarea: emptySet,
+  style: emptySet,
+  title: emptySet
+};
+const onlyValidParents = {
+  // sections
+  html: emptySet,
+  body: /* @__PURE__ */ new Set(["html"]),
+  head: /* @__PURE__ */ new Set(["html"]),
+  // table
+  td: /* @__PURE__ */ new Set(["tr"]),
+  colgroup: /* @__PURE__ */ new Set(["table"]),
+  caption: /* @__PURE__ */ new Set(["table"]),
+  tbody: /* @__PURE__ */ new Set(["table"]),
+  tfoot: /* @__PURE__ */ new Set(["table"]),
+  col: /* @__PURE__ */ new Set(["colgroup"]),
+  th: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["table"]),
+  tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
+  // data list
+  dd: /* @__PURE__ */ new Set(["dl", "div"]),
+  dt: /* @__PURE__ */ new Set(["dl", "div"]),
+  // other
+  figcaption: /* @__PURE__ */ new Set(["figure"]),
+  // li: new Set(["ul", "ol"]),
+  summary: /* @__PURE__ */ new Set(["details"]),
+  area: /* @__PURE__ */ new Set(["map"])
+};
+const knownInvalidChildren = {
+  p: /* @__PURE__ */ new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "center",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "fieldset",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "menu",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "ul"
+  ]),
+  svg: /* @__PURE__ */ new Set([
+    "b",
+    "blockquote",
+    "br",
+    "code",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "menu",
+    "meta",
+    "ol",
+    "p",
+    "pre",
+    "ruby",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "table",
+    "u",
+    "ul",
+    "var"
+  ])
+};
+const knownInvalidParents = {
+  a: /* @__PURE__ */ new Set(["a"]),
+  button: /* @__PURE__ */ new Set(["button"]),
+  dd: /* @__PURE__ */ new Set(["dd", "dt"]),
+  dt: /* @__PURE__ */ new Set(["dd", "dt"]),
+  form: /* @__PURE__ */ new Set(["form"]),
+  li: /* @__PURE__ */ new Set(["li"]),
+  h1: headings,
+  h2: headings,
+  h3: headings,
+  h4: headings,
+  h5: headings,
+  h6: headings
+};
+
+const validateHtmlNesting = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
+    const error = new SyntaxError(
+      `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`
+    );
+    error.loc = node.loc;
+    context.onWarn(error);
+  }
+};
+
+const DOMNodeTransforms = [
+  transformStyle,
+  ...[transformTransition, validateHtmlNesting] 
+];
+const DOMDirectiveTransforms = {
+  cloak: compilerCore.noopDirectiveTransform,
+  html: transformVHtml,
+  text: transformVText,
+  model: transformModel,
+  // override compiler-core
+  on: transformOn,
+  // override compiler-core
+  show: transformShow
+};
+function compile(src, options = {}) {
+  return compilerCore.baseCompile(
+    src,
+    shared.extend({}, parserOptions, options, {
+      nodeTransforms: [
+        // ignore <script> and <tag>
+        // this is not put inside DOMNodeTransforms because that list is used
+        // by compiler-ssr to generate vnode fallback branches
+        ignoreSideEffectTags,
+        ...DOMNodeTransforms,
+        ...options.nodeTransforms || []
+      ],
+      directiveTransforms: shared.extend(
+        {},
+        DOMDirectiveTransforms,
+        options.directiveTransforms || {}
+      ),
+      transformHoist: stringifyStatic
+    })
+  );
+}
+function parse(template, options = {}) {
+  return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
+}
+
+exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
+exports.DOMErrorCodes = DOMErrorCodes;
+exports.DOMErrorMessages = DOMErrorMessages;
+exports.DOMNodeTransforms = DOMNodeTransforms;
+exports.TRANSITION = TRANSITION;
+exports.TRANSITION_GROUP = TRANSITION_GROUP;
+exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
+exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
+exports.V_MODEL_RADIO = V_MODEL_RADIO;
+exports.V_MODEL_SELECT = V_MODEL_SELECT;
+exports.V_MODEL_TEXT = V_MODEL_TEXT;
+exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
+exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
+exports.V_SHOW = V_SHOW;
+exports.compile = compile;
+exports.createDOMCompilerError = createDOMCompilerError;
+exports.parse = parse;
+exports.parserOptions = parserOptions;
+exports.transformStyle = transformStyle;
+Object.keys(compilerCore).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
+});

node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.prod.js

@@ -0,0 +1,689 @@
+/**
+* @vue/compiler-dom v3.5.25
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerCore = require('@vue/compiler-core');
+var shared = require('@vue/shared');
+
+const V_MODEL_RADIO = Symbol(``);
+const V_MODEL_CHECKBOX = Symbol(
+  ``
+);
+const V_MODEL_TEXT = Symbol(``);
+const V_MODEL_SELECT = Symbol(
+  ``
+);
+const V_MODEL_DYNAMIC = Symbol(
+  ``
+);
+const V_ON_WITH_MODIFIERS = Symbol(
+  ``
+);
+const V_ON_WITH_KEYS = Symbol(
+  ``
+);
+const V_SHOW = Symbol(``);
+const TRANSITION = Symbol(``);
+const TRANSITION_GROUP = Symbol(
+  ``
+);
+compilerCore.registerRuntimeHelpers({
+  [V_MODEL_RADIO]: `vModelRadio`,
+  [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+  [V_MODEL_TEXT]: `vModelText`,
+  [V_MODEL_SELECT]: `vModelSelect`,
+  [V_MODEL_DYNAMIC]: `vModelDynamic`,
+  [V_ON_WITH_MODIFIERS]: `withModifiers`,
+  [V_ON_WITH_KEYS]: `withKeys`,
+  [V_SHOW]: `vShow`,
+  [TRANSITION]: `Transition`,
+  [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+const parserOptions = {
+  parseMode: "html",
+  isVoidTag: shared.isVoidTag,
+  isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),
+  isPreTag: (tag) => tag === "pre",
+  isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
+  decodeEntities: void 0,
+  isBuiltInComponent: (tag) => {
+    if (tag === "Transition" || tag === "transition") {
+      return TRANSITION;
+    } else if (tag === "TransitionGroup" || tag === "transition-group") {
+      return TRANSITION_GROUP;
+    }
+  },
+  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+  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;
+  }
+};
+
+const transformStyle = (node) => {
+  if (node.type === 1) {
+    node.props.forEach((p, i) => {
+      if (p.type === 6 && p.name === "style" && p.value) {
+        node.props[i] = {
+          type: 7,
+          name: `bind`,
+          arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
+          exp: parseInlineCSS(p.value.content, p.loc),
+          modifiers: [],
+          loc: p.loc
+        };
+      }
+    });
+  }
+};
+const parseInlineCSS = (cssText, loc) => {
+  const normalized = shared.parseStringStyle(cssText);
+  return compilerCore.createSimpleExpression(
+    JSON.stringify(normalized),
+    false,
+    loc,
+    3
+  );
+};
+
+function createDOMCompilerError(code, loc) {
+  return compilerCore.createCompilerError(
+    code,
+    loc,
+    DOMErrorMessages 
+  );
+}
+const 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__"
+};
+const DOMErrorMessages = {
+  [53]: `v-html is missing expression.`,
+  [54]: `v-html will override element children.`,
+  [55]: `v-text is missing expression.`,
+  [56]: `v-text will override element children.`,
+  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [58]: `v-model argument is not supported on plain elements.`,
+  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [61]: `v-show is missing expression.`,
+  [62]: `<Transition> expects exactly one child element or component.`,
+  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(53, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(54, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`innerHTML`, true, loc),
+        exp || compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformVText = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(55, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(56, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      compilerCore.createObjectProperty(
+        compilerCore.createSimpleExpression(`textContent`, true),
+        exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
+          context.helperString(compilerCore.TO_DISPLAY_STRING),
+          [exp],
+          loc
+        ) : compilerCore.createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformModel = (dir, node, context) => {
+  const baseResult = compilerCore.transformModel(dir, node, context);
+  if (!baseResult.props.length || node.tagType === 1) {
+    return baseResult;
+  }
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  }
+  const { tag } = node;
+  const isCustomElement = context.isCustomElement(tag);
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    let directiveToUse = V_MODEL_TEXT;
+    let isInvalidType = false;
+    if (tag === "input" || isCustomElement) {
+      const type = compilerCore.findProp(node, `type`);
+      if (type) {
+        if (type.type === 7) {
+          directiveToUse = V_MODEL_DYNAMIC;
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              directiveToUse = V_MODEL_RADIO;
+              break;
+            case "checkbox":
+              directiveToUse = V_MODEL_CHECKBOX;
+              break;
+            case "file":
+              isInvalidType = true;
+              context.onError(
+                createDOMCompilerError(
+                  59,
+                  dir.loc
+                )
+              );
+              break;
+          }
+        }
+      } else if (compilerCore.hasDynamicKeyVBind(node)) {
+        directiveToUse = V_MODEL_DYNAMIC;
+      } else ;
+    } else if (tag === "select") {
+      directiveToUse = V_MODEL_SELECT;
+    } else ;
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse);
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  baseResult.props = baseResult.props.filter(
+    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+  );
+  return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
+  // event propagation management
+  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);
+const 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" && compilerCore.checkCompatEnabled(
+      "COMPILER_V_ON_NATIVE",
+      context,
+      loc
+    )) {
+      eventOptionModifiers.push(modifier);
+    } else if (isEventOptionModifier(modifier)) {
+      eventOptionModifiers.push(modifier);
+    } else {
+      if (maybeKeyModifier(modifier)) {
+        if (compilerCore.isStaticExp(key)) {
+          if (isKeyboardEvent(key.content.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
+  };
+};
+const transformClick = (key, event) => {
+  const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
+  return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
+    `(`,
+    key,
+    `) === "onClick" ? "${event}" : (`,
+    key,
+    `)`
+  ]) : key;
+};
+const transformOn = (dir, node, context) => {
+  return compilerCore.transformOn(dir, node, context, (baseResult) => {
+    const { modifiers } = dir;
+    if (!modifiers.length) return baseResult;
+    let { key, value: handlerExp } = baseResult.props[0];
+    const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+    if (nonKeyModifiers.includes("right")) {
+      key = transformClick(key, `onContextmenu`);
+    }
+    if (nonKeyModifiers.includes("middle")) {
+      key = transformClick(key, `onMouseup`);
+    }
+    if (nonKeyModifiers.length) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+        handlerExp,
+        JSON.stringify(nonKeyModifiers)
+      ]);
+    }
+    if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+    (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
+      handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
+        handlerExp,
+        JSON.stringify(keyModifiers)
+      ]);
+    }
+    if (eventOptionModifiers.length) {
+      const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
+      key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+    }
+    return {
+      props: [compilerCore.createObjectProperty(key, handlerExp)]
+    };
+  });
+};
+
+const transformShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(61, loc)
+    );
+  }
+  return {
+    props: [],
+    needRuntime: context.helper(V_SHOW)
+  };
+};
+
+const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
+const stringifyStatic = (children, context, parent) => {
+  if (context.scopes.vSlot > 0) {
+    return;
+  }
+  const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
+  let nc = 0;
+  let ec = 0;
+  const currentChunk = [];
+  const stringifyCurrentChunk = (currentIndex) => {
+    if (nc >= 20 || ec >= 5) {
+      const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
+        JSON.stringify(
+          currentChunk.map((node) => stringifyNode(node, context)).join("")
+        ).replace(expReplaceRE, `" + $1 + "`),
+        // the 2nd argument indicates the number of DOM nodes this static vnode
+        // will insert / hydrate
+        String(currentChunk.length)
+      ]);
+      const deleteCount = currentChunk.length - 1;
+      if (isParentCached) {
+        children.splice(
+          currentIndex - currentChunk.length,
+          currentChunk.length,
+          // @ts-expect-error
+          staticCall
+        );
+      } else {
+        currentChunk[0].codegenNode.value = staticCall;
+        if (currentChunk.length > 1) {
+          children.splice(currentIndex - currentChunk.length + 1, deleteCount);
+          const cacheIndex = context.cached.indexOf(
+            currentChunk[currentChunk.length - 1].codegenNode
+          );
+          if (cacheIndex > -1) {
+            for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {
+              const c = context.cached[i2];
+              if (c) c.index -= deleteCount;
+            }
+            context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
+          }
+        }
+      }
+      return deleteCount;
+    }
+    return 0;
+  };
+  let i = 0;
+  for (; i < children.length; i++) {
+    const child = children[i];
+    const isCached = isParentCached || getCachedNode(child);
+    if (isCached) {
+      const result = analyzeNode(child);
+      if (result) {
+        nc += result[0];
+        ec += result[1];
+        currentChunk.push(child);
+        continue;
+      }
+    }
+    i -= stringifyCurrentChunk(i);
+    nc = 0;
+    ec = 0;
+    currentChunk.length = 0;
+  }
+  stringifyCurrentChunk(i);
+};
+const getCachedNode = (node) => {
+  if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {
+    return node.codegenNode;
+  }
+};
+const dataAriaRE = /^(?:data|aria)-/;
+const isStringifiableAttr = (name, ns) => {
+  return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
+};
+const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
+  `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
+);
+function analyzeNode(node) {
+  if (node.type === 1 && isNonStringifiable(node.tag)) {
+    return false;
+  }
+  if (node.type === 1 && compilerCore.findDir(node, "once", true)) {
+    return false;
+  }
+  if (node.type === 12) {
+    return [1, 0];
+  }
+  let nc = 1;
+  let ec = node.props.length > 0 ? 1 : 0;
+  let bailed = false;
+  const bail = () => {
+    bailed = true;
+    return false;
+  };
+  function walk(node2) {
+    const isOptionTag = node2.tag === "option" && node2.ns === 0;
+    for (let i = 0; i < node2.props.length; i++) {
+      const p = node2.props[i];
+      if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
+        return bail();
+      }
+      if (p.type === 7 && p.name === "bind") {
+        if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
+          return bail();
+        }
+        if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
+          return bail();
+        }
+        if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) {
+          return bail();
+        }
+      }
+    }
+    for (let i = 0; i < node2.children.length; i++) {
+      nc++;
+      const child = node2.children[i];
+      if (child.type === 1) {
+        if (child.props.length > 0) {
+          ec++;
+        }
+        walk(child);
+        if (bailed) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  return walk(node) ? [nc, ec] : false;
+}
+function stringifyNode(node, context) {
+  if (shared.isString(node)) {
+    return node;
+  }
+  if (shared.isSymbol(node)) {
+    return ``;
+  }
+  switch (node.type) {
+    case 1:
+      return stringifyElement(node, context);
+    case 2:
+      return shared.escapeHtml(node.content);
+    case 3:
+      return `<!--${shared.escapeHtml(node.content)}-->`;
+    case 5:
+      return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
+    case 8:
+      return shared.escapeHtml(evaluateConstant(node));
+    case 12:
+      return stringifyNode(node.content, context);
+    default:
+      return "";
+  }
+}
+function stringifyElement(node, context) {
+  let res = `<${node.tag}`;
+  let innerHTML = "";
+  for (let i = 0; i < node.props.length; i++) {
+    const p = node.props[i];
+    if (p.type === 6) {
+      res += ` ${p.name}`;
+      if (p.value) {
+        res += `="${shared.escapeHtml(p.value.content)}"`;
+      }
+    } else if (p.type === 7) {
+      if (p.name === "bind") {
+        const exp = p.exp;
+        if (exp.content[0] === "_") {
+          res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
+          continue;
+        }
+        if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
+          continue;
+        }
+        let evaluated = evaluateConstant(exp);
+        if (evaluated != null) {
+          const arg = p.arg && p.arg.content;
+          if (arg === "class") {
+            evaluated = shared.normalizeClass(evaluated);
+          } else if (arg === "style") {
+            evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
+          }
+          res += ` ${p.arg.content}="${shared.escapeHtml(
+            evaluated
+          )}"`;
+        }
+      } else if (p.name === "html") {
+        innerHTML = evaluateConstant(p.exp);
+      } else if (p.name === "text") {
+        innerHTML = shared.escapeHtml(
+          shared.toDisplayString(evaluateConstant(p.exp))
+        );
+      }
+    }
+  }
+  if (context.scopeId) {
+    res += ` ${context.scopeId}`;
+  }
+  res += `>`;
+  if (innerHTML) {
+    res += innerHTML;
+  } else {
+    for (let i = 0; i < node.children.length; i++) {
+      res += stringifyNode(node.children[i], context);
+    }
+  }
+  if (!shared.isVoidTag(node.tag)) {
+    res += `</${node.tag}>`;
+  }
+  return res;
+}
+function evaluateConstant(exp) {
+  if (exp.type === 4) {
+    return new Function(`return (${exp.content})`)();
+  } else {
+    let res = ``;
+    exp.children.forEach((c) => {
+      if (shared.isString(c) || shared.isSymbol(c)) {
+        return;
+      }
+      if (c.type === 2) {
+        res += c.content;
+      } else if (c.type === 5) {
+        res += shared.toDisplayString(evaluateConstant(c.content));
+      } else {
+        res += evaluateConstant(c);
+      }
+    });
+    return res;
+  }
+}
+
+const ignoreSideEffectTags = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+    context.removeNode();
+  }
+};
+
+const DOMNodeTransforms = [
+  transformStyle,
+  ...[]
+];
+const DOMDirectiveTransforms = {
+  cloak: compilerCore.noopDirectiveTransform,
+  html: transformVHtml,
+  text: transformVText,
+  model: transformModel,
+  // override compiler-core
+  on: transformOn,
+  // override compiler-core
+  show: transformShow
+};
+function compile(src, options = {}) {
+  return compilerCore.baseCompile(
+    src,
+    shared.extend({}, parserOptions, options, {
+      nodeTransforms: [
+        // ignore <script> and <tag>
+        // this is not put inside DOMNodeTransforms because that list is used
+        // by compiler-ssr to generate vnode fallback branches
+        ignoreSideEffectTags,
+        ...DOMNodeTransforms,
+        ...options.nodeTransforms || []
+      ],
+      directiveTransforms: shared.extend(
+        {},
+        DOMDirectiveTransforms,
+        options.directiveTransforms || {}
+      ),
+      transformHoist: stringifyStatic
+    })
+  );
+}
+function parse(template, options = {}) {
+  return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
+}
+
+exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
+exports.DOMErrorCodes = DOMErrorCodes;
+exports.DOMErrorMessages = DOMErrorMessages;
+exports.DOMNodeTransforms = DOMNodeTransforms;
+exports.TRANSITION = TRANSITION;
+exports.TRANSITION_GROUP = TRANSITION_GROUP;
+exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
+exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
+exports.V_MODEL_RADIO = V_MODEL_RADIO;
+exports.V_MODEL_SELECT = V_MODEL_SELECT;
+exports.V_MODEL_TEXT = V_MODEL_TEXT;
+exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
+exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
+exports.V_SHOW = V_SHOW;
+exports.compile = compile;
+exports.createDOMCompilerError = createDOMCompilerError;
+exports.parse = parse;
+exports.parserOptions = parserOptions;
+exports.transformStyle = transformStyle;
+Object.keys(compilerCore).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
+});

node_modules/@vue/compiler-dom/dist/compiler-dom.d.ts

@@ -0,0 +1,45 @@
+import { ParserOptions, NodeTransform, SourceLocation, CompilerError, DirectiveTransform, RootNode, CompilerOptions, CodegenResult } from '@vue/compiler-core';
+export * from '@vue/compiler-core';
+
+export declare const parserOptions: ParserOptions;
+
+export declare const V_MODEL_RADIO: unique symbol;
+export declare const V_MODEL_CHECKBOX: unique symbol;
+export declare const V_MODEL_TEXT: unique symbol;
+export declare const V_MODEL_SELECT: unique symbol;
+export declare const V_MODEL_DYNAMIC: unique symbol;
+export declare const V_ON_WITH_MODIFIERS: unique symbol;
+export declare const V_ON_WITH_KEYS: unique symbol;
+export declare const V_SHOW: unique symbol;
+export declare const TRANSITION: unique symbol;
+export declare const TRANSITION_GROUP: unique symbol;
+
+export declare const transformStyle: NodeTransform;
+
+interface DOMCompilerError extends CompilerError {
+    code: DOMErrorCodes;
+}
+export declare function createDOMCompilerError(code: DOMErrorCodes, loc?: SourceLocation): DOMCompilerError;
+export declare enum DOMErrorCodes {
+    X_V_HTML_NO_EXPRESSION = 53,
+    X_V_HTML_WITH_CHILDREN = 54,
+    X_V_TEXT_NO_EXPRESSION = 55,
+    X_V_TEXT_WITH_CHILDREN = 56,
+    X_V_MODEL_ON_INVALID_ELEMENT = 57,
+    X_V_MODEL_ARG_ON_ELEMENT = 58,
+    X_V_MODEL_ON_FILE_INPUT_ELEMENT = 59,
+    X_V_MODEL_UNNECESSARY_VALUE = 60,
+    X_V_SHOW_NO_EXPRESSION = 61,
+    X_TRANSITION_INVALID_CHILDREN = 62,
+    X_IGNORED_SIDE_EFFECT_TAG = 63,
+    __EXTEND_POINT__ = 64
+}
+export declare const DOMErrorMessages: {
+    [code: number]: string;
+};
+
+export declare const DOMNodeTransforms: NodeTransform[];
+export declare const DOMDirectiveTransforms: Record<string, DirectiveTransform>;
+export declare function compile(src: string | RootNode, options?: CompilerOptions): CodegenResult;
+export declare function parse(template: string, options?: ParserOptions): RootNode;
+

node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js

@@ -0,0 +1,690 @@
+/**
+* @vue/compiler-dom v3.5.25
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+import { registerRuntimeHelpers, createSimpleExpression, createCompilerError, createObjectProperty, createCallExpression, getConstantType, TO_DISPLAY_STRING, transformModel as transformModel$1, findProp, hasDynamicKeyVBind, findDir, isStaticArgOf, transformOn as transformOn$1, isStaticExp, createCompoundExpression, checkCompatEnabled, isCommentOrWhitespace, noopDirectiveTransform, baseCompile, baseParse } from '@vue/compiler-core';
+export * from '@vue/compiler-core';
+import { isHTMLTag, isSVGTag, isMathMLTag, isVoidTag, parseStringStyle, makeMap, capitalize, extend } from '@vue/shared';
+
+const V_MODEL_RADIO = Symbol(!!(process.env.NODE_ENV !== "production") ? `vModelRadio` : ``);
+const V_MODEL_CHECKBOX = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelCheckbox` : ``
+);
+const V_MODEL_TEXT = Symbol(!!(process.env.NODE_ENV !== "production") ? `vModelText` : ``);
+const V_MODEL_SELECT = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelSelect` : ``
+);
+const V_MODEL_DYNAMIC = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vModelDynamic` : ``
+);
+const V_ON_WITH_MODIFIERS = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vOnModifiersGuard` : ``
+);
+const V_ON_WITH_KEYS = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `vOnKeysGuard` : ``
+);
+const V_SHOW = Symbol(!!(process.env.NODE_ENV !== "production") ? `vShow` : ``);
+const TRANSITION = Symbol(!!(process.env.NODE_ENV !== "production") ? `Transition` : ``);
+const TRANSITION_GROUP = Symbol(
+  !!(process.env.NODE_ENV !== "production") ? `TransitionGroup` : ``
+);
+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`
+});
+
+let decoder;
+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;
+  }
+}
+
+const 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;
+    }
+  },
+  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+  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;
+  }
+};
+
+const transformStyle = (node) => {
+  if (node.type === 1) {
+    node.props.forEach((p, i) => {
+      if (p.type === 6 && p.name === "style" && p.value) {
+        node.props[i] = {
+          type: 7,
+          name: `bind`,
+          arg: createSimpleExpression(`style`, true, p.loc),
+          exp: parseInlineCSS(p.value.content, p.loc),
+          modifiers: [],
+          loc: p.loc
+        };
+      }
+    });
+  }
+};
+const parseInlineCSS = (cssText, loc) => {
+  const normalized = parseStringStyle(cssText);
+  return createSimpleExpression(
+    JSON.stringify(normalized),
+    false,
+    loc,
+    3
+  );
+};
+
+function createDOMCompilerError(code, loc) {
+  return createCompilerError(
+    code,
+    loc,
+    !!(process.env.NODE_ENV !== "production") || false ? DOMErrorMessages : void 0
+  );
+}
+const 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__"
+};
+const DOMErrorMessages = {
+  [53]: `v-html is missing expression.`,
+  [54]: `v-html will override element children.`,
+  [55]: `v-text is missing expression.`,
+  [56]: `v-text will override element children.`,
+  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+  [58]: `v-model argument is not supported on plain elements.`,
+  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+  [61]: `v-show is missing expression.`,
+  [62]: `<Transition> expects exactly one child element or component.`,
+  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(53, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(54, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      createObjectProperty(
+        createSimpleExpression(`innerHTML`, true, loc),
+        exp || createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformVText = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(55, loc)
+    );
+  }
+  if (node.children.length) {
+    context.onError(
+      createDOMCompilerError(56, loc)
+    );
+    node.children.length = 0;
+  }
+  return {
+    props: [
+      createObjectProperty(
+        createSimpleExpression(`textContent`, true),
+        exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(
+          context.helperString(TO_DISPLAY_STRING),
+          [exp],
+          loc
+        ) : createSimpleExpression("", true)
+      )
+    ]
+  };
+};
+
+const transformModel = (dir, node, context) => {
+  const baseResult = transformModel$1(dir, node, context);
+  if (!baseResult.props.length || node.tagType === 1) {
+    return baseResult;
+  }
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        58,
+        dir.arg.loc
+      )
+    );
+  }
+  function checkDuplicatedValue() {
+    const value = findDir(node, "bind");
+    if (value && isStaticArgOf(value.arg, "value")) {
+      context.onError(
+        createDOMCompilerError(
+          60,
+          value.loc
+        )
+      );
+    }
+  }
+  const { tag } = node;
+  const isCustomElement = context.isCustomElement(tag);
+  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+    let directiveToUse = V_MODEL_TEXT;
+    let isInvalidType = false;
+    if (tag === "input" || isCustomElement) {
+      const type = 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:
+              !!(process.env.NODE_ENV !== "production") && checkDuplicatedValue();
+              break;
+          }
+        }
+      } else if (hasDynamicKeyVBind(node)) {
+        directiveToUse = V_MODEL_DYNAMIC;
+      } else {
+        !!(process.env.NODE_ENV !== "production") && checkDuplicatedValue();
+      }
+    } else if (tag === "select") {
+      directiveToUse = V_MODEL_SELECT;
+    } else {
+      !!(process.env.NODE_ENV !== "production") && checkDuplicatedValue();
+    }
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse);
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        57,
+        dir.loc
+      )
+    );
+  }
+  baseResult.props = baseResult.props.filter(
+    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+  );
+  return baseResult;
+};
+
+const isEventOptionModifier = /* @__PURE__ */ makeMap(`passive,once,capture`);
+const isNonKeyModifier = /* @__PURE__ */ makeMap(
+  // event propagation management
+  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+);
+const maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
+const isKeyboardEvent = /* @__PURE__ */ makeMap(`onkeyup,onkeydown,onkeypress`);
+const 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
+  };
+};
+const transformClick = (key, event) => {
+  const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
+  return isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
+    `(`,
+    key,
+    `) === "onClick" ? "${event}" : (`,
+    key,
+    `)`
+  ]) : key;
+};
+const transformOn = (dir, node, context) => {
+  return transformOn$1(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 && // if event name is dynamic, always wrap with keys guard
+    (!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)]
+    };
+  });
+};
+
+const transformShow = (dir, node, context) => {
+  const { exp, loc } = dir;
+  if (!exp) {
+    context.onError(
+      createDOMCompilerError(61, loc)
+    );
+  }
+  return {
+    props: [],
+    needRuntime: context.helper(V_SHOW)
+  };
+};
+
+const transformTransition = (node, context) => {
+  if (node.type === 1 && node.tagType === 1) {
+    const component = context.isBuiltInComponent(node.tag);
+    if (component === TRANSITION) {
+      return () => {
+        if (!node.children.length) {
+          return;
+        }
+        if (hasMultipleChildren(node)) {
+          context.onError(
+            createDOMCompilerError(
+              62,
+              {
+                start: node.children[0].loc.start,
+                end: node.children[node.children.length - 1].loc.end,
+                source: ""
+              }
+            )
+          );
+        }
+        const child = node.children[0];
+        if (child.type === 1) {
+          for (const p of child.props) {
+            if (p.type === 7 && p.name === "show") {
+              node.props.push({
+                type: 6,
+                name: "persisted",
+                nameLoc: node.loc,
+                value: void 0,
+                loc: node.loc
+              });
+            }
+          }
+        }
+      };
+    }
+  }
+};
+function hasMultipleChildren(node) {
+  const children = node.children = node.children.filter(
+    (c) => !isCommentOrWhitespace(c)
+  );
+  const child = children[0];
+  return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
+}
+
+const ignoreSideEffectTags = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+    !!(process.env.NODE_ENV !== "production") && context.onError(
+      createDOMCompilerError(
+        63,
+        node.loc
+      )
+    );
+    context.removeNode();
+  }
+};
+
+function isValidHTMLNesting(parent, child) {
+  if (parent === "template") {
+    return true;
+  }
+  if (parent in onlyValidChildren) {
+    return onlyValidChildren[parent].has(child);
+  }
+  if (child in onlyValidParents) {
+    return onlyValidParents[child].has(parent);
+  }
+  if (parent in knownInvalidChildren) {
+    if (knownInvalidChildren[parent].has(child)) return false;
+  }
+  if (child in knownInvalidParents) {
+    if (knownInvalidParents[child].has(parent)) return false;
+  }
+  return true;
+}
+const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+const emptySet = /* @__PURE__ */ new Set([]);
+const onlyValidChildren = {
+  head: /* @__PURE__ */ new Set([
+    "base",
+    "basefront",
+    "bgsound",
+    "link",
+    "meta",
+    "title",
+    "noscript",
+    "noframes",
+    "style",
+    "script",
+    "template"
+  ]),
+  optgroup: /* @__PURE__ */ new Set(["option"]),
+  select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]),
+  // table
+  table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
+  tr: /* @__PURE__ */ new Set(["td", "th"]),
+  colgroup: /* @__PURE__ */ new Set(["col"]),
+  tbody: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["tr"]),
+  tfoot: /* @__PURE__ */ new Set(["tr"]),
+  // these elements can not have any children elements
+  script: emptySet,
+  iframe: emptySet,
+  option: emptySet,
+  textarea: emptySet,
+  style: emptySet,
+  title: emptySet
+};
+const onlyValidParents = {
+  // sections
+  html: emptySet,
+  body: /* @__PURE__ */ new Set(["html"]),
+  head: /* @__PURE__ */ new Set(["html"]),
+  // table
+  td: /* @__PURE__ */ new Set(["tr"]),
+  colgroup: /* @__PURE__ */ new Set(["table"]),
+  caption: /* @__PURE__ */ new Set(["table"]),
+  tbody: /* @__PURE__ */ new Set(["table"]),
+  tfoot: /* @__PURE__ */ new Set(["table"]),
+  col: /* @__PURE__ */ new Set(["colgroup"]),
+  th: /* @__PURE__ */ new Set(["tr"]),
+  thead: /* @__PURE__ */ new Set(["table"]),
+  tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
+  // data list
+  dd: /* @__PURE__ */ new Set(["dl", "div"]),
+  dt: /* @__PURE__ */ new Set(["dl", "div"]),
+  // other
+  figcaption: /* @__PURE__ */ new Set(["figure"]),
+  // li: new Set(["ul", "ol"]),
+  summary: /* @__PURE__ */ new Set(["details"]),
+  area: /* @__PURE__ */ new Set(["map"])
+};
+const knownInvalidChildren = {
+  p: /* @__PURE__ */ new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "center",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "fieldset",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "menu",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "ul"
+  ]),
+  svg: /* @__PURE__ */ new Set([
+    "b",
+    "blockquote",
+    "br",
+    "code",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "menu",
+    "meta",
+    "ol",
+    "p",
+    "pre",
+    "ruby",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "table",
+    "u",
+    "ul",
+    "var"
+  ])
+};
+const knownInvalidParents = {
+  a: /* @__PURE__ */ new Set(["a"]),
+  button: /* @__PURE__ */ new Set(["button"]),
+  dd: /* @__PURE__ */ new Set(["dd", "dt"]),
+  dt: /* @__PURE__ */ new Set(["dd", "dt"]),
+  form: /* @__PURE__ */ new Set(["form"]),
+  li: /* @__PURE__ */ new Set(["li"]),
+  h1: headings,
+  h2: headings,
+  h3: headings,
+  h4: headings,
+  h5: headings,
+  h6: headings
+};
+
+const validateHtmlNesting = (node, context) => {
+  if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
+    const error = new SyntaxError(
+      `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`
+    );
+    error.loc = node.loc;
+    context.onWarn(error);
+  }
+};
+
+const DOMNodeTransforms = [
+  transformStyle,
+  ...!!(process.env.NODE_ENV !== "production") ? [transformTransition, validateHtmlNesting] : []
+];
+const DOMDirectiveTransforms = {
+  cloak: noopDirectiveTransform,
+  html: transformVHtml,
+  text: transformVText,
+  model: transformModel,
+  // override compiler-core
+  on: transformOn,
+  // override compiler-core
+  show: transformShow
+};
+function compile(src, options = {}) {
+  return baseCompile(
+    src,
+    extend({}, parserOptions, options, {
+      nodeTransforms: [
+        // ignore <script> and <tag>
+        // this is not put inside DOMNodeTransforms because that list is used
+        // by compiler-ssr to generate vnode fallback branches
+        ignoreSideEffectTags,
+        ...DOMNodeTransforms,
+        ...options.nodeTransforms || []
+      ],
+      directiveTransforms: extend(
+        {},
+        DOMDirectiveTransforms,
+        options.directiveTransforms || {}
+      ),
+      transformHoist: null 
+    })
+  );
+}
+function parse(template, options = {}) {
+  return baseParse(template, extend({}, parserOptions, options));
+}
+
+export { DOMDirectiveTransforms, DOMErrorCodes, DOMErrorMessages, DOMNodeTransforms, TRANSITION, TRANSITION_GROUP, V_MODEL_CHECKBOX, V_MODEL_DYNAMIC, V_MODEL_RADIO, V_MODEL_SELECT, V_MODEL_TEXT, V_ON_WITH_KEYS, V_ON_WITH_MODIFIERS, V_SHOW, compile, createDOMCompilerError, parse, parserOptions, transformStyle };

node_modules/@vue/compiler-dom/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-dom.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-dom.cjs.js')
+}

node_modules/@vue/compiler-dom/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@vue/compiler-dom",
+  "version": "3.5.25",
+  "description": "@vue/compiler-dom",
+  "main": "index.js",
+  "module": "dist/compiler-dom.esm-bundler.js",
+  "types": "dist/compiler-dom.d.ts",
+  "unpkg": "dist/compiler-dom.global.js",
+  "jsdelivr": "dist/compiler-dom.global.js",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-dom.d.ts",
+      "node": {
+        "production": "./dist/compiler-dom.cjs.prod.js",
+        "development": "./dist/compiler-dom.cjs.js",
+        "default": "./index.js"
+      },
+      "module": "./dist/compiler-dom.esm-bundler.js",
+      "import": "./dist/compiler-dom.esm-bundler.js",
+      "require": "./index.js"
+    },
+    "./*": "./*"
+  },
+  "sideEffects": false,
+  "buildOptions": {
+    "name": "VueCompilerDOM",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-dom"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-dom#readme",
+  "dependencies": {
+    "@vue/shared": "3.5.25",
+    "@vue/compiler-core": "3.5.25"
+  }
+}

node_modules/@vue/compiler-vue2/README.md

@@ -0,0 +1,162 @@
+# vue-template-compiler
+
+> This package is auto-generated. For pull requests please see [src/platforms/web/entry-compiler.js](https://github.com/vuejs/vue/tree/dev/src/platforms/web/entry-compiler.js).
+
+This package can be used to pre-compile Vue 2.0 templates into render functions to avoid runtime-compilation overhead and CSP restrictions. In most cases you should be using it with [`vue-loader`](https://github.com/vuejs/vue-loader), you will only need it separately if you are writing build tools with very specific needs.
+
+## Installation
+
+``` bash
+npm install vue-template-compiler
+```
+
+``` js
+const compiler = require('vue-template-compiler')
+```
+
+## API
+
+### compiler.compile(template, [options])
+
+Compiles a template string and returns compiled JavaScript code. The returned result is an object of the following format:
+
+``` js
+{
+  ast: ?ASTElement, // parsed template elements to AST
+  render: string, // main render function code
+  staticRenderFns: Array<string>, // render code for static sub trees, if any
+  errors: Array<string> // template syntax errors, if any
+}
+```
+
+Note the returned function code uses `with` and thus cannot be used in strict mode code.
+
+#### Options
+
+- `outputSourceRange` *new in 2.6*
+  - Type: `boolean`
+  - Default: `false`
+
+  Set this to true will cause the `errors` returned in the compiled result become objects in the form of `{ msg, start, end }`. The `start` and `end` properties are numbers that mark the code range of the error source in the template. This can be passed on to the `compiler.generateCodeFrame` API to generate a code frame for the error.
+
+- `whitespace`
+  - Type: `string`
+  - Valid values: `'preserve' | 'condense'`
+  - Default: `'preserve'`
+
+  The default value `'preserve'` handles whitespaces as follows:
+
+  - A whitespace-only text node between element tags is condensed into a single space.
+  - All other whitespaces are preserved as-is.
+
+  If set to `'condense'`:
+
+  - A whitespace-only text node between element tags is removed if it contains new lines. Otherwise, it is condensed into a single space.
+  - Consecutive whitespaces inside a non-whitespace-only text node are condensed into a single space.
+
+  Using condense mode will result in smaller compiled code size and slightly improved performance. However, it will produce minor visual layout differences compared to plain HTML in certain cases.
+
+  **This option does not affect the `<pre>` tag.**
+
+  Example:
+
+  ``` html
+  <!-- source -->
+  <div>
+    <span>
+      foo
+    </span>   <span>bar</span>
+  </div>
+
+  <!-- whitespace: 'preserve' -->
+  <div> <span>
+    foo
+    </span> <span>bar</span> </div>
+
+  <!-- whitespace: 'condense' -->
+  <div><span> foo </span> <span>bar</span></div>
+  ```
+
+- `modules`
+
+  It's possible to hook into the compilation process to support custom template features. **However, beware that by injecting custom compile-time modules, your templates will not work with other build tools built on standard built-in modules, e.g `vue-loader` and `vueify`.**
+
+  An array of compiler modules. For details on compiler modules, refer to the `ModuleOptions` type in [flow declarations](https://github.com/vuejs/vue/blob/dev/flow/compiler.js#L47-L59) and the [built-in modules](https://github.com/vuejs/vue/tree/dev/src/platforms/web/compiler/modules).
+
+- `directives`
+
+  An object where the key is the directive name and the value is a function that transforms an template AST node. For example:
+
+  ``` js
+  compiler.compile('<div v-test></div>', {
+    directives: {
+      test (node, directiveMeta) {
+        // transform node based on directiveMeta
+      }
+    }
+  })
+  ```
+
+  By default, a compile-time directive will extract the directive and the directive will not be present at runtime. If you want the directive to also be handled by a runtime definition, return `true` in the transform function.
+
+  Refer to the implementation of some [built-in compile-time directives](https://github.com/vuejs/vue/tree/dev/src/platforms/web/compiler/directives).
+
+- `preserveWhitespace` **Deprecated since 2.6**
+  - Type: `boolean`
+  - Default: `true`
+
+  By default, the compiled render function preserves all whitespace characters between HTML tags. If set to `false`, whitespace between tags will be ignored. This can result in slightly better performance but may affect layout for inline elements.
+
+---
+
+### compiler.compileToFunctions(template)
+
+Similar to `compiler.compile`, but directly returns instantiated functions:
+
+``` js
+{
+  render: Function,
+  staticRenderFns: Array<Function>
+}
+```
+
+This is only useful at runtime with pre-configured builds, so it doesn't accept any compile-time options. In addition, this method uses `new Function()` so it is not CSP-compliant.
+
+---
+
+### compiler.ssrCompile(template, [options])
+
+> 2.4.0+
+
+Same as `compiler.compile` but generates SSR-specific render function code by optimizing parts of the template into string concatenation in order to improve SSR performance.
+
+This is used by default in `vue-loader@>=12` and can be disabled using the [`optimizeSSR`](https://vue-loader.vuejs.org/en/options.html#optimizessr) option.
+
+---
+
+### compiler.ssrCompileToFunctions(template)
+
+> 2.4.0+
+
+Same as `compiler.compileToFunction` but generates SSR-specific render function code by optimizing parts of the template into string concatenation in order to improve SSR performance.
+
+---
+
+### compiler.parseComponent(file, [options])
+
+Parse a SFC (single-file component, or `*.vue` file) into a descriptor (refer to the `SFCDescriptor` type in [flow declarations](https://github.com/vuejs/vue/blob/dev/flow/compiler.js)). This is used in SFC build tools like `vue-loader` and `vueify`.
+
+---
+
+### compiler.generateCodeFrame(template, start, end)
+
+Generate a code frame that highlights the part in `template` defined by `start` and `end`. Useful for error reporting in higher-level tooling.
+
+#### Options
+
+#### `pad`
+
+`pad` is useful when you are piping the extracted content into other pre-processors, as you will get correct line numbers or character indices if there are any syntax errors.
+
+- with `{ pad: "line" }`, the extracted content for each block will be prefixed with one newline for each line in the leading content from the original file to ensure that the line numbers align with the original file.
+- with `{ pad: "space" }`, the extracted content for each block will be prefixed with one space for each character in the leading content from the original file to ensure that the character count remains the same as the original file.

node_modules/@vue/compiler-vue2/index.js

@@ -0,0 +1,32 @@
+try {
+  var vueVersion = require('vue').version
+} catch (e) {}
+
+var packageName = require('./package.json').name
+var packageVersion = require('./package.json').version
+if (vueVersion && vueVersion !== packageVersion) {
+  var vuePath = require.resolve('vue')
+  var packagePath = require.resolve('./package.json')
+  throw new Error(
+    '\n\nVue packages version mismatch:\n\n' +
+      '- vue@' +
+      vueVersion +
+      ' (' +
+      vuePath +
+      ')\n' +
+      '- ' +
+      packageName +
+      '@' +
+      packageVersion +
+      ' (' +
+      packagePath +
+      ')\n\n' +
+      'This may cause things to work incorrectly. Make sure to use the same version for both.\n' +
+      'If you are using vue-loader@>=10.0, simply update vue-template-compiler.\n' +
+      'If you are using vue-loader@<10.0 or vueify, re-installing vue-loader/vueify should bump ' +
+      packageName +
+      ' to the latest.\n'
+  )
+}
+
+module.exports = require('./build')

node_modules/@vue/compiler-vue2/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@vue/compiler-vue2",
+  "version": "2.7.16",
+  "description": "template compiler for Vue 2.x",
+  "main": "index.js",
+  "unpkg": "browser.js",
+  "jsdelivr": "browser.js",
+  "browser": "browser.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "types/*.d.ts",
+    "*.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vue.git"
+  },
+  "keywords": [
+    "vue",
+    "compiler"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/vue/issues"
+  },
+  "homepage": "https://github.com/vuejs/vue/tree/dev/packages/vue-template-compiler#readme",
+  "dependencies": {
+    "de-indent": "^1.0.2",
+    "he": "^1.2.0"
+  },
+  "devDependencies": {
+    "vue": "file:../.."
+  }
+}

node_modules/@vue/compiler-vue2/types/index.d.ts

@@ -0,0 +1,247 @@
+import { VNode } from 'vue'
+
+/*
+ * Template compilation options / results
+ */
+interface CompilerOptions {
+  modules?: ModuleOptions[]
+  directives?: Record<string, DirectiveFunction>
+  preserveWhitespace?: boolean
+  whitespace?: 'preserve' | 'condense'
+  outputSourceRange?: any
+}
+
+interface CompilerOptionsWithSourceRange extends CompilerOptions {
+  outputSourceRange: true
+}
+
+interface ErrorWithRange {
+  msg: string
+  start: number
+  end: number
+}
+
+interface CompiledResult<ErrorType> {
+  ast: ASTElement | undefined
+  render: string
+  staticRenderFns: string[]
+  errors: ErrorType[]
+  tips: ErrorType[]
+}
+
+interface CompiledResultFunctions {
+  render: () => VNode
+  staticRenderFns: (() => VNode)[]
+}
+
+interface ModuleOptions {
+  preTransformNode: (el: ASTElement) => ASTElement | undefined
+  transformNode: (el: ASTElement) => ASTElement | undefined
+  postTransformNode: (el: ASTElement) => void
+  genData: (el: ASTElement) => string
+  transformCode?: (el: ASTElement, code: string) => string
+  staticKeys?: string[]
+}
+
+type DirectiveFunction = (node: ASTElement, directiveMeta: ASTDirective) => void
+
+/*
+ * AST Types
+ */
+
+/**
+ * - 0: FALSE - whole sub tree un-optimizable
+ * - 1: FULL - whole sub tree optimizable
+ * - 2: SELF - self optimizable but has some un-optimizable children
+ * - 3: CHILDREN - self un-optimizable but have fully optimizable children
+ * - 4: PARTIAL - self un-optimizable with some un-optimizable children
+ */
+export type SSROptimizability = 0 | 1 | 2 | 3 | 4
+
+export interface ASTModifiers {
+  [key: string]: boolean
+}
+
+export interface ASTIfCondition {
+  exp: string | undefined
+  block: ASTElement
+}
+
+export interface ASTElementHandler {
+  value: string
+  params?: any[]
+  modifiers: ASTModifiers | undefined
+}
+
+export interface ASTElementHandlers {
+  [key: string]: ASTElementHandler | ASTElementHandler[]
+}
+
+export interface ASTDirective {
+  name: string
+  rawName: string
+  value: string
+  arg: string | undefined
+  modifiers: ASTModifiers | undefined
+}
+
+export type ASTNode = ASTElement | ASTText | ASTExpression
+
+export interface ASTElement {
+  type: 1
+  tag: string
+  attrsList: { name: string; value: any }[]
+  attrsMap: Record<string, any>
+  parent: ASTElement | undefined
+  children: ASTNode[]
+
+  processed?: true
+
+  static?: boolean
+  staticRoot?: boolean
+  staticInFor?: boolean
+  staticProcessed?: boolean
+  hasBindings?: boolean
+
+  text?: string
+  attrs?: { name: string; value: any }[]
+  props?: { name: string; value: string }[]
+  plain?: boolean
+  pre?: true
+  ns?: string
+
+  component?: string
+  inlineTemplate?: true
+  transitionMode?: string | null
+  slotName?: string
+  slotTarget?: string
+  slotScope?: string
+  scopedSlots?: Record<string, ASTElement>
+
+  ref?: string
+  refInFor?: boolean
+
+  if?: string
+  ifProcessed?: boolean
+  elseif?: string
+  else?: true
+  ifConditions?: ASTIfCondition[]
+
+  for?: string
+  forProcessed?: boolean
+  key?: string
+  alias?: string
+  iterator1?: string
+  iterator2?: string
+
+  staticClass?: string
+  classBinding?: string
+  staticStyle?: string
+  styleBinding?: string
+  events?: ASTElementHandlers
+  nativeEvents?: ASTElementHandlers
+
+  transition?: string | true
+  transitionOnAppear?: boolean
+
+  model?: {
+    value: string
+    callback: string
+    expression: string
+  }
+
+  directives?: ASTDirective[]
+
+  forbidden?: true
+  once?: true
+  onceProcessed?: boolean
+  wrapData?: (code: string) => string
+  wrapListeners?: (code: string) => string
+
+  // 2.4 ssr optimization
+  ssrOptimizability?: SSROptimizability
+}
+
+export interface ASTExpression {
+  type: 2
+  expression: string
+  text: string
+  tokens: (string | Record<string, any>)[]
+  static?: boolean
+  // 2.4 ssr optimization
+  ssrOptimizability?: SSROptimizability
+}
+
+export interface ASTText {
+  type: 3
+  text: string
+  static?: boolean
+  isComment?: boolean
+  // 2.4 ssr optimization
+  ssrOptimizability?: SSROptimizability
+}
+
+/*
+ * SFC parser related types
+ */
+interface SFCParserOptions {
+  pad?: true | 'line' | 'space'
+  deindent?: boolean
+}
+
+export interface SFCBlock {
+  type: string
+  content: string
+  attrs: Record<string, string>
+  start?: number
+  end?: number
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
+}
+
+export interface SFCDescriptor {
+  template: SFCBlock | undefined
+  script: SFCBlock | undefined
+  styles: SFCBlock[]
+  customBlocks: SFCBlock[]
+}
+
+/*
+ * Exposed functions
+ */
+export function compile(
+  template: string,
+  options: CompilerOptionsWithSourceRange
+): CompiledResult<ErrorWithRange>
+
+export function compile(
+  template: string,
+  options?: CompilerOptions
+): CompiledResult<string>
+
+export function compileToFunctions(template: string): CompiledResultFunctions
+
+export function ssrCompile(
+  template: string,
+  options: CompilerOptionsWithSourceRange
+): CompiledResult<ErrorWithRange>
+
+export function ssrCompile(
+  template: string,
+  options?: CompilerOptions
+): CompiledResult<string>
+
+export function ssrCompileToFunctions(template: string): CompiledResultFunctions
+
+export function parseComponent(
+  file: string,
+  options?: SFCParserOptions
+): SFCDescriptor
+
+export function generateCodeFrame(
+  template: string,
+  start: number,
+  end: number
+): string

node_modules/@vue/language-core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@vue/language-core/index.d.ts

@@ -0,0 +1,14 @@
+export * from './lib/codegen/globalTypes';
+export * from './lib/codegen/template';
+export * from './lib/languagePlugin';
+export * from './lib/parsers/scriptSetupRanges';
+export * from './lib/plugins';
+export * from './lib/types';
+export * from './lib/utils/parseSfc';
+export * from './lib/utils/ts';
+export * from './lib/virtualFile/vueFile';
+export * as scriptRanges from './lib/parsers/scriptRanges';
+export { tsCodegen } from './lib/plugins/vue-tsx';
+export * from './lib/utils/shared';
+export * from '@volar/language-core';
+export type * as CompilerDOM from '@vue/compiler-dom';

node_modules/@vue/language-core/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsCodegen = exports.scriptRanges = void 0;
+__exportStar(require("./lib/codegen/globalTypes"), exports);
+__exportStar(require("./lib/codegen/template"), exports);
+__exportStar(require("./lib/languagePlugin"), exports);
+__exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
+__exportStar(require("./lib/plugins"), exports);
+__exportStar(require("./lib/types"), exports);
+__exportStar(require("./lib/utils/parseSfc"), exports);
+__exportStar(require("./lib/utils/ts"), exports);
+__exportStar(require("./lib/virtualFile/vueFile"), exports);
+exports.scriptRanges = require("./lib/parsers/scriptRanges");
+var vue_tsx_1 = require("./lib/plugins/vue-tsx");
+Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });
+__exportStar(require("./lib/utils/shared"), exports);
+__exportStar(require("@volar/language-core"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/lib/codegen/globalTypes.d.ts

@@ -0,0 +1 @@
+export declare function generateGlobalTypes(lib: string, target: number, strictTemplates: boolean): string;

node_modules/@vue/language-core/lib/codegen/globalTypes.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGlobalTypes = generateGlobalTypes;
+const shared_1 = require("../utils/shared");
+function generateGlobalTypes(lib, target, strictTemplates) {
+    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${strictTemplates ? '' : ' & Record<string, unknown>'}`;
+    let text = ``;
+    if (target < 3.5) {
+        text += `
+; declare module '${lib}' {
+	export interface GlobalComponents { }
+	export interface GlobalDirectives { }
+}`;
+    }
+    text += `
+; declare global {
+	const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
+	const __VLS_unref: typeof import('${lib}').unref;
+	const __VLS_placeholder: any;
+
+	const __VLS_nativeElements = {
+		...{} as SVGElementTagNameMap,
+		...{} as HTMLElementTagNameMap,
+	};
+
+	type __VLS_IntrinsicElements = ${(target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.IntrinsicElements;`
+        : `globalThis.JSX.IntrinsicElements;`)}
+	type __VLS_Element = ${(target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.Element;`
+        : `globalThis.JSX.Element;`)}
+	type __VLS_GlobalComponents = ${(target >= 3.5
+        ? `import('${lib}').GlobalComponents;`
+        : `import('${lib}').GlobalComponents & Pick<typeof import('${lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`)}
+	type __VLS_GlobalDirectives = import('${lib}').GlobalDirectives;
+	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+	type __VLS_unknownDirective = (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
+	type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> =
+		N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N1] } :
+		N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N2] } :
+		N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N3] } :
+		N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N1] } :
+		N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N2] } :
+		N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N3] } :
+		${strictTemplates ? '{}' : '{ [K in N0]: unknown }'};
+	type __VLS_FunctionalComponentProps<T, K> =
+		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
+		: T extends (props: infer P, ...args: any) => any ? P :
+		{};
+	type __VLS_IsFunction<T, K> = K extends keyof T
+		? __VLS_IsAny<T[K]> extends false
+		? unknown extends T[K]
+		? false
+		: true
+		: false
+		: false;
+	type __VLS_NormalizeComponentEvent<Props, Events, onEvent extends keyof Props, Event extends keyof Events, CamelizedEvent extends keyof Events> = (
+		__VLS_IsFunction<Props, onEvent> extends true
+			? Props
+			: __VLS_IsFunction<Events, Event> extends true
+				? { [K in onEvent]?: Events[Event] }
+				: __VLS_IsFunction<Events, CamelizedEvent> extends true
+					? { [K in onEvent]?: Events[CamelizedEvent] }
+					: Props
+	)${strictTemplates ? '' : ' & Record<string, unknown>'};
+	// fix https://github.com/vuejs/language-tools/issues/926
+	type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
+	type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R
+		? U extends T
+		? never
+		: __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R)
+		: never;
+	type __VLS_OverloadUnion<T> = Exclude<
+		__VLS_OverloadUnionInner<(() => never) & T>,
+		T extends () => never ? never : () => never
+	>;
+	type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F
+		? F extends (event: infer E, ...args: infer A) => any
+		? { [K in E & string]: (...args: A) => void; }
+		: never
+		: never;
+	type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
+		__VLS_UnionToIntersection<
+			__VLS_ConstructorOverloads<T> & {
+				[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+			}
+		>
+	>;
+	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
+	type __VLS_PickFunctionalComponentCtx<T, K> = NonNullable<__VLS_PickNotAny<
+		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
+		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
+	>>;
+	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
+
+	function __VLS_getVForSourceType(source: number): [number, number, number][];
+	function __VLS_getVForSourceType(source: string): [string, number, number][];
+	function __VLS_getVForSourceType<T extends any[]>(source: T): [
+		item: T[number],
+		key: number,
+		index: number,
+	][];
+	function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+		item: T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, 
+		key: number,
+		index: undefined,
+	][];
+	// #3845
+	function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
+		item: number | (Exclude<T, number> extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never), 
+		key: number,
+		index: undefined,
+	][];
+	function __VLS_getVForSourceType<T>(source: T): [
+		item: T[keyof T],
+		key: keyof T,
+		index: number,
+	][];
+	// @ts-ignore
+	function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+	// @ts-ignore
+	function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+	function __VLS_asFunctionalDirective<T>(dir: T): T extends import('${lib}').ObjectDirective
+		? NonNullable<T['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>
+		: T extends (...args: any) => any
+			? T
+			: __VLS_unknownDirective;
+	function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
+		T extends new (...args: any) => any
+		? (props: ${fnPropsType}, ctx?: any) => __VLS_Element & { __ctx?: {
+			attrs?: any,
+			slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : any,
+			emit?: K extends { $emit: infer Emit } ? Emit : any
+		} & { props?: ${fnPropsType}; expose?(exposed: K): void; } }
+		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+		: T extends (...args: any) => any ? T
+		: (_: {}${strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${strictTemplates ? '' : ' & Record<string, unknown>'} } };
+	function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
+	function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+	function __VLS_tryAsConstant<const T>(t: T): T;
+}
+`;
+    return text;
+}
+;
+//# sourceMappingURL=globalTypes.js.map

node_modules/@vue/language-core/lib/codegen/inlayHints.d.ts

@@ -0,0 +1,11 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+export interface InlayHintInfo {
+    blockName: string;
+    offset: number;
+    setting: string;
+    label: string;
+    tooltip?: string;
+    paddingRight?: boolean;
+    paddingLeft?: boolean;
+}
+export declare function createVBindShorthandInlayHintInfo(loc: CompilerDOM.SourceLocation, variableName: string): InlayHintInfo;

node_modules/@vue/language-core/lib/codegen/inlayHints.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVBindShorthandInlayHintInfo = createVBindShorthandInlayHintInfo;
+function createVBindShorthandInlayHintInfo(loc, variableName) {
+    return {
+        blockName: 'template',
+        offset: loc.end.offset,
+        setting: 'vue.inlayHints.vBindShorthand',
+        label: `="${variableName}"`,
+        tooltip: [
+            `This is a shorthand for \`${loc.source}="${variableName}"\`.`,
+            'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
+            '[More info](https://github.com/vuejs/core/pull/9451)',
+        ].join('\n\n'),
+    };
+}
+//# sourceMappingURL=inlayHints.js.map

node_modules/@vue/language-core/lib/codegen/localTypes.d.ts

@@ -0,0 +1,13 @@
+import type * as ts from 'typescript';
+import { VueCompilerOptions } from '../types';
+export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): {
+    generate: (names: string[]) => Generator<string, void, unknown>;
+    getUsedNames(): Set<string>;
+    readonly PrettifyLocal: string;
+    readonly OmitKeepDiscriminatedUnion: string;
+    readonly WithDefaults: string;
+    readonly WithTemplateSlots: string;
+    readonly PropsChildren: string;
+    readonly TypePropsToOption: string;
+    readonly OmitIndexSignature: string;
+};

node_modules/@vue/language-core/lib/codegen/localTypes.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalTypesGenerator = getLocalTypesGenerator;
+const shared_1 = require("../utils/shared");
+const utils_1 = require("./utils");
+function getLocalTypesGenerator(compilerOptions, vueCompilerOptions) {
+    const used = new Set();
+    const OmitKeepDiscriminatedUnion = defineHelper(`__VLS_OmitKeepDiscriminatedUnion`, () => `
+type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
+	? Pick<T, Exclude<keyof T, K>>
+	: never;
+`.trimStart());
+    const WithDefaults = defineHelper(`__VLS_WithDefaults`, () => `
+type __VLS_WithDefaults<P, D> = {
+	[K in keyof Pick<P, keyof P>]: K extends keyof D
+		? ${PrettifyLocal.name}<P[K] & { default: D[K]}>
+		: P[K]
+};
+`.trimStart());
+    const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {}${utils_1.endOfLine}`);
+    const WithTemplateSlots = defineHelper(`__VLS_WithTemplateSlots`, () => `
+type __VLS_WithTemplateSlots<T, S> = T & {
+	new(): {
+		${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;
+		${vueCompilerOptions.jsxSlots ? `$props: ${PropsChildren.name}<S>;` : ''}
+	}
+};
+`.trimStart());
+    const PropsChildren = defineHelper(`__VLS_PropsChildren`, () => `
+type __VLS_PropsChildren<S> = {
+	[K in keyof (
+		boolean extends (
+			// @ts-ignore
+			JSX.ElementChildrenAttribute extends never
+				? true
+				: false
+		)
+			? never
+			// @ts-ignore
+			: JSX.ElementChildrenAttribute
+	)]?: S;
+};
+`.trimStart());
+    const TypePropsToOption = defineHelper(`__VLS_TypePropsToOption`, () => compilerOptions.exactOptionalPropertyTypes ?
+        `
+type __VLS_TypePropsToOption<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K>
+		? { type: import('${vueCompilerOptions.lib}').PropType<T[K]> }
+		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+};
+`.trimStart() :
+        `
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K>
+		? { type: import('${vueCompilerOptions.lib}').PropType<__VLS_NonUndefinedable<T[K]>> }
+		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+};
+`.trimStart());
+    const OmitIndexSignature = defineHelper(`__VLS_OmitIndexSignature`, () => `type __VLS_OmitIndexSignature<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K]; }${utils_1.endOfLine}`);
+    const helpers = {
+        [PrettifyLocal.name]: PrettifyLocal,
+        [OmitKeepDiscriminatedUnion.name]: OmitKeepDiscriminatedUnion,
+        [WithDefaults.name]: WithDefaults,
+        [WithTemplateSlots.name]: WithTemplateSlots,
+        [PropsChildren.name]: PropsChildren,
+        [TypePropsToOption.name]: TypePropsToOption,
+        [OmitIndexSignature.name]: OmitIndexSignature,
+    };
+    used.clear();
+    return {
+        generate,
+        getUsedNames() {
+            return used;
+        },
+        get PrettifyLocal() { return PrettifyLocal.name; },
+        get OmitKeepDiscriminatedUnion() { return OmitKeepDiscriminatedUnion.name; },
+        get WithDefaults() { return WithDefaults.name; },
+        get WithTemplateSlots() { return WithTemplateSlots.name; },
+        get PropsChildren() { return PropsChildren.name; },
+        get TypePropsToOption() { return TypePropsToOption.name; },
+        get OmitIndexSignature() { return OmitIndexSignature.name; },
+    };
+    function* generate(names) {
+        const generated = new Set();
+        while (names.length) {
+            used.clear();
+            for (const name of names) {
+                if (generated.has(name)) {
+                    continue;
+                }
+                const helper = helpers[name];
+                yield helper.generate();
+                generated.add(name);
+            }
+            names = [...used].filter(name => !generated.has(name));
+        }
+    }
+    function defineHelper(name, generate) {
+        return {
+            get name() {
+                used.add(name);
+                return name;
+            },
+            generate,
+        };
+    }
+}
+//# sourceMappingURL=localTypes.js.map

node_modules/@vue/language-core/lib/codegen/script/component.d.ts

@@ -0,0 +1,8 @@
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateComponent(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateComponentSetupReturns(scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateEmitsOption(options: ScriptCodegenOptions, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generatePropsOption(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges, hasEmitsOption: boolean, inheritAttrs: boolean): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/component.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponent = generateComponent;
+exports.generateComponentSetupReturns = generateComponentSetupReturns;
+exports.generateEmitsOption = generateEmitsOption;
+exports.generatePropsOption = generatePropsOption;
+const utils_1 = require("../utils");
+const index_1 = require("./index");
+function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
+    if (options.sfc.script && options.scriptRanges?.exportDefault && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
+        // use defineComponent() from user space code if it exist
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, index_1.codeFeatures.all);
+        yield `{${utils_1.newLine}`;
+    }
+    else {
+        yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
+    }
+    yield `setup() {${utils_1.newLine}`;
+    yield `return {${utils_1.newLine}`;
+    if (ctx.bypassDefineComponent) {
+        yield* generateComponentSetupReturns(scriptSetupRanges);
+    }
+    if (scriptSetupRanges.defineExpose) {
+        yield `...__VLS_exposed,${utils_1.newLine}`;
+    }
+    yield `}${utils_1.endOfLine}`;
+    yield `},${utils_1.newLine}`;
+    if (!ctx.bypassDefineComponent) {
+        const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
+        for (const code of emitOptionCodes) {
+            yield code;
+        }
+        yield* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, !!emitOptionCodes.length, true);
+    }
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
+        const { args } = options.scriptRanges.exportDefault;
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.templateRefs.size) {
+        yield `__typeRefs: {} as __VLS_TemplateResult['refs'],${utils_1.newLine}`;
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.singleRootElType) {
+        yield `__typeEl: {} as __VLS_TemplateResult['rootEl'],${utils_1.newLine}`;
+    }
+    yield `})`;
+}
+function* generateComponentSetupReturns(scriptSetupRanges) {
+    // fill $props
+    if (scriptSetupRanges.defineProps) {
+        // NOTE: defineProps is inaccurate for $props
+        yield `$props: __VLS_makeOptional(${scriptSetupRanges.defineProps.name ?? `__VLS_props`}),${utils_1.newLine}`;
+        yield `...${scriptSetupRanges.defineProps.name ?? `__VLS_props`},${utils_1.newLine}`;
+    }
+    // fill $emit
+    if (scriptSetupRanges.defineEmits) {
+        yield `$emit: ${scriptSetupRanges.defineEmits.name ?? '__VLS_emit'},${utils_1.newLine}`;
+    }
+}
+function* generateEmitsOption(options, scriptSetupRanges) {
+    const codes = [];
+    if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+        codes.push({
+            optionExp: `{} as __VLS_NormalizeEmits<typeof __VLS_modelEmit>`,
+            typeOptionType: `__VLS_ModelEmit`,
+        });
+    }
+    if (scriptSetupRanges.defineEmits) {
+        const { name, typeArg, hasUnionTypeArg } = scriptSetupRanges.defineEmits;
+        codes.push({
+            optionExp: `{} as __VLS_NormalizeEmits<typeof ${name ?? '__VLS_emit'}>`,
+            typeOptionType: typeArg && !hasUnionTypeArg
+                ? `__VLS_Emit`
+                : undefined,
+        });
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionType)) {
+        if (codes.length === 1) {
+            yield `__typeEmits: {} as `;
+            yield codes[0].typeOptionType;
+            yield `,${utils_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `__typeEmits: {} as `;
+            yield codes[0].typeOptionType;
+            for (let i = 1; i < codes.length; i++) {
+                yield ` & `;
+                yield codes[i].typeOptionType;
+            }
+            yield `,${utils_1.newLine}`;
+        }
+    }
+    else if (codes.every(code => code.optionExp)) {
+        if (codes.length === 1) {
+            yield `emits: `;
+            yield codes[0].optionExp;
+            yield `,${utils_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `emits: {${utils_1.newLine}`;
+            for (const code of codes) {
+                yield `...`;
+                yield code.optionExp;
+                yield `,${utils_1.newLine}`;
+            }
+            yield `},${utils_1.newLine}`;
+        }
+    }
+}
+function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasEmitsOption, inheritAttrs) {
+    const codes = [];
+    if (ctx.generatedPropsType) {
+        codes.push({
+            optionExp: [
+                `{} as `,
+                scriptSetupRanges.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
+                `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
+                scriptSetupRanges.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
+            ].join(''),
+            typeOptionExp: `{} as __VLS_PublicProps`,
+        });
+    }
+    if (scriptSetupRanges.defineProps?.arg) {
+        const { arg } = scriptSetupRanges.defineProps;
+        codes.push({
+            optionExp: (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation),
+            typeOptionExp: undefined,
+        });
+    }
+    if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
+        let attrsType = `__VLS_TemplateResult['attrs']`;
+        if (hasEmitsOption) {
+            attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
+        }
+        const propsType = `__VLS_PickNotAny<${ctx.localTypes.OmitIndexSignature}<${attrsType}>, {}>`;
+        const optionType = `${ctx.localTypes.TypePropsToOption}<${propsType}>`;
+        codes.unshift({
+            optionExp: codes.length
+                ? `{} as ${optionType}`
+                // workaround for https://github.com/vuejs/core/pull/7419
+                : `{} as keyof ${propsType} extends never ? never: ${optionType}`,
+            typeOptionExp: `{} as ${attrsType}`,
+        });
+    }
+    const useTypeOption = options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionExp);
+    const useOption = !useTypeOption || scriptSetupRanges.withDefaults;
+    if (useTypeOption) {
+        if (codes.length === 1) {
+            yield `__typeProps: `;
+            yield codes[0].typeOptionExp;
+            yield `,${utils_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `__typeProps: {${utils_1.newLine}`;
+            for (const { typeOptionExp } of codes) {
+                yield `...`;
+                yield typeOptionExp;
+                yield `,${utils_1.newLine}`;
+            }
+            yield `},${utils_1.newLine}`;
+        }
+    }
+    if (useOption) {
+        if (codes.length === 1) {
+            yield `props: `;
+            yield codes[0].optionExp;
+            yield `,${utils_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `props: {${utils_1.newLine}`;
+            for (const { optionExp } of codes) {
+                yield `...`;
+                yield optionExp;
+                yield `,${utils_1.newLine}`;
+            }
+            yield `},${utils_1.newLine}`;
+        }
+    }
+}
+//# sourceMappingURL=component.js.map

node_modules/@vue/language-core/lib/codegen/script/componentSelf.d.ts

@@ -0,0 +1,5 @@
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import { type ScriptCodegenOptions } from './index';
+export declare function generateComponentSelf(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/componentSelf.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponentSelf = generateComponentSelf;
+const path = require("path-browserify");
+const utils_1 = require("../utils");
+const component_1 = require("./component");
+const index_1 = require("./index");
+const template_1 = require("./template");
+function* generateComponentSelf(options, ctx, templateCodegenCtx) {
+    if (options.sfc.scriptSetup && options.scriptSetupRanges) {
+        yield `const __VLS_self = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
+        yield `setup() {${utils_1.newLine}`;
+        yield `return {${utils_1.newLine}`;
+        if (ctx.bypassDefineComponent) {
+            yield* (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges);
+        }
+        // bindings
+        const templateUsageVars = (0, template_1.getTemplateUsageVars)(options, ctx);
+        for (const [content, bindings] of [
+            [options.sfc.scriptSetup.content, options.scriptSetupRanges.bindings],
+            options.sfc.script && options.scriptRanges
+                ? [options.sfc.script.content, options.scriptRanges.bindings]
+                : ['', []],
+        ]) {
+            for (const { range } of bindings) {
+                const varName = content.slice(range.start, range.end);
+                if (!templateUsageVars.has(varName) && !templateCodegenCtx.accessExternalVariables.has(varName)) {
+                    continue;
+                }
+                const templateOffset = options.getGeneratedLength();
+                yield `${varName}: ${varName} as typeof `;
+                const scriptOffset = options.getGeneratedLength();
+                yield `${varName},${utils_1.newLine}`;
+                options.linkedCodeMappings.push({
+                    sourceOffsets: [scriptOffset],
+                    generatedOffsets: [templateOffset],
+                    lengths: [varName.length],
+                    data: undefined,
+                });
+            }
+        }
+        yield `}${utils_1.endOfLine}`; // return {
+        yield `},${utils_1.newLine}`; // setup() {
+        if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
+            const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.scriptSetupRanges)];
+            for (const code of emitOptionCodes) {
+                yield code;
+            }
+            yield* (0, component_1.generatePropsOption)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges, !!emitOptionCodes.length, false);
+        }
+        if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
+            const { args } = options.scriptRanges.exportDefault;
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+        }
+        yield `})${utils_1.endOfLine}`; // defineComponent {
+    }
+    else if (options.sfc.script) {
+        yield `let __VLS_self!: typeof import('./${path.basename(options.fileName)}').default${utils_1.endOfLine}`;
+    }
+    else {
+        yield `const __VLS_self = (await import('${options.vueCompilerOptions.lib}')).defineComponent({})${utils_1.endOfLine}`;
+    }
+}
+//# sourceMappingURL=componentSelf.js.map

node_modules/@vue/language-core/lib/codegen/script/context.d.ts

@@ -0,0 +1,28 @@
+import { InlayHintInfo } from '../inlayHints';
+import type { ScriptCodegenOptions } from './index';
+export interface HelperType {
+    name: string;
+    used?: boolean;
+    generated?: boolean;
+    code: string;
+}
+export type ScriptCodegenContext = ReturnType<typeof createScriptCodegenContext>;
+export declare function createScriptCodegenContext(options: ScriptCodegenOptions): {
+    generatedTemplate: boolean;
+    generatedPropsType: boolean;
+    scriptSetupGeneratedOffset: number | undefined;
+    bypassDefineComponent: boolean;
+    bindingNames: Set<string>;
+    localTypes: {
+        generate: (names: string[]) => Generator<string, void, unknown>;
+        getUsedNames(): Set<string>;
+        readonly PrettifyLocal: string;
+        readonly OmitKeepDiscriminatedUnion: string;
+        readonly WithDefaults: string;
+        readonly WithTemplateSlots: string;
+        readonly PropsChildren: string;
+        readonly TypePropsToOption: string;
+        readonly OmitIndexSignature: string;
+    };
+    inlayHints: InlayHintInfo[];
+};

node_modules/@vue/language-core/lib/codegen/script/context.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScriptCodegenContext = createScriptCodegenContext;
+const localTypes_1 = require("../localTypes");
+function createScriptCodegenContext(options) {
+    const localTypes = (0, localTypes_1.getLocalTypesGenerator)(options.compilerOptions, options.vueCompilerOptions);
+    const inlayHints = [];
+    return {
+        generatedTemplate: false,
+        generatedPropsType: false,
+        scriptSetupGeneratedOffset: undefined,
+        bypassDefineComponent: options.lang === 'js' || options.lang === 'jsx',
+        bindingNames: new Set([
+            ...options.scriptRanges?.bindings.map(({ range }) => options.sfc.script.content.slice(range.start, range.end)) ?? [],
+            ...options.scriptSetupRanges?.bindings.map(({ range }) => options.sfc.scriptSetup.content.slice(range.start, range.end)) ?? [],
+        ]),
+        localTypes,
+        inlayHints,
+    };
+}
+//# sourceMappingURL=context.js.map

node_modules/@vue/language-core/lib/codegen/script/index.d.ts

@@ -0,0 +1,35 @@
+import type { Mapping } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { ScriptRanges } from '../../parsers/scriptRanges';
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc, VueCodeInformation, VueCompilerOptions } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
+import { ScriptCodegenContext } from './context';
+export declare const codeFeatures: {
+    all: VueCodeInformation;
+    none: VueCodeInformation;
+    verification: VueCodeInformation;
+    navigation: VueCodeInformation;
+    navigationWithoutRename: VueCodeInformation;
+};
+export interface ScriptCodegenOptions {
+    ts: typeof ts;
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    sfc: Sfc;
+    edited: boolean;
+    fileName: string;
+    lang: string;
+    scriptRanges: ScriptRanges | undefined;
+    scriptSetupRanges: ScriptSetupRanges | undefined;
+    templateCodegen: TemplateCodegenContext & {
+        codes: Code[];
+    } | undefined;
+    destructuredPropNames: Set<string>;
+    templateRefNames: Set<string>;
+    getGeneratedLength: () => number;
+    linkedCodeMappings: Mapping[];
+    appendGlobalTypes: boolean;
+}
+export declare function generateScript(options: ScriptCodegenOptions): Generator<Code, ScriptCodegenContext>;
+export declare function generateScriptSectionPartiallyEnding(source: string, end: number, mark: string): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/index.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFeatures = void 0;
+exports.generateScript = generateScript;
+exports.generateScriptSectionPartiallyEnding = generateScriptSectionPartiallyEnding;
+const path = require("path-browserify");
+const globalTypes_1 = require("../globalTypes");
+const utils_1 = require("../utils");
+const componentSelf_1 = require("./componentSelf");
+const context_1 = require("./context");
+const scriptSetup_1 = require("./scriptSetup");
+const src_1 = require("./src");
+const styleModulesType_1 = require("./styleModulesType");
+const template_1 = require("./template");
+exports.codeFeatures = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    none: {},
+    verification: {
+        verification: true,
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename() {
+                return false;
+            },
+        },
+    },
+};
+function* generateScript(options) {
+    const ctx = (0, context_1.createScriptCodegenContext)(options);
+    if (options.vueCompilerOptions.__setupedGlobalTypes) {
+        const globalTypes = options.vueCompilerOptions.__setupedGlobalTypes;
+        if (typeof globalTypes === 'object') {
+            let relativePath = path.relative(path.dirname(options.fileName), globalTypes.absolutePath);
+            if (relativePath !== globalTypes.absolutePath && !relativePath.startsWith('./') && !relativePath.startsWith('../')) {
+                relativePath = './' + relativePath;
+            }
+            yield `/// <reference types="${relativePath}" />${utils_1.newLine}`;
+        }
+        else {
+            yield `/// <reference types=".vue-global-types/${options.vueCompilerOptions.lib}_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}.d.ts" />${utils_1.newLine}`;
+        }
+    }
+    else {
+        yield `/* placeholder */`;
+    }
+    if (options.sfc.script?.src) {
+        yield* (0, src_1.generateSrc)(options.sfc.script, options.sfc.script.src);
+    }
+    if (options.sfc.script && options.scriptRanges) {
+        const { exportDefault, classBlockEnd } = options.scriptRanges;
+        const isExportRawObject = exportDefault
+            && options.sfc.script.content[exportDefault.expression.start] === '{';
+        if (options.sfc.scriptSetup && options.scriptSetupRanges) {
+            yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
+            if (exportDefault) {
+                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, exports.codeFeatures.all);
+                yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+            else {
+                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+                yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/both.vue');
+                yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+            }
+        }
+        else if (exportDefault && isExportRawObject && options.vueCompilerOptions.optionsWrapper.length) {
+            ctx.inlayHints.push({
+                blockName: options.sfc.script.name,
+                offset: exportDefault.expression.start,
+                setting: 'vue.inlayHints.optionsWrapper',
+                label: options.vueCompilerOptions.optionsWrapper.length
+                    ? options.vueCompilerOptions.optionsWrapper[0]
+                    : '[Missing optionsWrapper[0]]',
+                tooltip: [
+                    'This is virtual code that is automatically wrapped for type support, it does not affect your runtime behavior, you can customize it via `vueCompilerOptions.optionsWrapper` option in tsconfig / jsconfig.',
+                    'To hide it, you can set `"vue.inlayHints.optionsWrapper": false` in IDE settings.',
+                ].join('\n\n'),
+            }, {
+                blockName: options.sfc.script.name,
+                offset: exportDefault.expression.end,
+                setting: 'vue.inlayHints.optionsWrapper',
+                label: options.vueCompilerOptions.optionsWrapper.length >= 2
+                    ? options.vueCompilerOptions.optionsWrapper[1]
+                    : '[Missing optionsWrapper[1]]',
+            });
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, exports.codeFeatures.all);
+            yield options.vueCompilerOptions.optionsWrapper[0];
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.start, exportDefault.expression.end, exports.codeFeatures.all);
+            yield options.vueCompilerOptions.optionsWrapper[1];
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, exports.codeFeatures.all);
+        }
+        else if (classBlockEnd !== undefined) {
+            if (options.vueCompilerOptions.skipTemplateCodegen) {
+                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+            else {
+                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, classBlockEnd, exports.codeFeatures.all);
+                yield `__VLS_template = () => {${utils_1.newLine}`;
+                const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
+                yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
+                yield `}${utils_1.endOfLine}`;
+                yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, classBlockEnd, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+        }
+        else {
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+        }
+    }
+    else if (options.sfc.scriptSetup && options.scriptSetupRanges) {
+        yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
+        yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+    }
+    if (options.sfc.script) {
+        yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/script.vue');
+    }
+    if (options.sfc.scriptSetup) {
+        yield* generateScriptSectionPartiallyEnding(options.sfc.scriptSetup.name, options.sfc.scriptSetup.content.length, '#4569/main.vue');
+    }
+    if (!ctx.generatedTemplate) {
+        yield `function __VLS_template() {${utils_1.newLine}`;
+        const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
+        yield `}${utils_1.endOfLine}`;
+        yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
+    }
+    // #4788
+    yield* (0, styleModulesType_1.generateStyleModulesType)(options, ctx);
+    if (options.edited) {
+        yield `type __VLS_IntrinsicElementsCompletion = __VLS_IntrinsicElements${utils_1.endOfLine}`;
+    }
+    yield* ctx.localTypes.generate([...ctx.localTypes.getUsedNames()]);
+    if (options.appendGlobalTypes) {
+        yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions.lib, options.vueCompilerOptions.target, options.vueCompilerOptions.strictTemplates);
+    }
+    if (options.sfc.scriptSetup) {
+        yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, exports.codeFeatures.verification];
+    }
+    return ctx;
+}
+function* generateScriptSectionPartiallyEnding(source, end, mark) {
+    yield `;`;
+    yield ['', source, end, exports.codeFeatures.verification];
+    yield `/* PartiallyEnd: ${mark} */${utils_1.newLine}`;
+}
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/lib/codegen/script/scriptSetup.d.ts

@@ -0,0 +1,6 @@
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateScriptSetupImports(scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateScriptSetup(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/scriptSetup.js

@@ -0,0 +1,481 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScriptSetupImports = generateScriptSetupImports;
+exports.generateScriptSetup = generateScriptSetup;
+const utils_1 = require("../utils");
+const component_1 = require("./component");
+const componentSelf_1 = require("./componentSelf");
+const index_1 = require("./index");
+const template_1 = require("./template");
+function* generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
+    yield [
+        scriptSetup.content.slice(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)),
+        'scriptSetup',
+        0,
+        index_1.codeFeatures.all,
+    ];
+}
+function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
+    if (scriptSetup.generic) {
+        if (!options.scriptRanges?.exportDefault) {
+            if (options.sfc.scriptSetup) {
+                // #4569
+                yield [
+                    '',
+                    'scriptSetup',
+                    options.sfc.scriptSetup.content.length,
+                    index_1.codeFeatures.verification,
+                ];
+            }
+            yield `export default `;
+        }
+        yield `(<`;
+        yield [
+            scriptSetup.generic,
+            scriptSetup.name,
+            scriptSetup.genericOffset,
+            index_1.codeFeatures.all,
+        ];
+        if (!scriptSetup.generic.endsWith(`,`)) {
+            yield `,`;
+        }
+        yield `>(${utils_1.newLine}`
+            + `	__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'],${utils_1.newLine}`
+            + `	__VLS_ctx?: ${ctx.localTypes.PrettifyLocal}<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>,${utils_1.newLine}` // use __VLS_Prettify for less dts code
+            + `	__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],${utils_1.newLine}`
+            + `	__VLS_setup = (async () => {${utils_1.newLine}`;
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, undefined);
+        const emitTypes = [];
+        if (scriptSetupRanges.defineEmits) {
+            emitTypes.push(`typeof ${scriptSetupRanges.defineEmits.name ?? '__VLS_emit'}`);
+        }
+        if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+            emitTypes.push(`typeof __VLS_modelEmit`);
+        }
+        yield `return {} as {${utils_1.newLine}`
+            + `	props: ${ctx.localTypes.PrettifyLocal}<__VLS_OwnProps & __VLS_PublicProps & __VLS_TemplateResult['attrs']> & __VLS_BuiltInPublicProps,${utils_1.newLine}`
+            + `	expose(exposed: import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.defineExpose ? 'typeof __VLS_exposed' : '{}'}>): void,${utils_1.newLine}`
+            + `	attrs: any,${utils_1.newLine}`
+            + `	slots: __VLS_TemplateResult['slots'],${utils_1.newLine}`
+            + `	emit: ${emitTypes.length ? emitTypes.join(' & ') : `{}`},${utils_1.newLine}`
+            + `}${utils_1.endOfLine}`;
+        yield `})(),${utils_1.newLine}`; // __VLS_setup = (async () => {
+        yield `) => ({} as import('${options.vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))`;
+    }
+    else if (!options.sfc.script) {
+        // no script block, generate script setup code at root
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'export default');
+    }
+    else {
+        if (!options.scriptRanges?.exportDefault) {
+            yield `export default `;
+        }
+        yield `await (async () => {${utils_1.newLine}`;
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'return');
+        yield `})()`;
+    }
+}
+function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, syntax) {
+    ctx.scriptSetupGeneratedOffset = options.getGeneratedLength() - scriptSetupRanges.importSectionEndOffset;
+    let setupCodeModifies = [];
+    if (scriptSetupRanges.defineProps) {
+        const { name, statement, callExp, typeArg } = scriptSetupRanges.defineProps;
+        setupCodeModifies.push(...generateDefineWithType(scriptSetup, statement, scriptSetupRanges.withDefaults?.callExp ?? callExp, typeArg, name, '__VLS_props', '__VLS_Props'));
+    }
+    if (scriptSetupRanges.defineEmits) {
+        const { name, statement, callExp, typeArg } = scriptSetupRanges.defineEmits;
+        setupCodeModifies.push(...generateDefineWithType(scriptSetup, statement, callExp, typeArg, name, '__VLS_emit', '__VLS_Emit'));
+    }
+    if (scriptSetupRanges.defineSlots) {
+        const { name, callExp, isObjectBindingPattern } = scriptSetupRanges.defineSlots;
+        if (isObjectBindingPattern) {
+            setupCodeModifies.push([
+                [`__VLS_slots;\nconst __VLS_slots = `],
+                callExp.start,
+                callExp.start,
+            ]);
+        }
+        else if (!name) {
+            setupCodeModifies.push([
+                [`const __VLS_slots = `],
+                callExp.start,
+                callExp.start
+            ]);
+        }
+    }
+    if (scriptSetupRanges.defineExpose) {
+        const { callExp, arg, typeArg } = scriptSetupRanges.defineExpose;
+        if (typeArg) {
+            setupCodeModifies.push([
+                [
+                    `let __VLS_exposed!: `,
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, index_1.codeFeatures.navigation),
+                    `${utils_1.endOfLine}`,
+                ],
+                callExp.start,
+                callExp.start,
+            ]);
+        }
+        else if (arg) {
+            setupCodeModifies.push([
+                [
+                    `const __VLS_exposed = `,
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation),
+                    `${utils_1.endOfLine}`,
+                ],
+                callExp.start,
+                callExp.start,
+            ]);
+        }
+        else {
+            setupCodeModifies.push([
+                [`const __VLS_exposed = {}${utils_1.endOfLine}`],
+                callExp.start,
+                callExp.start,
+            ]);
+        }
+    }
+    // TODO: circular reference
+    // for (const { callExp } of scriptSetupRanges.useAttrs) {
+    // 	setupCodeModifies.push([
+    // 		[`(`],
+    // 		callExp.start,
+    // 		callExp.start
+    // 	], [
+    // 		[` as __VLS_TemplateResult['attrs'] & Record<string, unknown>)`],
+    // 		callExp.end,
+    // 		callExp.end
+    // 	]);
+    // }
+    for (const { callExp, exp, arg } of scriptSetupRanges.useCssModule) {
+        setupCodeModifies.push([
+            [`(`],
+            callExp.start,
+            callExp.start
+        ], [
+            arg ? [
+                ` as Omit<__VLS_StyleModules, '$style'>[`,
+                (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.all),
+                `])`
+            ] : [
+                ` as __VLS_StyleModules[`,
+                ['', scriptSetup.name, exp.start, index_1.codeFeatures.verification],
+                `'$style'`,
+                ['', scriptSetup.name, exp.end, utils_1.combineLastMapping],
+                `])`
+            ],
+            callExp.end,
+            callExp.end
+        ]);
+        if (arg) {
+            setupCodeModifies.push([
+                [`(__VLS_placeholder)`],
+                arg.start,
+                arg.end
+            ]);
+        }
+    }
+    for (const { callExp } of scriptSetupRanges.useSlots) {
+        setupCodeModifies.push([
+            [`(`],
+            callExp.start,
+            callExp.start
+        ], [
+            [` as __VLS_TemplateResult['slots'])`],
+            callExp.end,
+            callExp.end
+        ]);
+    }
+    const isTs = options.lang !== 'js' && options.lang !== 'jsx';
+    for (const { callExp, exp, arg } of scriptSetupRanges.useTemplateRef) {
+        const templateRefType = arg
+            ? [
+                `__VLS_TemplateResult['refs'][`,
+                (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.all),
+                `]`
+            ]
+            : [`unknown`];
+        if (isTs) {
+            setupCodeModifies.push([
+                [
+                    `<`,
+                    ...templateRefType,
+                    `>`
+                ],
+                exp.end,
+                exp.end
+            ]);
+        }
+        else {
+            setupCodeModifies.push([
+                [`(`],
+                callExp.start,
+                callExp.start
+            ], [
+                [
+                    ` as __VLS_UseTemplateRef<`,
+                    ...templateRefType,
+                    `>)`
+                ],
+                callExp.end,
+                callExp.end
+            ]);
+        }
+        if (arg) {
+            setupCodeModifies.push([
+                [`(__VLS_placeholder)`],
+                arg.start,
+                arg.end
+            ]);
+        }
+    }
+    setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
+    let nextStart = Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset);
+    for (const [codes, start, end] of setupCodeModifies) {
+        yield (0, utils_1.generateSfcBlockSection)(scriptSetup, nextStart, start, index_1.codeFeatures.all);
+        for (const code of codes) {
+            yield code;
+        }
+        nextStart = end;
+    }
+    yield (0, utils_1.generateSfcBlockSection)(scriptSetup, nextStart, scriptSetup.content.length, index_1.codeFeatures.all);
+    yield* (0, index_1.generateScriptSectionPartiallyEnding)(scriptSetup.name, scriptSetup.content.length, '#3632/scriptSetup.vue');
+    yield* generateMacros(options, ctx);
+    yield* generateDefineProp(options);
+    if (scriptSetupRanges.defineProps?.typeArg && scriptSetupRanges.withDefaults?.arg) {
+        // fix https://github.com/vuejs/language-tools/issues/1187
+        yield `const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`;
+        yield (0, utils_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.withDefaults.arg.start, scriptSetupRanges.withDefaults.arg.end, index_1.codeFeatures.navigation);
+        yield `)${utils_1.endOfLine}`;
+    }
+    yield* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges);
+    yield* generateModelEmit(scriptSetup, scriptSetupRanges);
+    yield `function __VLS_template() {${utils_1.newLine}`;
+    const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
+    yield `}${utils_1.endOfLine}`;
+    yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
+    yield `type __VLS_TemplateResult = ReturnType<typeof __VLS_template>${utils_1.endOfLine}`;
+    if (syntax) {
+        if (!options.vueCompilerOptions.skipTemplateCodegen && (options.templateCodegen?.hasSlot || scriptSetupRanges.defineSlots)) {
+            yield `const __VLS_component = `;
+            yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
+            yield utils_1.endOfLine;
+            yield `${syntax} `;
+            yield `{} as ${ctx.localTypes.WithTemplateSlots}<typeof __VLS_component, __VLS_TemplateResult['slots']>${utils_1.endOfLine}`;
+        }
+        else {
+            yield `${syntax} `;
+            yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
+            yield utils_1.endOfLine;
+        }
+    }
+}
+function* generateMacros(options, ctx) {
+    if (options.vueCompilerOptions.target >= 3.3) {
+        yield `declare const { `;
+        for (const macro of Object.keys(options.vueCompilerOptions.macros)) {
+            if (!ctx.bindingNames.has(macro)) {
+                yield `${macro}, `;
+            }
+        }
+        yield `}: typeof import('${options.vueCompilerOptions.lib}')${utils_1.endOfLine}`;
+    }
+}
+function* generateDefineProp(options) {
+    const definePropProposalA = options.vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
+    const definePropProposalB = options.vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
+    if (definePropProposalA || definePropProposalB) {
+        yield `type __VLS_PropOptions<T> = Exclude<import('${options.vueCompilerOptions.lib}').Prop<T>, import('${options.vueCompilerOptions.lib}').PropType<T>>${utils_1.endOfLine}`;
+        if (definePropProposalA) {
+            yield `declare function defineProp<T>(name: string, options: ({ required: true } | { default: T }) & __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${utils_1.endOfLine}`;
+            yield `declare function defineProp<T>(name?: string, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${utils_1.endOfLine}`;
+        }
+        if (definePropProposalB) {
+            yield `declare function defineProp<T>(value: T | (() => T), required?: boolean, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${utils_1.endOfLine}`;
+            yield `declare function defineProp<T>(value: T | (() => T) | undefined, required: true, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${utils_1.endOfLine}`;
+            yield `declare function defineProp<T>(value?: T | (() => T), required?: boolean, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${utils_1.endOfLine}`;
+        }
+    }
+}
+function* generateDefineWithType(scriptSetup, statement, callExp, typeArg, name, defaultName, typeName) {
+    if (typeArg) {
+        yield [[
+                `type ${typeName} = `,
+                (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, index_1.codeFeatures.all),
+                utils_1.endOfLine,
+            ], statement.start, statement.start];
+        yield [[typeName], typeArg.start, typeArg.end];
+    }
+    if (!name) {
+        if (statement.start === callExp.start && statement.end === callExp.end) {
+            yield [[`const ${defaultName} = `], callExp.start, callExp.start];
+        }
+        else if (typeArg) {
+            yield [[
+                    `const ${defaultName} = `,
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, typeArg.start, index_1.codeFeatures.all)
+                ], statement.start, typeArg.start];
+            yield [[
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.end, callExp.end, index_1.codeFeatures.all),
+                    utils_1.endOfLine,
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, index_1.codeFeatures.all),
+                    defaultName
+                ], typeArg.end, callExp.end];
+        }
+        else {
+            yield [[
+                    `const ${defaultName} = `,
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, callExp.end, index_1.codeFeatures.all),
+                    utils_1.endOfLine,
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, index_1.codeFeatures.all),
+                    defaultName
+                ], statement.start, callExp.end];
+        }
+    }
+}
+function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges) {
+    if (scriptSetup.generic) {
+        yield `const __VLS_fnComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
+        if (scriptSetupRanges.defineProps?.arg) {
+            yield `props: `;
+            yield (0, utils_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.defineProps.arg.start, scriptSetupRanges.defineProps.arg.end, index_1.codeFeatures.navigation);
+            yield `,${utils_1.newLine}`;
+        }
+        yield* (0, component_1.generateEmitsOption)(options, scriptSetupRanges);
+        yield `})${utils_1.endOfLine}`;
+        yield `type __VLS_BuiltInPublicProps = ${options.vueCompilerOptions.target >= 3.4
+            ? `import('${options.vueCompilerOptions.lib}').PublicProps`
+            : options.vueCompilerOptions.target >= 3.0
+                ? `import('${options.vueCompilerOptions.lib}').VNodeProps`
+                    + ` & import('${options.vueCompilerOptions.lib}').AllowedComponentProps`
+                    + ` & import('${options.vueCompilerOptions.lib}').ComponentCustomProps`
+                : `globalThis.JSX.IntrinsicAttributes`}`;
+        yield utils_1.endOfLine;
+        yield `type __VLS_OwnProps = `;
+        yield `${ctx.localTypes.OmitKeepDiscriminatedUnion}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof __VLS_BuiltInPublicProps>`;
+        yield utils_1.endOfLine;
+    }
+    if (scriptSetupRanges.defineProp.length) {
+        yield `const __VLS_defaults = {${utils_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            if (!defineProp.defaultValue) {
+                continue;
+            }
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
+            if (defineProp.name || defineProp.isModel) {
+                yield `'${propName}'`;
+            }
+            else if (defineProp.localName) {
+                yield localName;
+            }
+            else {
+                continue;
+            }
+            yield `: `;
+            yield getRangeName(scriptSetup, defineProp.defaultValue);
+            yield `,${utils_1.newLine}`;
+        }
+        yield `}${utils_1.endOfLine}`;
+    }
+    yield `type __VLS_PublicProps = `;
+    if (scriptSetupRanges.defineSlots && options.vueCompilerOptions.jsxSlots) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `${ctx.localTypes.PropsChildren}<typeof __VLS_slots>`;
+    }
+    if (scriptSetupRanges.defineProp.length) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `{${utils_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
+            if (defineProp.isModel && !defineProp.name) {
+                yield propName;
+            }
+            else if (defineProp.name) {
+                yield (0, utils_1.generateSfcBlockSection)(scriptSetup, defineProp.name.start, defineProp.name.end, index_1.codeFeatures.navigation);
+            }
+            else if (defineProp.localName) {
+                yield (0, utils_1.generateSfcBlockSection)(scriptSetup, defineProp.localName.start, defineProp.localName.end, index_1.codeFeatures.navigation);
+            }
+            else {
+                continue;
+            }
+            yield defineProp.required
+                ? `: `
+                : `?: `;
+            yield* generateDefinePropType(scriptSetup, propName, localName, defineProp);
+            yield `,${utils_1.newLine}`;
+            if (defineProp.modifierType) {
+                const modifierName = `${defineProp.name ? propName : 'model'}Modifiers`;
+                const modifierType = getRangeName(scriptSetup, defineProp.modifierType);
+                yield `'${modifierName}'?: Partial<Record<${modifierType}, true>>,${utils_1.newLine}`;
+            }
+        }
+        yield `}`;
+    }
+    if (scriptSetupRanges.defineProps?.typeArg) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `__VLS_Props`;
+    }
+    if (!ctx.generatedPropsType) {
+        yield `{}`;
+    }
+    yield utils_1.endOfLine;
+}
+function* generateModelEmit(scriptSetup, scriptSetupRanges) {
+    const defineModels = scriptSetupRanges.defineProp.filter(p => p.isModel);
+    if (defineModels.length) {
+        yield `type __VLS_ModelEmit = {${utils_1.newLine}`;
+        for (const defineModel of defineModels) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
+            yield `'update:${propName}': [value: `;
+            yield* generateDefinePropType(scriptSetup, propName, localName, defineModel);
+            yield `]${utils_1.endOfLine}`;
+        }
+        yield `}${utils_1.endOfLine}`;
+        yield `const __VLS_modelEmit = defineEmits<__VLS_ModelEmit>()${utils_1.endOfLine}`;
+    }
+}
+function* generateDefinePropType(scriptSetup, propName, localName, defineProp) {
+    if (defineProp.type) {
+        // Infer from defineProp<T>
+        yield getRangeName(scriptSetup, defineProp.type);
+    }
+    else if (defineProp.runtimeType && localName) {
+        // Infer from actual prop declaration code 
+        yield `typeof ${localName}['value']`;
+    }
+    else if (defineProp.defaultValue && propName) {
+        // Infer from defineProp({default: T})
+        yield `typeof __VLS_defaults['${propName}']`;
+    }
+    else {
+        yield `any`;
+    }
+}
+function getPropAndLocalName(scriptSetup, defineProp) {
+    const localName = defineProp.localName
+        ? getRangeName(scriptSetup, defineProp.localName)
+        : undefined;
+    let propName = defineProp.name
+        ? getRangeName(scriptSetup, defineProp.name)
+        : defineProp.isModel
+            ? 'modelValue'
+            : localName;
+    if (defineProp.name) {
+        propName = propName.replace(/['"]+/g, '');
+    }
+    return [propName, localName];
+}
+function getRangeName(scriptSetup, range) {
+    return scriptSetup.content.slice(range.start, range.end);
+}
+//# sourceMappingURL=scriptSetup.js.map

node_modules/@vue/language-core/lib/codegen/script/src.d.ts

@@ -0,0 +1,2 @@
+import type { Code, Sfc } from '../../types';
+export declare function generateSrc(script: NonNullable<Sfc['script']>, src: string): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/src.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSrc = generateSrc;
+const utils_1 = require("../utils");
+const index_1 = require("./index");
+function* generateSrc(script, src) {
+    if (src.endsWith('.d.ts')) {
+        src = src.slice(0, -'.d.ts'.length);
+    }
+    else if (src.endsWith('.ts')) {
+        src = src.slice(0, -'.ts'.length);
+    }
+    else if (src.endsWith('.tsx')) {
+        src = src.slice(0, -'.tsx'.length) + '.jsx';
+    }
+    if (!src.endsWith('.js') && !src.endsWith('.jsx')) {
+        src = src + '.js';
+    }
+    yield `export * from `;
+    yield [
+        `'${src}'`,
+        'script',
+        script.srcOffset - 1,
+        {
+            ...index_1.codeFeatures.all,
+            navigation: src === script.src
+                ? true
+                : {
+                    shouldRename: () => false,
+                    resolveRenameEditText(newName) {
+                        if (newName.endsWith('.jsx') || newName.endsWith('.js')) {
+                            newName = newName.split('.').slice(0, -1).join('.');
+                        }
+                        if (script?.src?.endsWith('.d.ts')) {
+                            newName = newName + '.d.ts';
+                        }
+                        else if (script?.src?.endsWith('.ts')) {
+                            newName = newName + '.ts';
+                        }
+                        else if (script?.src?.endsWith('.tsx')) {
+                            newName = newName + '.tsx';
+                        }
+                        return newName;
+                    },
+                },
+        },
+    ];
+    yield utils_1.endOfLine;
+    yield `export { default } from '${src}'${utils_1.endOfLine}`;
+}
+//# sourceMappingURL=src.js.map

node_modules/@vue/language-core/lib/codegen/script/styleModulesType.d.ts

@@ -0,0 +1,4 @@
+import type { Code } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateStyleModulesType(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/styleModulesType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleModulesType = generateStyleModulesType;
+const utils_1 = require("../utils");
+const index_1 = require("./index");
+const template_1 = require("./template");
+function* generateStyleModulesType(options, ctx) {
+    const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
+    if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
+        return;
+    }
+    yield `type __VLS_StyleModules = {${utils_1.newLine}`;
+    for (const [style, i] of styles) {
+        const { name, offset } = style.module;
+        if (offset) {
+            yield [
+                name,
+                'main',
+                offset + 1,
+                index_1.codeFeatures.all
+            ];
+        }
+        else {
+            yield name;
+        }
+        yield `: Record<string, string> & ${ctx.localTypes.PrettifyLocal}<{}`;
+        for (const className of style.classNames) {
+            yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
+        }
+        yield `>${utils_1.endOfLine}`;
+    }
+    yield `}${utils_1.endOfLine}`;
+}
+//# sourceMappingURL=styleModulesType.js.map

node_modules/@vue/language-core/lib/codegen/script/template.d.ts

@@ -0,0 +1,8 @@
+import type { Code } from '../../types';
+import { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import { type ScriptCodegenOptions } from './index';
+export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code, TemplateCodegenContext>;
+export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
+export declare function generateCssClassProperty(styleIndex: number, classNameWithDot: string, offset: number, propertyType: string, optional: boolean): Generator<Code>;
+export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;

node_modules/@vue/language-core/lib/codegen/script/template.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplate = generateTemplate;
+exports.generateTemplateDirectives = generateTemplateDirectives;
+exports.generateCssClassProperty = generateCssClassProperty;
+exports.getTemplateUsageVars = getTemplateUsageVars;
+const path = require("path-browserify");
+const shared_1 = require("../../utils/shared");
+const context_1 = require("../template/context");
+const interpolation_1 = require("../template/interpolation");
+const styleScopedClasses_1 = require("../template/styleScopedClasses");
+const utils_1 = require("../utils");
+const index_1 = require("./index");
+function* generateTemplate(options, ctx) {
+    ctx.generatedTemplate = true;
+    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
+        scriptSetupBindingNames: new Set(),
+        edited: options.edited,
+    });
+    yield* generateTemplateCtx(options);
+    yield* generateTemplateComponents(options);
+    yield* generateTemplateDirectives(options);
+    yield* generateTemplateBody(options, templateCodegenCtx);
+    return templateCodegenCtx;
+}
+function* generateTemplateCtx(options) {
+    const exps = [];
+    exps.push(`{} as InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>`);
+    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileName.endsWith(ext))) {
+        exps.push(`globalThis`);
+    }
+    if (options.sfc.styles.some(style => style.module)) {
+        exps.push(`{} as __VLS_StyleModules`);
+    }
+    yield `const __VLS_ctx = `;
+    if (exps.length === 1) {
+        yield exps[0];
+        yield `${utils_1.endOfLine}`;
+    }
+    else {
+        yield `{${utils_1.newLine}`;
+        for (const exp of exps) {
+            yield `...`;
+            yield exp;
+            yield `,${utils_1.newLine}`;
+        }
+        yield `}${utils_1.endOfLine}`;
+    }
+}
+function* generateTemplateComponents(options) {
+    const types = [];
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
+        const { componentsOption } = options.scriptRanges.exportDefault;
+        yield `const __VLS_componentsOption = `;
+        yield [
+            options.sfc.script.content.slice(componentsOption.start, componentsOption.end),
+            'script',
+            componentsOption.start,
+            index_1.codeFeatures.navigation,
+        ];
+        yield utils_1.endOfLine;
+        types.push(`typeof __VLS_componentsOption`);
+    }
+    let nameType;
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.nameOption) {
+        const { nameOption } = options.scriptRanges.exportDefault;
+        nameType = options.sfc.script.content.slice(nameOption.start, nameOption.end);
+    }
+    else if (options.sfc.scriptSetup) {
+        const baseName = path.basename(options.fileName);
+        nameType = `'${options.scriptSetupRanges?.defineOptions?.name ?? baseName.slice(0, baseName.lastIndexOf('.'))}'`;
+    }
+    if (nameType) {
+        types.push(`{ [K in ${nameType}]: typeof __VLS_self & (new () => { `
+            + (0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)
+            + `: typeof ${options.scriptSetupRanges?.defineSlots?.name ?? `__VLS_slots`} }) }`);
+    }
+    types.push(`typeof __VLS_ctx`);
+    yield `type __VLS_LocalComponents =`;
+    for (const type of types) {
+        yield ` & `;
+        yield type;
+    }
+    yield utils_1.endOfLine;
+    yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
+}
+function* generateTemplateDirectives(options) {
+    const types = [];
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
+        const { directivesOption } = options.scriptRanges.exportDefault;
+        yield `const __VLS_directivesOption = `;
+        yield [
+            options.sfc.script.content.slice(directivesOption.start, directivesOption.end),
+            'script',
+            directivesOption.start,
+            index_1.codeFeatures.navigation,
+        ];
+        yield utils_1.endOfLine;
+        types.push(`typeof __VLS_directivesOption`);
+    }
+    types.push(`typeof __VLS_ctx`);
+    yield `type __VLS_LocalDirectives =`;
+    for (const type of types) {
+        yield ` & `;
+        yield type;
+    }
+    yield utils_1.endOfLine;
+    yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
+}
+function* generateTemplateBody(options, templateCodegenCtx) {
+    yield* generateStyleScopedClasses(options, templateCodegenCtx);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(templateCodegenCtx, true);
+    yield* generateCssVars(options, templateCodegenCtx);
+    if (options.templateCodegen) {
+        for (const code of options.templateCodegen.codes) {
+            yield code;
+        }
+    }
+    else {
+        yield `// no template${utils_1.newLine}`;
+        if (!options.scriptSetupRanges?.defineSlots) {
+            yield `const __VLS_slots = {}${utils_1.endOfLine}`;
+        }
+        yield `const __VLS_inheritedAttrs = {}${utils_1.endOfLine}`;
+        yield `const $refs = {}${utils_1.endOfLine}`;
+        yield `const $el = {} as any${utils_1.endOfLine}`;
+    }
+    yield `return {${utils_1.newLine}`;
+    yield `	attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${utils_1.newLine}`;
+    yield `	slots: ${options.scriptSetupRanges?.defineSlots?.name ?? '__VLS_slots'},${utils_1.newLine}`;
+    yield `	refs: $refs,${utils_1.newLine}`;
+    yield `	rootEl: $el,${utils_1.newLine}`;
+    yield `}${utils_1.endOfLine}`;
+}
+function* generateStyleScopedClasses(options, ctx) {
+    const firstClasses = new Set();
+    yield `type __VLS_StyleScopedClasses = {}`;
+    for (let i = 0; i < options.sfc.styles.length; i++) {
+        const style = options.sfc.styles[i];
+        const option = options.vueCompilerOptions.experimentalResolveStyleCssClasses;
+        if (option === 'always' || (option === 'scoped' && style.scoped)) {
+            for (const className of style.classNames) {
+                if (firstClasses.has(className.text)) {
+                    ctx.scopedClasses.push({
+                        source: 'style_' + i,
+                        className: className.text.slice(1),
+                        offset: className.offset + 1
+                    });
+                    continue;
+                }
+                firstClasses.add(className.text);
+                yield* generateCssClassProperty(i, className.text, className.offset, 'boolean', true);
+            }
+        }
+    }
+    yield utils_1.endOfLine;
+}
+function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propertyType, optional) {
+    yield `${utils_1.newLine} & { `;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset,
+        index_1.codeFeatures.navigation,
+    ];
+    yield `'`;
+    yield [
+        classNameWithDot.slice(1),
+        'style_' + styleIndex,
+        offset + 1,
+        index_1.codeFeatures.navigation,
+    ];
+    yield `'`;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset + classNameWithDot.length,
+        index_1.codeFeatures.navigationWithoutRename,
+    ];
+    yield `${optional ? '?' : ''}: ${propertyType}`;
+    yield ` }`;
+}
+function* generateCssVars(options, ctx) {
+    if (!options.sfc.styles.length) {
+        return;
+    }
+    yield `// CSS variable injection ${utils_1.newLine}`;
+    for (const style of options.sfc.styles) {
+        for (const cssBind of style.cssVars) {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style.name, index_1.codeFeatures.all, cssBind.text, cssBind.offset);
+            yield utils_1.endOfLine;
+        }
+    }
+    yield `// CSS variable injection end ${utils_1.newLine}`;
+}
+function getTemplateUsageVars(options, ctx) {
+    const usageVars = new Set();
+    const components = new Set(options.sfc.template?.ast?.components);
+    if (options.templateCodegen) {
+        // fix import components unused report
+        for (const varName of ctx.bindingNames) {
+            if (components.has(varName) || components.has((0, shared_1.hyphenateTag)(varName))) {
+                usageVars.add(varName);
+            }
+        }
+        for (const component of components) {
+            if (component.includes('.')) {
+                usageVars.add(component.split('.')[0]);
+            }
+        }
+        for (const [varName] of options.templateCodegen.accessExternalVariables) {
+            usageVars.add(varName);
+        }
+    }
+    return usageVars;
+}
+//# sourceMappingURL=template.js.map

node_modules/@vue/language-core/lib/codegen/template/context.d.ts

@@ -0,0 +1,66 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { Code, VueCodeInformation } from '../../types';
+import { InlayHintInfo } from '../inlayHints';
+import type { TemplateCodegenOptions } from './index';
+export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
+export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
+    slots: {
+        name: string;
+        loc?: number;
+        tagRange: [number, number];
+        varName: string;
+        nodeLoc: any;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        varName: string;
+    }[];
+    codeFeatures: {
+        all: VueCodeInformation;
+        verification: VueCodeInformation;
+        completion: VueCodeInformation;
+        additionalCompletion: VueCodeInformation;
+        navigation: VueCodeInformation;
+        navigationWithoutRename: VueCodeInformation;
+        navigationAndCompletion: VueCodeInformation;
+        navigationAndAdditionalCompletion: VueCodeInformation;
+        withoutNavigation: VueCodeInformation;
+        withoutHighlight: VueCodeInformation;
+        withoutHighlightAndCompletion: VueCodeInformation;
+        withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
+    };
+    accessExternalVariables: Map<string, Set<number>>;
+    lastGenericComment: {
+        content: string;
+        offset: number;
+    } | undefined;
+    hasSlotElements: Set<CompilerDOM.ElementNode>;
+    blockConditions: string[];
+    scopedClasses: {
+        source: string;
+        className: string;
+        offset: number;
+    }[];
+    emptyClassOffsets: number[];
+    inlayHints: InlayHintInfo[];
+    hasSlot: boolean;
+    bindingAttrLocs: CompilerDOM.SourceLocation[];
+    inheritedAttrVars: Set<string>;
+    templateRefs: Map<string, [varName: string, offset: number]>;
+    currentComponent: {
+        node: CompilerDOM.ElementNode;
+        ctxVar: string;
+        used: boolean;
+    } | undefined;
+    singleRootElType: string | undefined;
+    singleRootNode: CompilerDOM.ElementNode | undefined;
+    accessExternalVariable(name: string, offset?: number): void;
+    hasLocalVariable: (name: string) => boolean;
+    addLocalVariable: (name: string) => void;
+    removeLocalVariable: (name: string) => void;
+    getInternalVariable: () => string;
+    ignoreError: () => Generator<Code>;
+    expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
+    resetDirectiveComments: (endStr: string) => Generator<Code>;
+    generateAutoImportCompletion: () => Generator<Code>;
+};

node_modules/@vue/language-core/lib/codegen/template/context.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplateCodegenContext = createTemplateCodegenContext;
+const utils_1 = require("../utils");
+const _codeFeatures = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    verification: {
+        verification: true,
+    },
+    completion: {
+        completion: true,
+    },
+    additionalCompletion: {
+        completion: { isAdditional: true },
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename() {
+                return false;
+            },
+        },
+    },
+    navigationAndCompletion: {
+        navigation: true,
+        completion: true,
+    },
+    navigationAndAdditionalCompletion: {
+        navigation: true,
+        completion: { isAdditional: true },
+    },
+    withoutNavigation: {
+        verification: true,
+        completion: true,
+        semantic: true,
+    },
+    withoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
+    withoutHighlightAndCompletion: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+    },
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+    },
+};
+function createTemplateCodegenContext(options) {
+    let ignoredError = false;
+    let expectErrorToken;
+    let lastGenericComment;
+    let variableId = 0;
+    const codeFeatures = new Proxy(_codeFeatures, {
+        get(target, key) {
+            const data = target[key];
+            if (data.verification) {
+                if (ignoredError) {
+                    return {
+                        ...data,
+                        verification: false,
+                    };
+                }
+                if (expectErrorToken) {
+                    const token = expectErrorToken;
+                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
+                        return {
+                            ...data,
+                            verification: {
+                                shouldReport: () => {
+                                    token.errors++;
+                                    return false;
+                                },
+                            },
+                        };
+                    }
+                }
+            }
+            return data;
+        },
+    });
+    const localVars = new Map();
+    const accessExternalVariables = new Map();
+    const slots = [];
+    const dynamicSlots = [];
+    const hasSlotElements = new Set();
+    ;
+    const blockConditions = [];
+    const scopedClasses = [];
+    const emptyClassOffsets = [];
+    const inlayHints = [];
+    const bindingAttrLocs = [];
+    const inheritedAttrVars = new Set();
+    const templateRefs = new Map();
+    return {
+        slots,
+        dynamicSlots,
+        codeFeatures,
+        accessExternalVariables,
+        lastGenericComment,
+        hasSlotElements,
+        blockConditions,
+        scopedClasses,
+        emptyClassOffsets,
+        inlayHints,
+        hasSlot: false,
+        bindingAttrLocs,
+        inheritedAttrVars,
+        templateRefs,
+        currentComponent: undefined,
+        singleRootElType: undefined,
+        singleRootNode: undefined,
+        accessExternalVariable(name, offset) {
+            let arr = accessExternalVariables.get(name);
+            if (!arr) {
+                accessExternalVariables.set(name, arr = new Set());
+            }
+            if (offset !== undefined) {
+                arr.add(offset);
+            }
+        },
+        hasLocalVariable: (name) => {
+            return !!localVars.get(name);
+        },
+        addLocalVariable: (name) => {
+            localVars.set(name, (localVars.get(name) ?? 0) + 1);
+        },
+        removeLocalVariable: (name) => {
+            localVars.set(name, localVars.get(name) - 1);
+        },
+        getInternalVariable: () => {
+            return `__VLS_${variableId++}`;
+        },
+        ignoreError: function* () {
+            if (!ignoredError) {
+                ignoredError = true;
+                yield `// @vue-ignore start${utils_1.newLine}`;
+            }
+        },
+        expectError: function* (prevNode) {
+            if (!expectErrorToken) {
+                expectErrorToken = {
+                    errors: 0,
+                    node: prevNode,
+                };
+                yield `// @vue-expect-error start${utils_1.newLine}`;
+            }
+        },
+        resetDirectiveComments: function* (endStr) {
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                yield* (0, utils_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
+                    verification: {
+                        shouldReport: () => token.errors === 0,
+                    },
+                }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
+                yield `${utils_1.newLine}${utils_1.endOfLine}`;
+                expectErrorToken = undefined;
+                yield `// @vue-expect-error ${endStr}${utils_1.newLine}`;
+            }
+            if (ignoredError) {
+                ignoredError = false;
+                yield `// @vue-ignore ${endStr}${utils_1.newLine}`;
+            }
+        },
+        generateAutoImportCompletion: function* () {
+            if (!options.edited) {
+                return;
+            }
+            const all = [...accessExternalVariables.entries()];
+            if (!all.some(([_, offsets]) => offsets.size)) {
+                return;
+            }
+            yield `// @ts-ignore${utils_1.newLine}`; // #2304
+            yield `[`;
+            for (const [varName, offsets] of all) {
+                for (const offset of offsets) {
+                    if (options.scriptSetupBindingNames.has(varName)) {
+                        // #3409
+                        yield [
+                            varName,
+                            'template',
+                            offset,
+                            {
+                                ...codeFeatures.additionalCompletion,
+                                ...codeFeatures.withoutHighlightAndCompletionAndNavigation,
+                            },
+                        ];
+                    }
+                    else {
+                        yield [
+                            varName,
+                            'template',
+                            offset,
+                            codeFeatures.additionalCompletion,
+                        ];
+                    }
+                    yield `,`;
+                }
+                offsets.clear();
+            }
+            yield `]${utils_1.endOfLine}`;
+        }
+    };
+}
+//# sourceMappingURL=context.js.map

node_modules/@vue/language-core/lib/codegen/template/element.d.ts

@@ -0,0 +1,6 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isVForChild: boolean): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/element.js

@@ -0,0 +1,571 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponent = generateComponent;
+exports.generateElement = generateElement;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const shared_2 = require("../../utils/shared");
+const inlayHints_1 = require("../inlayHints");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const elementChildren_1 = require("./elementChildren");
+const elementDirectives_1 = require("./elementDirectives");
+const elementEvents_1 = require("./elementEvents");
+const elementProps_1 = require("./elementProps");
+const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+const propertyAccess_1 = require("./propertyAccess");
+const templateChild_1 = require("./templateChild");
+const colonReg = /:/g;
+function* generateComponent(options, ctx, node) {
+    const tagOffsets = [node.loc.start.offset + options.template.content.slice(node.loc.start.offset).indexOf(node.tag)];
+    if (!node.isSelfClosing && options.template.lang === 'html') {
+        const endTagOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
+        if (endTagOffset > tagOffsets[0]) {
+            tagOffsets.push(endTagOffset);
+        }
+    }
+    const failedPropExps = [];
+    const possibleOriginalNames = getPossibleOriginalComponentNames(node.tag, true);
+    const matchImportName = possibleOriginalNames.find(name => options.scriptSetupImportComponentNames.has(name));
+    const var_originalComponent = matchImportName ?? ctx.getInternalVariable();
+    const var_functionalComponent = ctx.getInternalVariable();
+    const var_componentInstance = ctx.getInternalVariable();
+    const var_componentEmit = ctx.getInternalVariable();
+    const var_componentEvents = ctx.getInternalVariable();
+    const var_defineComponentCtx = ctx.getInternalVariable();
+    const isComponentTag = node.tag.toLowerCase() === 'component';
+    ctx.currentComponent = {
+        node,
+        ctxVar: var_defineComponentCtx,
+        used: false
+    };
+    let props = node.props;
+    let dynamicTagInfo;
+    if (isComponentTag) {
+        for (const prop of node.props) {
+            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+                && prop.name === 'bind'
+                && prop.arg?.loc.source === 'is'
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                if (prop.arg.loc.end.offset === prop.exp.loc.end.offset) {
+                    ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.exp.loc, 'is'));
+                }
+                dynamicTagInfo = {
+                    tag: prop.exp.content,
+                    offsets: [prop.exp.loc.start.offset],
+                    astHolder: prop.exp.loc,
+                };
+                props = props.filter(p => p !== prop);
+                break;
+            }
+        }
+    }
+    else if (node.tag.includes('.')) {
+        // namespace tag
+        dynamicTagInfo = {
+            tag: node.tag,
+            offsets: tagOffsets,
+            astHolder: node.loc,
+        };
+    }
+    if (matchImportName) {
+        // hover, renaming / find references support
+        yield `// @ts-ignore${utils_1.newLine}`; // #2304
+        yield `/** @type { [`;
+        for (const tagOffset of tagOffsets) {
+            yield `typeof `;
+            if (var_originalComponent === node.tag) {
+                yield [
+                    var_originalComponent,
+                    'template',
+                    tagOffset,
+                    ctx.codeFeatures.withoutHighlightAndCompletion,
+                ];
+            }
+            else {
+                const shouldCapitalize = matchImportName[0].toUpperCase() === matchImportName[0];
+                yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(node.tag) : node.tag, tagOffset, {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    navigation: {
+                        resolveRenameNewName: camelizeComponentName,
+                        resolveRenameEditText: getTagRenameApply(node.tag),
+                    },
+                });
+            }
+            yield `, `;
+        }
+        yield `] } */${utils_1.endOfLine}`;
+    }
+    else if (dynamicTagInfo) {
+        yield `const ${var_originalComponent} = (`;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, dynamicTagInfo.tag, dynamicTagInfo.offsets[0], dynamicTagInfo.astHolder, '(', ')');
+        if (dynamicTagInfo.offsets[1] !== undefined) {
+            yield `,`;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', {
+                ...ctx.codeFeatures.all,
+                completion: false,
+            }, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], dynamicTagInfo.astHolder, '(', ')');
+        }
+        yield `)${utils_1.endOfLine}`;
+    }
+    else if (!isComponentTag) {
+        yield `const ${var_originalComponent} = ({} as __VLS_WithComponent<'${getCanonicalComponentName(node.tag)}', __VLS_LocalComponents, `;
+        yield getPossibleOriginalComponentNames(node.tag, false)
+            .map(name => `'${name}'`)
+            .join(`, `);
+        yield `>).`;
+        yield* generateCanonicalComponentName(node.tag, tagOffsets[0], ctx.codeFeatures.withoutHighlightAndCompletionAndNavigation);
+        yield `${utils_1.endOfLine}`;
+        const camelizedTag = (0, shared_1.camelize)(node.tag);
+        if (utils_1.variableNameRegex.test(camelizedTag)) {
+            // renaming / find references support
+            yield `/** @type { [`;
+            for (const tagOffset of tagOffsets) {
+                for (const shouldCapitalize of (node.tag[0] === node.tag[0].toUpperCase() ? [false] : [true, false])) {
+                    const expectName = shouldCapitalize ? (0, shared_1.capitalize)(camelizedTag) : camelizedTag;
+                    yield `typeof __VLS_components.`;
+                    yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(node.tag) : node.tag, tagOffset, {
+                        navigation: {
+                            resolveRenameNewName: node.tag !== expectName ? camelizeComponentName : undefined,
+                            resolveRenameEditText: getTagRenameApply(node.tag),
+                        },
+                    });
+                    yield `, `;
+                }
+            }
+            yield `] } */${utils_1.endOfLine}`;
+            // auto import support
+            if (options.edited) {
+                yield `// @ts-ignore${utils_1.newLine}`; // #2304
+                yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(node.tag), tagOffsets[0], {
+                    completion: {
+                        isAdditional: true,
+                        onlyImport: true,
+                    },
+                });
+                yield `${utils_1.endOfLine}`;
+            }
+        }
+    }
+    else {
+        yield `const ${var_originalComponent} = {} as any${utils_1.endOfLine}`;
+    }
+    yield `// @ts-ignore${utils_1.newLine}`;
+    yield `const ${var_functionalComponent} = __VLS_asFunctionalComponent(${var_originalComponent}, new ${var_originalComponent}({${utils_1.newLine}`;
+    yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.strictTemplates, false);
+    yield `}))${utils_1.endOfLine}`;
+    yield `const `;
+    yield* (0, utils_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, {
+        verification: {
+            shouldReport(_source, code) {
+                return String(code) !== '6133';
+            },
+        }
+    }, var_componentInstance);
+    yield ` = ${var_functionalComponent}`;
+    yield* generateComponentGeneric(ctx);
+    yield `(`;
+    yield* (0, utils_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.strictTemplates, true, failedPropExps), `}`);
+    yield `, ...__VLS_functionalComponentArgsRest(${var_functionalComponent}))${utils_1.endOfLine}`;
+    yield* generateFailedPropExps(options, ctx, failedPropExps);
+    const [refName, offset] = yield* generateVScope(options, ctx, node, props);
+    const isRootNode = node === ctx.singleRootNode;
+    if (refName || isRootNode) {
+        const varName = ctx.getInternalVariable();
+        ctx.currentComponent.used = true;
+        yield `var ${varName} = {} as (Parameters<NonNullable<typeof ${var_defineComponentCtx}['expose']>>[0] | null)`;
+        if (node.codegenNode?.type === CompilerDOM.NodeTypes.VNODE_CALL
+            && node.codegenNode.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION
+            && node.codegenNode.props.properties.some(({ key }) => key.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && key.content === 'ref_for')) {
+            yield `[]`;
+        }
+        yield `${utils_1.endOfLine}`;
+        if (refName) {
+            ctx.templateRefs.set(refName, [varName, offset]);
+        }
+        if (isRootNode) {
+            ctx.singleRootElType = `NonNullable<typeof ${varName}>['$el']`;
+        }
+    }
+    const usedComponentEventsVar = yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, var_functionalComponent, var_componentInstance, var_componentEvents);
+    if (usedComponentEventsVar) {
+        ctx.currentComponent.used = true;
+        yield `let ${var_componentEmit}!: typeof ${var_defineComponentCtx}.emit${utils_1.endOfLine}`;
+        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${utils_1.endOfLine}`;
+    }
+    if (options.vueCompilerOptions.fallthroughAttributes
+        && (node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.exp?.loc.source === '$attrs')
+            || node === ctx.singleRootNode)) {
+        const varAttrs = ctx.getInternalVariable();
+        ctx.inheritedAttrVars.add(varAttrs);
+        yield `var ${varAttrs}!: Parameters<typeof ${var_functionalComponent}>[0];\n`;
+    }
+    const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+    if (slotDir) {
+        yield* generateComponentSlot(options, ctx, node, slotDir);
+    }
+    else {
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
+    }
+    if (ctx.currentComponent.used) {
+        yield `var ${var_defineComponentCtx}!: __VLS_PickFunctionalComponentCtx<typeof ${var_originalComponent}, typeof ${var_componentInstance}>${utils_1.endOfLine}`;
+    }
+}
+function* generateElement(options, ctx, node, isVForChild) {
+    const startTagOffset = node.loc.start.offset + options.template.content.slice(node.loc.start.offset).indexOf(node.tag);
+    const endTagOffset = !node.isSelfClosing && options.template.lang === 'html'
+        ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
+        : undefined;
+    const failedPropExps = [];
+    yield `__VLS_elementAsFunction(__VLS_intrinsicElements`;
+    yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+    if (endTagOffset !== undefined) {
+        yield `, __VLS_intrinsicElements`;
+        yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+    }
+    yield `)(`;
+    yield* (0, utils_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.strictTemplates, true, failedPropExps), `}`);
+    yield `)${utils_1.endOfLine}`;
+    yield* generateFailedPropExps(options, ctx, failedPropExps);
+    const [refName, offset] = yield* generateVScope(options, ctx, node, node.props);
+    if (refName) {
+        let refValue = `__VLS_nativeElements['${node.tag}']`;
+        if (isVForChild) {
+            refValue = `[${refValue}]`;
+        }
+        ctx.templateRefs.set(refName, [refValue, offset]);
+    }
+    if (ctx.singleRootNode === node) {
+        ctx.singleRootElType = `typeof __VLS_nativeElements['${node.tag}']`;
+    }
+    const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+    if (slotDir && ctx.currentComponent) {
+        yield* generateComponentSlot(options, ctx, node, slotDir);
+    }
+    else {
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
+    }
+    if (options.vueCompilerOptions.fallthroughAttributes
+        && (node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.exp?.loc.source === '$attrs')
+            || node === ctx.singleRootNode)) {
+        ctx.inheritedAttrVars.add(`__VLS_intrinsicElements.${node.tag}`);
+    }
+}
+function* generateFailedPropExps(options, ctx, failedPropExps) {
+    for (const failedExp of failedPropExps) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, failedExp.node.loc.source, failedExp.node.loc.start.offset, failedExp.node.loc, failedExp.prefix, failedExp.suffix);
+        yield utils_1.endOfLine;
+    }
+}
+function* generateVScope(options, ctx, node, props) {
+    const vScope = props.find(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && (prop.name === 'scope' || prop.name === 'data'));
+    let inScope = false;
+    let originalConditionsNum = ctx.blockConditions.length;
+    if (vScope?.type === CompilerDOM.NodeTypes.DIRECTIVE && vScope.exp) {
+        const scopeVar = ctx.getInternalVariable();
+        const condition = `__VLS_withScope(__VLS_ctx, ${scopeVar})`;
+        yield `const ${scopeVar} = `;
+        yield [
+            vScope.exp.loc.source,
+            'template',
+            vScope.exp.loc.start.offset,
+            ctx.codeFeatures.all,
+        ];
+        yield utils_1.endOfLine;
+        yield `if (${condition}) {${utils_1.newLine}`;
+        ctx.blockConditions.push(condition);
+        inScope = true;
+    }
+    yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
+    const [refName, offset] = yield* generateReferencesForElements(options, ctx, node); // <el ref="foo" />
+    yield* generateReferencesForScopedCssClasses(options, ctx, node);
+    if (inScope) {
+        yield `}${utils_1.newLine}`;
+        ctx.blockConditions.length = originalConditionsNum;
+    }
+    return [refName, offset];
+}
+function getCanonicalComponentName(tagText) {
+    return utils_1.variableNameRegex.test(tagText)
+        ? tagText
+        : (0, shared_1.capitalize)((0, shared_1.camelize)(tagText.replace(colonReg, '-')));
+}
+function getPossibleOriginalComponentNames(tagText, deduplicate) {
+    const name1 = (0, shared_1.capitalize)((0, shared_1.camelize)(tagText));
+    const name2 = (0, shared_1.camelize)(tagText);
+    const name3 = tagText;
+    const names = [name1];
+    if (!deduplicate || name2 !== name1) {
+        names.push(name2);
+    }
+    if (!deduplicate || name3 !== name2) {
+        names.push(name3);
+    }
+    return names;
+}
+function* generateCanonicalComponentName(tagText, offset, features) {
+    if (utils_1.variableNameRegex.test(tagText)) {
+        yield [tagText, 'template', offset, features];
+    }
+    else {
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tagText.replace(colonReg, '-')), offset, features);
+    }
+}
+function* generateComponentGeneric(ctx) {
+    if (ctx.lastGenericComment) {
+        const { content, offset } = ctx.lastGenericComment;
+        yield* (0, utils_1.wrapWith)(offset, offset + content.length, ctx.codeFeatures.verification, `<`, [
+            content,
+            'template',
+            offset,
+            ctx.codeFeatures.all
+        ], `>`);
+    }
+    ctx.lastGenericComment = undefined;
+}
+function* generateComponentSlot(options, ctx, node, slotDir) {
+    yield `{${utils_1.newLine}`;
+    if (ctx.currentComponent) {
+        ctx.currentComponent.used = true;
+        ctx.hasSlotElements.add(ctx.currentComponent.node);
+    }
+    const slotBlockVars = [];
+    yield `const {`;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+    }
+    else {
+        yield* (0, utils_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+    }
+    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
+    if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
+        (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
+        if (!slotDir.exp.content.includes(':')) {
+            yield `const [`;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${utils_1.endOfLine}`;
+        }
+        else {
+            yield `const `;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_1.endOfLine}`;
+        }
+    }
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    yield* ctx.resetDirectiveComments('end of slot children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
+        prev = childNode;
+    }
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    let isStatic = true;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        isStatic = slotDir.arg.isStatic;
+    }
+    if (isStatic && slotDir && !slotDir.arg) {
+        yield `${ctx.currentComponent.ctxVar}.slots!['`;
+        yield [
+            '',
+            'template',
+            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                ? '#'.length : slotDir.loc.source.startsWith('v-slot:')
+                ? 'v-slot:'.length
+                : 0),
+            ctx.codeFeatures.completion,
+        ];
+        yield `'/* empty slot name completion */]${utils_1.newLine}`;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${utils_1.newLine}`;
+}
+function* generateReferencesForElements(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'ref'
+            && prop.value) {
+            const [content, startOffset] = normalizeAttributeValue(prop.value);
+            yield `// @ts-ignore navigation for \`const ${content} = ref()\`${utils_1.newLine}`;
+            yield `/** @type { typeof __VLS_ctx`;
+            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, ctx.codeFeatures.navigation, prop.value.loc);
+            yield ` } */${utils_1.endOfLine}`;
+            if (utils_1.variableNameRegex.test(content) && !options.templateRefNames.has(content)) {
+                ctx.accessExternalVariable(content, startOffset);
+            }
+            return [content, startOffset];
+        }
+    }
+    return [];
+}
+function* generateReferencesForScopedCssClasses(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'class'
+            && prop.value) {
+            if (options.template.lang === 'pug') {
+                const getClassOffset = Reflect.get(prop.value.loc.start, 'getClassOffset');
+                const content = prop.value.loc.source.slice(1, -1);
+                let startOffset = 1;
+                for (const className of content.split(' ')) {
+                    if (className) {
+                        ctx.scopedClasses.push({
+                            source: 'template',
+                            className,
+                            offset: getClassOffset(startOffset),
+                        });
+                    }
+                    startOffset += className.length + 1;
+                }
+            }
+            else {
+                let isWrapped = false;
+                const [content, startOffset] = normalizeAttributeValue(prop.value);
+                if (content) {
+                    const classes = collectClasses(content, startOffset + (isWrapped ? 1 : 0));
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(startOffset);
+                }
+            }
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.arg.content === 'class') {
+            const content = '`${' + prop.exp.content + '}`';
+            const startOffset = prop.exp.loc.start.offset - 3;
+            const { ts } = options;
+            const ast = ts.createSourceFile('', content, 99);
+            const literals = [];
+            ts.forEachChild(ast, node => {
+                if (!ts.isExpressionStatement(node) ||
+                    !isTemplateExpression(node.expression)) {
+                    return;
+                }
+                const expression = node.expression.templateSpans[0].expression;
+                if (ts.isStringLiteralLike(expression)) {
+                    literals.push(expression);
+                }
+                if (ts.isArrayLiteralExpression(expression)) {
+                    walkArrayLiteral(expression);
+                }
+                if (ts.isObjectLiteralExpression(expression)) {
+                    walkObjectLiteral(expression);
+                }
+            });
+            for (const literal of literals) {
+                if (literal.text) {
+                    const classes = collectClasses(literal.text, literal.end - literal.text.length - 1 + startOffset);
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(literal.end - 1 + startOffset);
+                }
+            }
+            function walkArrayLiteral(node) {
+                const { elements } = node;
+                for (const element of elements) {
+                    if (ts.isStringLiteralLike(element)) {
+                        literals.push(element);
+                    }
+                    else if (ts.isObjectLiteralExpression(element)) {
+                        walkObjectLiteral(element);
+                    }
+                }
+            }
+            function walkObjectLiteral(node) {
+                const { properties } = node;
+                for (const property of properties) {
+                    if (ts.isPropertyAssignment(property)) {
+                        const { name } = property;
+                        if (ts.isIdentifier(name)) {
+                            walkIdentifier(name);
+                        }
+                        else if (ts.isStringLiteral(name)) {
+                            literals.push(name);
+                        }
+                        else if (ts.isComputedPropertyName(name)) {
+                            const { expression } = name;
+                            if (ts.isStringLiteralLike(expression)) {
+                                literals.push(expression);
+                            }
+                        }
+                    }
+                    else if (ts.isShorthandPropertyAssignment(property)) {
+                        walkIdentifier(property.name);
+                    }
+                }
+            }
+            function walkIdentifier(node) {
+                const text = (0, scriptSetupRanges_1.getNodeText)(ts, node, ast);
+                ctx.scopedClasses.push({
+                    source: 'template',
+                    className: text,
+                    offset: node.end - text.length + startOffset
+                });
+            }
+        }
+    }
+}
+function camelizeComponentName(newName) {
+    return (0, shared_1.camelize)('-' + newName);
+}
+function getTagRenameApply(oldName) {
+    return oldName === (0, shared_2.hyphenateTag)(oldName) ? shared_2.hyphenateTag : undefined;
+}
+function normalizeAttributeValue(node) {
+    let offset = node.loc.start.offset;
+    let content = node.loc.source;
+    if ((content.startsWith(`'`) && content.endsWith(`'`))
+        || (content.startsWith(`"`) && content.endsWith(`"`))) {
+        offset++;
+        content = content.slice(1, -1);
+    }
+    return [content, offset];
+}
+function collectClasses(content, startOffset = 0) {
+    const classes = [];
+    let currentClassName = '';
+    let offset = 0;
+    for (const char of (content + ' ')) {
+        if (char.trim() === '') {
+            if (currentClassName !== '') {
+                classes.push({
+                    source: 'template',
+                    className: currentClassName,
+                    offset: offset + startOffset
+                });
+                offset += currentClassName.length;
+                currentClassName = '';
+            }
+            offset += char.length;
+        }
+        else {
+            currentClassName += char;
+        }
+    }
+    return classes;
+}
+// isTemplateExpression is missing in tsc
+function isTemplateExpression(node) {
+    return node.kind === 228;
+}
+//# sourceMappingURL=element.js.map

node_modules/@vue/language-core/lib/codegen/template/elementChildren.d.ts

@@ -0,0 +1,5 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementChildren(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/elementChildren.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementChildren = generateElementChildren;
+const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+const templateChild_1 = require("./templateChild");
+function* generateElementChildren(options, ctx, node) {
+    yield* ctx.resetDirectiveComments('end of element children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
+        prev = childNode;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    // fix https://github.com/vuejs/language-tools/issues/932
+    if (ctx.currentComponent
+        && !ctx.hasSlotElements.has(node)
+        && node.children.length
+        && node.tagType !== CompilerDOM.ElementTypes.ELEMENT
+        && node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
+        ctx.currentComponent.used = true;
+        yield `${ctx.currentComponent.ctxVar}.slots!.`;
+        yield* (0, utils_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        yield utils_1.endOfLine;
+    }
+}
+//# sourceMappingURL=elementChildren.js.map

node_modules/@vue/language-core/lib/codegen/template/elementDirectives.d.ts

@@ -0,0 +1,6 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementDirectives(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateModifiers(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, propertyName?: string): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/elementDirectives.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementDirectives = generateElementDirectives;
+exports.generateModifiers = generateModifiers;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const shared_2 = require("../../utils/shared");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
+const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+function* generateElementDirectives(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
+            || prop.name === 'slot'
+            || prop.name === 'on'
+            || prop.name === 'model'
+            || prop.name === 'bind'
+            || prop.name === 'scope'
+            || prop.name === 'data') {
+            continue;
+        }
+        ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
+        yield* (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(ctx, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), ` }, null!, null!)`);
+        yield utils_1.endOfLine;
+    }
+}
+function* generateIdentifier(ctx, prop) {
+    const rawName = 'v-' + prop.name;
+    yield* (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, ctx.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, prop.loc.start.offset, {
+        ...ctx.codeFeatures.all,
+        verification: false,
+        completion: {
+            // fix https://github.com/vuejs/language-tools/issues/1905
+            isAdditional: true,
+        },
+        navigation: {
+            resolveRenameNewName: shared_1.camelize,
+            resolveRenameEditText: getPropRenameApply(prop.name),
+        },
+    }));
+}
+function* generateArg(options, ctx, prop) {
+    const { arg } = prop;
+    if (arg?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        return;
+    }
+    const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
+    yield* (0, utils_1.wrapWith)(startOffset, startOffset + arg.content.length, ctx.codeFeatures.verification, `arg`);
+    yield `: `;
+    if (arg.isStatic) {
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.all);
+    }
+    else {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, arg.content, startOffset, arg.loc, `(`, `)`);
+    }
+    yield `, `;
+}
+function* generateModifiers(options, ctx, prop, propertyName = 'modifiers') {
+    const { modifiers } = prop;
+    if (!modifiers.length) {
+        return;
+    }
+    const startOffset = modifiers[0].loc.start.offset - 1;
+    const endOffset = modifiers.at(-1).loc.end.offset;
+    yield* (0, utils_1.wrapWith)(startOffset, endOffset, ctx.codeFeatures.verification, propertyName);
+    yield `: { `;
+    for (const mod of modifiers) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, ctx.codeFeatures.withoutNavigation);
+        yield `: true, `;
+    }
+    yield `}, `;
+}
+function* generateValue(options, ctx, prop) {
+    const { exp } = prop;
+    if (exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        return;
+    }
+    yield* (0, utils_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `value`);
+    yield `: `;
+    yield* (0, utils_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, exp.content, exp.loc.start.offset, exp.loc, `(`, `)`));
+}
+function getPropRenameApply(oldName) {
+    return oldName === (0, shared_2.hyphenateAttr)(oldName) ? shared_2.hyphenateAttr : undefined;
+}
+//# sourceMappingURL=elementDirectives.js.map

node_modules/@vue/language-core/lib/codegen/template/elementEvents.d.ts

@@ -0,0 +1,9 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentVar: string, componentInstanceVar: string, eventsVar: string): Generator<Code, boolean>;
+export declare function generateEventArg(ctx: TemplateCodegenContext, name: string, start: number, directive?: string): Generator<Code>;
+export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
+export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

node_modules/@vue/language-core/lib/codegen/template/elementEvents.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementEvents = generateElementEvents;
+exports.generateEventArg = generateEventArg;
+exports.generateEventExpression = generateEventExpression;
+exports.isCompoundExpression = isCompoundExpression;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const interpolation_1 = require("./interpolation");
+function* generateElementEvents(options, ctx, node, componentVar, componentInstanceVar, eventsVar) {
+    let usedComponentEventsVar = false;
+    let propsVar;
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && !prop.arg.loc.source.startsWith('[')
+            && !prop.arg.loc.source.endsWith(']')) {
+            usedComponentEventsVar = true;
+            if (!propsVar) {
+                propsVar = ctx.getInternalVariable();
+                yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>${utils_1.endOfLine}`;
+            }
+            let source = prop.arg.loc.source;
+            let start = prop.arg.loc.start.offset;
+            let propPrefix = 'on';
+            let emitPrefix = '';
+            if (source.startsWith('vue:')) {
+                source = source.slice('vue:'.length);
+                start = start + 'vue:'.length;
+                propPrefix = 'onVnode';
+                emitPrefix = 'vnode-';
+            }
+            yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${eventsVar}, '${(0, shared_1.camelize)(propPrefix + '-' + source)}', '${emitPrefix}${source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> = {${utils_1.newLine}`;
+            yield* generateEventArg(ctx, source, start, propPrefix);
+            yield `: `;
+            yield* generateEventExpression(options, ctx, prop);
+            yield `}${utils_1.endOfLine}`;
+        }
+    }
+    return usedComponentEventsVar;
+}
+function* generateEventArg(ctx, name, start, directive = 'on') {
+    const features = {
+        ...ctx.codeFeatures.withoutHighlightAndCompletion,
+        ...ctx.codeFeatures.navigationWithoutRename,
+    };
+    if (utils_1.variableNameRegex.test((0, shared_1.camelize)(name))) {
+        yield ['', 'template', start, features];
+        yield directive;
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), start, utils_1.combineLastMapping);
+    }
+    else {
+        yield* (0, utils_1.wrapWith)(start, start + name.length, features, `'`, ['', 'template', start, utils_1.combineLastMapping], directive, ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), start, utils_1.combineLastMapping), `'`);
+    }
+}
+function* generateEventExpression(options, ctx, prop) {
+    if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        let prefix = '(';
+        let suffix = ')';
+        let isFirstMapping = true;
+        const ast = (0, utils_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
+        const _isCompoundExpression = isCompoundExpression(options.ts, ast);
+        if (_isCompoundExpression) {
+            yield `(...[$event]) => {${utils_1.newLine}`;
+            ctx.addLocalVariable('$event');
+            prefix = '';
+            suffix = '';
+            for (const blockCondition of ctx.blockConditions) {
+                prefix += `if (!(${blockCondition})) return${utils_1.endOfLine}`;
+            }
+        }
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', offset => {
+            if (_isCompoundExpression && isFirstMapping) {
+                isFirstMapping = false;
+                ctx.inlayHints.push({
+                    blockName: 'template',
+                    offset,
+                    setting: 'vue.inlayHints.inlineHandlerLeading',
+                    label: '$event =>',
+                    paddingRight: true,
+                    tooltip: [
+                        '`$event` is a hidden parameter, you can use it in this callback.',
+                        'To hide this hint, set `vue.inlayHints.inlineHandlerLeading` to `false` in IDE settings.',
+                        '[More info](https://github.com/vuejs/language-tools/issues/2445#issuecomment-1444771420)',
+                    ].join('\n\n'),
+                });
+            }
+            return ctx.codeFeatures.all;
+        }, prop.exp.content, prop.exp.loc.start.offset, prop.exp.loc, prefix, suffix);
+        if (_isCompoundExpression) {
+            ctx.removeLocalVariable('$event');
+            yield utils_1.endOfLine;
+            yield* ctx.generateAutoImportCompletion();
+            yield `}`;
+        }
+    }
+    else {
+        yield `() => {}`;
+    }
+}
+function isCompoundExpression(ts, ast) {
+    let result = true;
+    if (ast.statements.length === 0) {
+        result = false;
+    }
+    else if (ast.statements.length === 1) {
+        ts.forEachChild(ast, child_1 => {
+            if (ts.isExpressionStatement(child_1)) {
+                ts.forEachChild(child_1, child_2 => {
+                    if (ts.isArrowFunction(child_2)) {
+                        result = false;
+                    }
+                    else if (isPropertyAccessOrId(ts, child_2)) {
+                        result = false;
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(child_1)) {
+                result = false;
+            }
+        });
+    }
+    return result;
+}
+function isPropertyAccessOrId(ts, node) {
+    if (ts.isIdentifier(node)) {
+        return true;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return isPropertyAccessOrId(ts, node.expression);
+    }
+    return false;
+}
+//# sourceMappingURL=elementEvents.js.map

node_modules/@vue/language-core/lib/codegen/template/elementProps.d.ts

@@ -0,0 +1,10 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export interface FailedPropExpression {
+    node: CompilerDOM.SimpleExpressionNode;
+    prefix: string;
+    suffix: string;
+}
+export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], strictPropsCheck: boolean, enableCodeFeatures: boolean, failedPropExps?: FailedPropExpression[]): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/elementProps.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementProps = generateElementProps;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const minimatch_1 = require("minimatch");
+const muggle_string_1 = require("muggle-string");
+const shared_2 = require("../../utils/shared");
+const inlayHints_1 = require("../inlayHints");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const unicode_1 = require("../utils/unicode");
+const elementDirectives_1 = require("./elementDirectives");
+const elementEvents_1 = require("./elementEvents");
+const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+function* generateElementProps(options, ctx, node, props, strictPropsCheck, enableCodeFeatures, failedPropExps) {
+    const isComponent = node.tagType === CompilerDOM.ElementTypes.COMPONENT;
+    for (const prop of props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on') {
+            if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && !prop.arg.loc.source.startsWith('[')
+                && !prop.arg.loc.source.endsWith(']')) {
+                if (!isComponent) {
+                    yield `...{ `;
+                    yield* (0, elementEvents_1.generateEventArg)(ctx, prop.arg.loc.source, prop.arg.loc.start.offset);
+                    yield `: `;
+                    yield* (0, elementEvents_1.generateEventExpression)(options, ctx, prop);
+                    yield `},`;
+                }
+                else {
+                    yield `...{ '${(0, shared_1.camelize)('on-' + prop.arg.loc.source)}': {} as any },`;
+                }
+                yield utils_1.newLine;
+            }
+            else if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && prop.arg.loc.source.startsWith('[')
+                && prop.arg.loc.source.endsWith(']')) {
+                failedPropExps?.push({ node: prop.arg, prefix: '(', suffix: ')' });
+                failedPropExps?.push({ node: prop.exp, prefix: '() => {', suffix: '}' });
+            }
+            else if (!prop.arg
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                failedPropExps?.push({ node: prop.exp, prefix: '(', suffix: ')' });
+            }
+        }
+    }
+    for (const prop of props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && ((prop.name === 'bind' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)
+                || prop.name === 'model')
+            && (!prop.exp || prop.exp.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)) {
+            let propName;
+            if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                propName = prop.arg.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY
+                    ? prop.arg.content
+                    : prop.arg.loc.source;
+            }
+            else {
+                propName = getModelPropName(node, options.vueCompilerOptions);
+            }
+            if (propName === undefined
+                || options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern))) {
+                if (prop.exp && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
+                    failedPropExps?.push({ node: prop.exp, prefix: '(', suffix: ')' });
+                }
+                continue;
+            }
+            if (prop.name === 'bind'
+                && prop.modifiers.some(m => m.content === 'prop' || m.content === 'attr')) {
+                propName = propName.slice(1);
+            }
+            const shouldSpread = propName === 'style' || propName === 'class';
+            const shouldCamelize = isComponent && getShouldCamelize(options, prop, propName);
+            const codeInfo = getPropsCodeInfo(ctx, strictPropsCheck, shouldCamelize);
+            if (shouldSpread) {
+                yield `...{ `;
+            }
+            const codes = (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(prop.arg
+                ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, prop.loc.name_2 ??= {}, shouldCamelize)
+                : (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.verification, propName)), `: (`, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
+            if (enableCodeFeatures) {
+                yield* codes;
+            }
+            else {
+                yield (0, muggle_string_1.toString)([...codes]);
+            }
+            if (shouldSpread) {
+                yield ` }`;
+            }
+            yield `,${utils_1.newLine}`;
+            if (prop.name === 'model' && prop.modifiers.length) {
+                const propertyName = prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                    ? !prop.arg.isStatic
+                        ? `[__VLS_tryAsConstant(\`$\{${prop.arg.content}\}Modifiers\`)]`
+                        : (0, shared_1.camelize)(propName) + `Modifiers`
+                    : `modelModifiers`;
+                const codes = (0, elementDirectives_1.generateModifiers)(options, ctx, prop, propertyName);
+                if (enableCodeFeatures) {
+                    yield* codes;
+                }
+                else {
+                    yield (0, muggle_string_1.toString)([...codes]);
+                }
+                yield utils_1.newLine;
+            }
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            if (options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern))
+                // Vue 2 Transition doesn't support "persisted" property but `@vue/compiler-dom` always adds it (#3881)
+                || (options.vueCompilerOptions.target < 3
+                    && prop.name === 'persisted'
+                    && node.tag.toLowerCase() === 'transition')) {
+                continue;
+            }
+            const shouldSpread = prop.name === 'style' || prop.name === 'class';
+            const shouldCamelize = isComponent && getShouldCamelize(options, prop, prop.name);
+            const codeInfo = getPropsCodeInfo(ctx, strictPropsCheck, true);
+            if (shouldSpread) {
+                yield `...{ `;
+            }
+            const codes = (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, prop.loc.name_1 ??= {}, shouldCamelize), `: (`, ...(prop.value
+                ? generateAttrValue(prop.value, ctx.codeFeatures.withoutNavigation)
+                : [`true`]), `)`);
+            if (enableCodeFeatures) {
+                yield* codes;
+            }
+            else {
+                yield (0, muggle_string_1.toString)([...codes]);
+            }
+            if (shouldSpread) {
+                yield ` }`;
+            }
+            yield `,${utils_1.newLine}`;
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && !prop.arg
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            if (prop.exp.loc.source === '$attrs') {
+                if (enableCodeFeatures) {
+                    ctx.bindingAttrLocs.push(prop.exp.loc);
+                }
+            }
+            else {
+                const codes = (0, utils_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, false, enableCodeFeatures));
+                if (enableCodeFeatures) {
+                    yield* codes;
+                }
+                else {
+                    yield (0, muggle_string_1.toString)([...codes]);
+                }
+                yield `,${utils_1.newLine}`;
+            }
+        }
+    }
+}
+function* generatePropExp(options, ctx, prop, exp, features, isShorthand, enableCodeFeatures) {
+    if (isShorthand && features.completion) {
+        features = {
+            ...features,
+            completion: undefined,
+        };
+    }
+    if (exp && exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) { // style='z-index: 2' will compile to {'z-index':'2'}
+        if (!isShorthand) { // vue 3.4+
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, exp.loc.source, exp.loc.start.offset, exp.loc, '(', ')');
+        }
+        else {
+            const propVariableName = (0, shared_1.camelize)(exp.loc.source);
+            if (utils_1.variableNameRegex.test(propVariableName)) {
+                const isDestructuredProp = options.destructuredPropNames?.has(propVariableName) ?? false;
+                const isTemplateRef = options.templateRefNames?.has(propVariableName) ?? false;
+                const codes = (0, camelized_1.generateCamelized)(exp.loc.source, exp.loc.start.offset, features);
+                if (ctx.hasLocalVariable(propVariableName) || isDestructuredProp) {
+                    yield* codes;
+                }
+                else {
+                    ctx.accessExternalVariable(propVariableName, exp.loc.start.offset);
+                    if (isTemplateRef) {
+                        yield `__VLS_unref(`;
+                        yield* codes;
+                        yield `)`;
+                    }
+                    else {
+                        yield `__VLS_ctx.`;
+                        yield* codes;
+                    }
+                }
+                if (enableCodeFeatures) {
+                    ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.loc, propVariableName));
+                }
+            }
+        }
+    }
+    else {
+        yield `{}`;
+    }
+}
+function* generateAttrValue(attrNode, features) {
+    const quote = attrNode.loc.source.startsWith("'") ? "'" : '"';
+    yield quote;
+    let start = attrNode.loc.start.offset;
+    let content = attrNode.loc.source;
+    if ((content.startsWith('"') && content.endsWith('"'))
+        || (content.startsWith("'") && content.endsWith("'"))) {
+        start++;
+        content = content.slice(1, -1);
+    }
+    yield* (0, unicode_1.generateUnicode)(content, start, features);
+    yield quote;
+}
+function getShouldCamelize(options, prop, propName) {
+    return (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
+        || !prop.arg
+        || (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))
+        && (0, shared_2.hyphenateAttr)(propName) === propName
+        && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern));
+}
+function getPropsCodeInfo(ctx, strictPropsCheck, shouldCamelize) {
+    const codeInfo = ctx.codeFeatures.withoutHighlightAndCompletion;
+    return {
+        ...codeInfo,
+        navigation: codeInfo.navigation
+            ? {
+                resolveRenameNewName: shared_1.camelize,
+                resolveRenameEditText: shouldCamelize ? shared_2.hyphenateAttr : undefined,
+            }
+            : false,
+        verification: strictPropsCheck
+            ? codeInfo.verification
+            : {
+                shouldReport(_source, code) {
+                    if (String(code) === '2353' || String(code) === '2561') {
+                        return false;
+                    }
+                    return typeof codeInfo.verification === 'object'
+                        ? codeInfo.verification.shouldReport?.(_source, code) ?? true
+                        : true;
+                },
+            }
+    };
+}
+function getModelPropName(node, vueCompilerOptions) {
+    for (const modelName in vueCompilerOptions.experimentalModelPropName) {
+        const tags = vueCompilerOptions.experimentalModelPropName[modelName];
+        for (const tag in tags) {
+            if (node.tag === tag || node.tag === (0, shared_2.hyphenateTag)(tag)) {
+                const val = tags[tag];
+                if (typeof val === 'object') {
+                    const arr = Array.isArray(val) ? val : [val];
+                    for (const attrs of arr) {
+                        let failed = false;
+                        for (const attr in attrs) {
+                            const attrNode = node.props.find(prop => prop.type === CompilerDOM.NodeTypes.ATTRIBUTE && prop.name === attr);
+                            if (!attrNode || attrNode.value?.content !== attrs[attr]) {
+                                failed = true;
+                                break;
+                            }
+                        }
+                        if (!failed) {
+                            // all match
+                            return modelName || undefined;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for (const modelName in vueCompilerOptions.experimentalModelPropName) {
+        const tags = vueCompilerOptions.experimentalModelPropName[modelName];
+        for (const tag in tags) {
+            if (node.tag === tag || node.tag === (0, shared_2.hyphenateTag)(tag)) {
+                const attrs = tags[tag];
+                if (attrs === true) {
+                    return modelName || undefined;
+                }
+            }
+        }
+    }
+    return vueCompilerOptions.target < 3 ? 'value' : 'modelValue';
+}
+//# sourceMappingURL=elementProps.js.map

node_modules/@vue/language-core/lib/codegen/template/index.d.ts

@@ -0,0 +1,21 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code, Sfc, VueCompilerOptions } from '../../types';
+import { TemplateCodegenContext } from './context';
+export interface TemplateCodegenOptions {
+    ts: typeof ts;
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    template: NonNullable<Sfc['template']>;
+    edited: boolean;
+    scriptSetupBindingNames: Set<string>;
+    scriptSetupImportComponentNames: Set<string>;
+    destructuredPropNames: Set<string>;
+    templateRefNames: Set<string>;
+    hasDefineSlots?: boolean;
+    slotsAssignName?: string;
+    propsAssignName?: string;
+    inheritAttrs: boolean;
+}
+export declare function generateTemplate(options: TemplateCodegenOptions): Generator<Code, TemplateCodegenContext>;
+export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;

node_modules/@vue/language-core/lib/codegen/template/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplate = generateTemplate;
+exports.forEachElementNode = forEachElementNode;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("../../utils/shared");
+const utils_1 = require("../utils");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
+const context_1 = require("./context");
+const objectProperty_1 = require("./objectProperty");
+const styleScopedClasses_1 = require("./styleScopedClasses");
+const templateChild_1 = require("./templateChild");
+function* generateTemplate(options) {
+    const ctx = (0, context_1.createTemplateCodegenContext)(options);
+    if (options.slotsAssignName) {
+        ctx.addLocalVariable(options.slotsAssignName);
+    }
+    if (options.propsAssignName) {
+        ctx.addLocalVariable(options.propsAssignName);
+    }
+    ctx.addLocalVariable((0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target));
+    ctx.addLocalVariable('$attrs');
+    ctx.addLocalVariable('$refs');
+    ctx.addLocalVariable('$el');
+    if (options.template.ast) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast, undefined);
+    }
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(ctx);
+    yield* generateSlots(options, ctx);
+    yield* generateInheritedAttrs(ctx);
+    yield* generateRefs(ctx);
+    yield* generateRootEl(ctx);
+    yield* ctx.generateAutoImportCompletion();
+    return ctx;
+}
+function* generateSlots(options, ctx) {
+    if (!options.hasDefineSlots) {
+        yield `var __VLS_slots!: `;
+        for (const { expVar, varName } of ctx.dynamicSlots) {
+            ctx.hasSlot = true;
+            yield `Partial<Record<NonNullable<typeof ${expVar}>, (_: typeof ${varName}) => any>> &${utils_1.newLine}`;
+        }
+        yield `{${utils_1.newLine}`;
+        for (const slot of ctx.slots) {
+            ctx.hasSlot = true;
+            if (slot.name && slot.loc !== undefined) {
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.loc, ctx.codeFeatures.withoutHighlightAndCompletion, slot.nodeLoc);
+            }
+            else {
+                yield* (0, utils_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+            }
+            yield `?(_: typeof ${slot.varName}): any,${utils_1.newLine}`;
+        }
+        yield `}${utils_1.endOfLine}`;
+    }
+    const name = (0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target);
+    yield `var ${name}!: typeof ${options.slotsAssignName ?? '__VLS_slots'}${utils_1.endOfLine}`;
+}
+function* generateInheritedAttrs(ctx) {
+    yield 'let __VLS_inheritedAttrs!: {}';
+    for (const varName of ctx.inheritedAttrVars) {
+        yield ` & typeof ${varName}`;
+    }
+    yield utils_1.endOfLine;
+    yield `var $attrs!: Partial<typeof __VLS_inheritedAttrs> & Record<string, unknown>${utils_1.endOfLine}`;
+    if (ctx.bindingAttrLocs.length) {
+        yield `[`;
+        for (const loc of ctx.bindingAttrLocs) {
+            yield [
+                loc.source,
+                'template',
+                loc.start.offset,
+                ctx.codeFeatures.all
+            ];
+            yield `,`;
+        }
+        yield `]${utils_1.endOfLine}`;
+    }
+}
+function* generateRefs(ctx) {
+    yield `const __VLS_refs = {${utils_1.newLine}`;
+    for (const [name, [varName, offset]] of ctx.templateRefs) {
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(name, offset, ctx.codeFeatures.navigationAndCompletion);
+        yield `: ${varName},${utils_1.newLine}`;
+    }
+    yield `}${utils_1.endOfLine}`;
+    yield `var $refs!: typeof __VLS_refs${utils_1.endOfLine}`;
+}
+function* generateRootEl(ctx) {
+    if (ctx.singleRootElType) {
+        yield `var $el!: ${ctx.singleRootElType}${utils_1.endOfLine}`;
+    }
+    else {
+        yield `var $el!: any${utils_1.endOfLine}`;
+    }
+}
+function* forEachElementNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        const patchForNode = (0, templateChild_1.getVForNode)(node);
+        if (patchForNode) {
+            yield* forEachElementNode(patchForNode);
+        }
+        else {
+            yield node;
+            for (const child of node.children) {
+                yield* forEachElementNode(child);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        // v-if / v-else-if / v-else
+        for (let i = 0; i < node.branches.length; i++) {
+            const branch = node.branches[i];
+            for (const childNode of branch.children) {
+                yield* forEachElementNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        // v-for
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/lib/codegen/template/interpolation.d.ts

@@ -0,0 +1,8 @@
+import type * as ts from 'typescript';
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+export declare function generateInterpolation(options: {
+    ts: typeof ts;
+    destructuredPropNames: Set<string> | undefined;
+    templateRefNames: Set<string> | undefined;
+}, ctx: TemplateCodegenContext, source: string, data: VueCodeInformation | ((offset: number) => VueCodeInformation) | undefined, _code: string, start: number | undefined, astHolder?: any, prefix?: string, suffix?: string): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/interpolation.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterpolation = generateInterpolation;
+const shared_1 = require("@vue/shared");
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const utils_1 = require("../utils");
+function* generateInterpolation(options, ctx, source, data, _code, start, astHolder = {}, prefix = '', suffix = '') {
+    const code = prefix + _code + suffix;
+    const ast = (0, utils_1.createTsAst)(options.ts, astHolder, code);
+    for (let [section, offset, type] of forEachInterpolationSegment(options.ts, options.destructuredPropNames, options.templateRefNames, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
+        if (offset === undefined) {
+            yield section;
+        }
+        else {
+            offset -= prefix.length;
+            let addSuffix = '';
+            const overLength = offset + section.length - _code.length;
+            if (overLength > 0) {
+                addSuffix = section.slice(section.length - overLength);
+                section = section.slice(0, -overLength);
+            }
+            if (offset < 0) {
+                yield section.slice(0, -offset);
+                section = section.slice(-offset);
+                offset = 0;
+            }
+            const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+            if (!shouldSkip) {
+                if (start !== undefined
+                    && data) {
+                    yield [
+                        section,
+                        source,
+                        start + offset,
+                        type === 'errorMappingOnly'
+                            ? ctx.codeFeatures.verification
+                            : typeof data === 'function' ? data(start + offset) : data,
+                    ];
+                }
+                else {
+                    yield section;
+                }
+            }
+            yield addSuffix;
+        }
+    }
+}
+function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, code, offset, ast) {
+    let ctxVars = [];
+    const varCb = (id, isShorthand) => {
+        const text = (0, scriptSetupRanges_1.getNodeText)(ts, id, ast);
+        if (ctx.hasLocalVariable(text) ||
+            // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
+            (0, shared_1.isGloballyAllowed)(text) ||
+            text === 'require' ||
+            text.startsWith('__VLS_')) {
+            // localVarOffsets.push(localVar.getStart(ast));
+        }
+        else {
+            ctxVars.push({
+                text,
+                isShorthand: isShorthand,
+                offset: (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start,
+            });
+            if (destructuredPropNames?.has(text)) {
+                return;
+            }
+            if (offset !== undefined) {
+                ctx.accessExternalVariable(text, offset + (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start);
+            }
+            else {
+                ctx.accessExternalVariable(text);
+            }
+        }
+    };
+    ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, ctx));
+    ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
+    if (ctxVars.length) {
+        if (ctxVars[0].isShorthand) {
+            yield [code.slice(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
+            yield [': ', undefined];
+        }
+        else if (ctxVars[0].offset > 0) {
+            yield [code.slice(0, ctxVars[0].offset), 0, 'startText'];
+        }
+        for (let i = 0; i < ctxVars.length - 1; i++) {
+            const curVar = ctxVars[i];
+            const nextVar = ctxVars[i + 1];
+            yield* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar);
+            if (nextVar.isShorthand) {
+                yield [code.slice(curVar.offset + curVar.text.length, nextVar.offset + nextVar.text.length), curVar.offset + curVar.text.length];
+                yield [': ', undefined];
+            }
+            else {
+                yield [code.slice(curVar.offset + curVar.text.length, nextVar.offset), curVar.offset + curVar.text.length];
+            }
+        }
+        const lastVar = ctxVars.at(-1);
+        yield* generateVar(code, destructuredPropNames, templateRefNames, lastVar);
+        if (lastVar.offset + lastVar.text.length < code.length) {
+            yield [code.slice(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+        }
+    }
+    else {
+        yield [code, 0];
+    }
+}
+function* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar = curVar) {
+    // fix https://github.com/vuejs/language-tools/issues/1205
+    // fix https://github.com/vuejs/language-tools/issues/1264
+    yield ['', nextVar.offset, 'errorMappingOnly'];
+    const isDestructuredProp = destructuredPropNames?.has(curVar.text) ?? false;
+    const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
+    if (isTemplateRef) {
+        yield [`__VLS_unref(`, undefined];
+        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [`)`, undefined];
+    }
+    else {
+        if (!isDestructuredProp) {
+            yield [`__VLS_ctx.`, undefined];
+        }
+        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+    }
+}
+function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true) {
+    if (ts.isIdentifier(node)) {
+        cb(node, false);
+    }
+    else if (ts.isShorthandPropertyAssignment(node)) {
+        cb(node.name, true);
+    }
+    else if (ts.isPropertyAccessExpression(node)) {
+        walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars, false);
+    }
+    else if (ts.isVariableDeclaration(node)) {
+        (0, utils_1.collectVars)(ts, node.name, ast, blockVars);
+        for (const varName of blockVars) {
+            ctx.addLocalVariable(varName);
+        }
+        if (node.initializer) {
+            walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars, false);
+        }
+    }
+    else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        processFunction(ts, node, ast, cb, ctx);
+    }
+    else if (ts.isObjectLiteralExpression(node)) {
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                // fix https://github.com/vuejs/language-tools/issues/1176
+                if (ts.isComputedPropertyName(prop.name)) {
+                    walkIdentifiers(ts, prop.name.expression, ast, cb, ctx, blockVars, false);
+                }
+                walkIdentifiers(ts, prop.initializer, ast, cb, ctx, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1156
+            else if (ts.isShorthandPropertyAssignment(prop)) {
+                walkIdentifiers(ts, prop, ast, cb, ctx, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
+            else if (ts.isSpreadAssignment(prop)) {
+                // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
+                walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/4604
+            else if (ts.isFunctionLike(prop) && prop.body) {
+                processFunction(ts, prop, ast, cb, ctx);
+            }
+        }
+    }
+    else if (ts.isTypeReferenceNode(node)) {
+        // fix https://github.com/vuejs/language-tools/issues/1422
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+    else {
+        const _blockVars = blockVars;
+        if (ts.isBlock(node)) {
+            blockVars = [];
+        }
+        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, ctx, blockVars, false));
+        if (ts.isBlock(node)) {
+            for (const varName of blockVars) {
+                ctx.removeLocalVariable(varName);
+            }
+        }
+        blockVars = _blockVars;
+    }
+    if (isRoot) {
+        for (const varName of blockVars) {
+            ctx.removeLocalVariable(varName);
+        }
+    }
+}
+function processFunction(ts, node, ast, cb, ctx) {
+    const functionArgs = [];
+    for (const param of node.parameters) {
+        (0, utils_1.collectVars)(ts, param.name, ast, functionArgs);
+        if (param.type) {
+            walkIdentifiers(ts, param.type, ast, cb, ctx);
+        }
+    }
+    for (const varName of functionArgs) {
+        ctx.addLocalVariable(varName);
+    }
+    if (node.body) {
+        walkIdentifiers(ts, node.body, ast, cb, ctx);
+    }
+    for (const varName of functionArgs) {
+        ctx.removeLocalVariable(varName);
+    }
+}
+function walkIdentifiersInTypeReference(ts, node, cb) {
+    if (ts.isTypeQueryNode(node) && ts.isIdentifier(node.exprName)) {
+        cb(node.exprName, false);
+    }
+    else {
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+}
+//# sourceMappingURL=interpolation.js.map

node_modules/@vue/language-core/lib/codegen/template/objectProperty.d.ts

@@ -0,0 +1,4 @@
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, astHolder?: any, shouldCamelize?: boolean, shouldBeConstant?: boolean): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/objectProperty.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateObjectProperty = generateObjectProperty;
+const shared_1 = require("@vue/shared");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
+const interpolation_1 = require("./interpolation");
+function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false, shouldBeConstant = false) {
+    if (code.startsWith('[') && code.endsWith(']') && astHolder) {
+        if (shouldBeConstant) {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code.slice(1, -1), offset + 1, astHolder, `[__VLS_tryAsConstant(`, `)]`);
+        }
+        else {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset, astHolder);
+        }
+    }
+    else if (shouldCamelize) {
+        if (utils_1.variableNameRegex.test((0, shared_1.camelize)(code))) {
+            yield* (0, camelized_1.generateCamelized)(code, offset, features);
+        }
+        else {
+            yield* (0, utils_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, offset, utils_1.combineLastMapping), `'`);
+        }
+    }
+    else {
+        if (utils_1.variableNameRegex.test(code)) {
+            yield [code, 'template', offset, features];
+        }
+        else {
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, offset, features);
+        }
+    }
+}
+//# sourceMappingURL=objectProperty.js.map

node_modules/@vue/language-core/lib/codegen/template/propertyAccess.d.ts

@@ -0,0 +1,4 @@
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset?: number, features?: VueCodeInformation, astHolder?: any): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/propertyAccess.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePropertyAccess = generatePropertyAccess;
+const utils_1 = require("../utils");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
+const interpolation_1 = require("./interpolation");
+function* generatePropertyAccess(options, ctx, code, offset, features, astHolder) {
+    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && utils_1.variableNameRegex.test(code)) {
+        yield `.`;
+        yield offset !== undefined && features
+            ? [code, 'template', offset, features]
+            : code;
+    }
+    else if (code.startsWith('[') && code.endsWith(']')) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset, astHolder);
+    }
+    else {
+        yield `[`;
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, offset, features);
+        yield `]`;
+    }
+}
+//# sourceMappingURL=propertyAccess.js.map

node_modules/@vue/language-core/lib/codegen/template/slotOutlet.d.ts

@@ -0,0 +1,5 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateSlotOutlet(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.SlotOutletNode): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/slotOutlet.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSlotOutlet = generateSlotOutlet;
+const CompilerDOM = require("@vue/compiler-dom");
+const inlayHints_1 = require("../inlayHints");
+const utils_1 = require("../utils");
+const elementChildren_1 = require("./elementChildren");
+const elementProps_1 = require("./elementProps");
+const interpolation_1 = require("./interpolation");
+function* generateSlotOutlet(options, ctx, node) {
+    const startTagOffset = node.loc.start.offset + options.template.content.slice(node.loc.start.offset).indexOf(node.tag);
+    const varSlot = ctx.getInternalVariable();
+    const nameProp = node.props.find(prop => {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            return prop.name === 'name';
+        }
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            return prop.arg.content === 'name';
+        }
+    });
+    if (options.hasDefineSlots) {
+        yield `__VLS_normalizeSlot(`;
+        yield* (0, utils_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, utils_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value
+            ? `'${nameProp.value.content}'`
+            : nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                ? nameProp.exp.content
+                : `('default' as const)`), `]`);
+        yield `)?.(`;
+        yield* (0, utils_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
+        yield `)${utils_1.endOfLine}`;
+    }
+    else {
+        yield `var ${varSlot} = {${utils_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), options.vueCompilerOptions.strictTemplates, true);
+        yield `}${utils_1.endOfLine}`;
+        if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && nameProp.value) {
+            ctx.slots.push({
+                name: nameProp.value.content,
+                loc: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
+                tagRange: [startTagOffset, startTagOffset + node.tag.length],
+                varName: varSlot,
+                nodeLoc: node.loc,
+            });
+        }
+        else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const isShortHand = nameProp.arg?.loc.start.offset === nameProp.exp.loc.start.offset;
+            if (isShortHand) {
+                ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(nameProp.exp.loc, 'name'));
+            }
+            const slotExpVar = ctx.getInternalVariable();
+            yield `var ${slotExpVar} = `;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset, nameProp.exp, '(', ')');
+            yield ` as const${utils_1.endOfLine}`;
+            ctx.dynamicSlots.push({
+                expVar: slotExpVar,
+                varName: varSlot,
+            });
+        }
+        else {
+            ctx.slots.push({
+                name: 'default',
+                tagRange: [startTagOffset, startTagOffset + node.tag.length],
+                varName: varSlot,
+                nodeLoc: node.loc,
+            });
+        }
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
+}
+//# sourceMappingURL=slotOutlet.js.map

node_modules/@vue/language-core/lib/codegen/template/styleScopedClasses.d.ts

@@ -0,0 +1,3 @@
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+export declare function generateStyleScopedClassReferences(ctx: TemplateCodegenContext, withDot?: boolean): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/styleScopedClasses.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
+const utils_1 = require("../utils");
+function* generateStyleScopedClassReferences(ctx, withDot = false) {
+    if (!ctx.emptyClassOffsets.length && !ctx.scopedClasses.length) {
+        return;
+    }
+    yield `[`;
+    for (const offset of ctx.emptyClassOffsets) {
+        yield `'`;
+        yield [
+            '',
+            'template',
+            offset,
+            ctx.codeFeatures.additionalCompletion,
+        ];
+        yield `', `;
+    }
+    for (const { source, className, offset } of ctx.scopedClasses) {
+        yield [
+            '',
+            source,
+            offset - (withDot ? 1 : 0),
+            ctx.codeFeatures.navigation,
+        ];
+        yield `'`;
+        // fix https://github.com/vuejs/language-tools/issues/4537
+        yield* escapeString(source, className, offset, ['\\', '\'']);
+        yield `'`;
+        yield [
+            '',
+            source,
+            offset + className.length,
+            ctx.codeFeatures.navigationWithoutRename,
+        ];
+        yield `, `;
+    }
+    yield `] as (keyof __VLS_StyleScopedClasses)[]${utils_1.endOfLine}`;
+    function* escapeString(source, className, offset, escapeTargets) {
+        let count = 0;
+        const currentEscapeTargets = [...escapeTargets];
+        const firstEscapeTarget = currentEscapeTargets.shift();
+        const splitted = className.split(firstEscapeTarget);
+        for (let i = 0; i < splitted.length; i++) {
+            const part = splitted[i];
+            const partLength = part.length;
+            if (escapeTargets.length > 0) {
+                yield* escapeString(source, part, offset + count, [...currentEscapeTargets]);
+            }
+            else {
+                yield [
+                    part,
+                    source,
+                    offset + count,
+                    ctx.codeFeatures.navigationAndAdditionalCompletion,
+                ];
+            }
+            if (i !== splitted.length - 1) {
+                yield '\\';
+                yield [
+                    firstEscapeTarget,
+                    source,
+                    offset + count + partLength,
+                    ctx.codeFeatures.navigationAndAdditionalCompletion,
+                ];
+                count += partLength + 1;
+            }
+            else {
+                count += partLength;
+            }
+        }
+    }
+}
+//# sourceMappingURL=styleScopedClasses.js.map

node_modules/@vue/language-core/lib/codegen/template/templateChild.d.ts

@@ -0,0 +1,7 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, prevNode: CompilerDOM.TemplateChildNode | undefined, isVForChild?: boolean): Generator<Code>;
+export declare function getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
+export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

node_modules/@vue/language-core/lib/codegen/template/templateChild.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplateChild = generateTemplateChild;
+exports.getVForNode = getVForNode;
+exports.parseInterpolationNode = parseInterpolationNode;
+const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+const element_1 = require("./element");
+const interpolation_1 = require("./interpolation");
+const slotOutlet_1 = require("./slotOutlet");
+const vFor_1 = require("./vFor");
+const vIf_1 = require("./vIf");
+// @ts-ignore
+const transformContext = {
+    onError: () => { },
+    helperString: str => str.toString(),
+    replaceNode: () => { },
+    cacheHandlers: false,
+    prefixIdentifiers: false,
+    scopes: {
+        vFor: 0,
+        vOnce: 0,
+        vPre: 0,
+        vSlot: 0,
+    },
+    expressionPlugins: ['typescript'],
+};
+function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = false) {
+    if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
+        const commentText = prevNode.content.trim().split(' ')[0];
+        if (/^@vue-skip\b[\s\S]*/.test(commentText)) {
+            yield `// @vue-skip${utils_1.newLine}`;
+            return;
+        }
+        else if (/^@vue-ignore\b[\s\S]*/.test(commentText)) {
+            yield* ctx.ignoreError();
+        }
+        else if (/^@vue-expect-error\b[\s\S]*/.test(commentText)) {
+            yield* ctx.expectError(prevNode);
+        }
+        else {
+            const match = prevNode.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
+            if (match) {
+                const { content } = match.groups ?? {};
+                ctx.lastGenericComment = {
+                    content,
+                    offset: prevNode.loc.start.offset + match[0].indexOf(content)
+                };
+            }
+        }
+    }
+    const shouldInheritRootNodeAttrs = options.inheritAttrs;
+    const cur = node;
+    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
+        cur.codegenNode = cur.codegenNode.value;
+    }
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        let prev;
+        if (shouldInheritRootNodeAttrs && node.children.length === 1 && node.children[0].type === CompilerDOM.NodeTypes.ELEMENT) {
+            ctx.singleRootNode = node.children[0];
+        }
+        for (const childNode of node.children) {
+            yield* generateTemplateChild(options, ctx, childNode, prev);
+            prev = childNode;
+        }
+        yield* ctx.resetDirectiveComments('end of root');
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        const vForNode = getVForNode(node);
+        const vIfNode = getVIfNode(node);
+        if (vForNode) {
+            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode);
+        }
+        else if (vIfNode) {
+            yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode);
+        }
+        else {
+            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
+                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
+                || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
+                yield* (0, element_1.generateElement)(options, ctx, node, isVForChild);
+            }
+            else {
+                const { currentComponent } = ctx;
+                yield* (0, element_1.generateComponent)(options, ctx, node);
+                ctx.currentComponent = currentComponent;
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+        // {{ var }}
+        yield* generateTemplateChild(options, ctx, node.content, undefined);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
+        // {{ ... }} {{ ... }}
+        for (const childNode of node.children) {
+            if (typeof childNode === 'object') {
+                yield* generateTemplateChild(options, ctx, childNode, undefined);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+        // {{ ... }}
+        const [content, start] = parseInterpolationNode(node, options.template.content);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, content, start, node.content.loc, `(`, `)${utils_1.endOfLine}`);
+        yield* ctx.resetDirectiveComments('end of INTERPOLATION');
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        // v-if / v-else-if / v-else
+        yield* (0, vIf_1.generateVIf)(options, ctx, node);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        // v-for
+        yield* (0, vFor_1.generateVFor)(options, ctx, node);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT) {
+        // not needed progress
+    }
+}
+// TODO: track https://github.com/vuejs/vue-next/issues/3498
+function getVForNode(node) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'for');
+    if (forDirective) {
+        let forNode;
+        CompilerDOM.processFor(node, forDirective, transformContext, _forNode => {
+            forNode = { ..._forNode };
+            return undefined;
+        });
+        if (forNode) {
+            forNode.children = [{
+                    ...node,
+                    props: node.props.filter(prop => prop !== forDirective),
+                }];
+            return forNode;
+        }
+    }
+}
+function getVIfNode(node) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'if');
+    if (forDirective) {
+        let ifNode;
+        CompilerDOM.processIf(node, forDirective, transformContext, _ifNode => {
+            ifNode = { ..._ifNode };
+            return undefined;
+        });
+        if (ifNode) {
+            for (const branch of ifNode.branches) {
+                branch.children = [{
+                        ...node,
+                        props: node.props.filter(prop => prop !== forDirective),
+                    }];
+            }
+            return ifNode;
+        }
+    }
+}
+function parseInterpolationNode(node, template) {
+    let content = node.content.loc.source;
+    let start = node.content.loc.start.offset;
+    let leftCharacter;
+    let rightCharacter;
+    // fix https://github.com/vuejs/language-tools/issues/1787
+    while ((leftCharacter = template.slice(start - 1, start)).trim() === '' && leftCharacter.length) {
+        start--;
+        content = leftCharacter + content;
+    }
+    while ((rightCharacter = template.slice(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
+        content = content + rightCharacter;
+    }
+    return [
+        content,
+        start,
+    ];
+}
+//# sourceMappingURL=templateChild.js.map

node_modules/@vue/language-core/lib/codegen/template/vFor.d.ts

@@ -0,0 +1,12 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateVFor(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ForNode): Generator<Code>;
+export declare function parseVForNode(node: CompilerDOM.ForNode): {
+    leftExpressionRange: {
+        start: number;
+        end: number;
+    } | undefined;
+    leftExpressionText: string | undefined;
+};

node_modules/@vue/language-core/lib/codegen/template/vFor.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVFor = generateVFor;
+exports.parseVForNode = parseVForNode;
+const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+const interpolation_1 = require("./interpolation");
+const templateChild_1 = require("./templateChild");
+function* generateVFor(options, ctx, node) {
+    const { source } = node.parseResult;
+    const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
+    const forBlockVars = [];
+    yield `for (const [`;
+    if (leftExpressionRange && leftExpressionText) {
+        const collectAst = (0, utils_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
+        (0, utils_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
+        yield [
+            leftExpressionText,
+            'template',
+            leftExpressionRange.start,
+            ctx.codeFeatures.all,
+        ];
+    }
+    yield `] of `;
+    if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        yield `__VLS_getVForSourceType(`;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, source.loc, '(', ')');
+        yield `!)`; // #3102
+    }
+    else {
+        yield `{} as any`;
+    }
+    yield `) {${utils_1.newLine}`;
+    for (const varName of forBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    let isFragment = true;
+    for (const argument of node.codegenNode?.children.arguments ?? []) {
+        if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
+            && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
+            && argument.returns?.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
+            if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
+                isFragment = false;
+                continue;
+            }
+            for (const prop of argument.returns.props.properties) {
+                if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                    && !prop.value.isStatic) {
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, prop.value.loc, '(', ')');
+                    yield utils_1.endOfLine;
+                }
+            }
+        }
+    }
+    if (isFragment) {
+        yield* ctx.resetDirectiveComments('end of v-for start');
+    }
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev, true);
+        prev = childNode;
+    }
+    for (const varName of forBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${utils_1.newLine}`;
+}
+function parseVForNode(node) {
+    const { value, key, index } = node.parseResult;
+    const leftExpressionRange = (value || key || index)
+        ? {
+            start: (value ?? key ?? index).loc.start.offset,
+            end: (index ?? key ?? value).loc.end.offset,
+        }
+        : undefined;
+    const leftExpressionText = leftExpressionRange
+        ? node.loc.source.slice(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        : undefined;
+    return {
+        leftExpressionRange,
+        leftExpressionText,
+    };
+}
+//# sourceMappingURL=vFor.js.map

node_modules/@vue/language-core/lib/codegen/template/vIf.d.ts

@@ -0,0 +1,5 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/vIf.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVIf = generateVIf;
+const CompilerDOM = require("@vue/compiler-dom");
+const muggle_string_1 = require("muggle-string");
+const utils_1 = require("../utils");
+const interpolation_1 = require("./interpolation");
+const templateChild_1 = require("./templateChild");
+function* generateVIf(options, ctx, node) {
+    let originalBlockConditionsLength = ctx.blockConditions.length;
+    for (let i = 0; i < node.branches.length; i++) {
+        const branch = node.branches[i];
+        if (i === 0) {
+            yield `if `;
+        }
+        else if (branch.condition) {
+            yield `else if `;
+        }
+        else {
+            yield `else `;
+        }
+        let addedBlockCondition = false;
+        if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const codes = [
+                ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, '(', ')'),
+            ];
+            for (const code of codes) {
+                yield code;
+            }
+            ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
+            addedBlockCondition = true;
+            yield ` `;
+        }
+        yield `{${utils_1.newLine}`;
+        if (isFragment(node)) {
+            yield* ctx.resetDirectiveComments('end of v-if start');
+        }
+        let prev;
+        for (const childNode of branch.children) {
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
+            prev = childNode;
+        }
+        yield* ctx.generateAutoImportCompletion();
+        yield `}${utils_1.newLine}`;
+        if (addedBlockCondition) {
+            ctx.blockConditions[ctx.blockConditions.length - 1] = `!(${ctx.blockConditions[ctx.blockConditions.length - 1]})`;
+        }
+    }
+    ctx.blockConditions.length = originalBlockConditionsLength;
+}
+function isFragment(node) {
+    return node.codegenNode
+        && 'consequent' in node.codegenNode
+        && 'tag' in node.codegenNode.consequent
+        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
+}
+//# sourceMappingURL=vIf.js.map

node_modules/@vue/language-core/lib/codegen/utils/camelized.d.ts

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateCamelized(code: string, offset: number, info: VueCodeInformation): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/utils/camelized.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCamelized = generateCamelized;
+const shared_1 = require("@vue/shared");
+const index_1 = require("./index");
+function* generateCamelized(code, offset, info) {
+    const parts = code.split('-');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part !== '') {
+            if (i === 0) {
+                yield [
+                    part,
+                    'template',
+                    offset,
+                    info,
+                ];
+            }
+            else {
+                yield [
+                    (0, shared_1.capitalize)(part),
+                    'template',
+                    offset,
+                    index_1.combineLastMapping,
+                ];
+            }
+        }
+        offset += part.length + 1;
+    }
+}
+//# sourceMappingURL=camelized.js.map

node_modules/@vue/language-core/lib/codegen/utils/index.d.ts

@@ -0,0 +1,11 @@
+import type * as ts from 'typescript';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
+export declare const newLine = "\n";
+export declare const endOfLine = ";\n";
+export declare const combineLastMapping: VueCodeInformation;
+export declare const variableNameRegex: RegExp;
+export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: [id: ts.Identifier, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];
+export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
+export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

node_modules/@vue/language-core/lib/codegen/utils/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
+exports.wrapWith = wrapWith;
+exports.collectVars = collectVars;
+exports.collectIdentifiers = collectIdentifiers;
+exports.createTsAst = createTsAst;
+exports.generateSfcBlockSection = generateSfcBlockSection;
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+exports.newLine = `\n`;
+exports.endOfLine = `;${exports.newLine}`;
+exports.combineLastMapping = { __combineLastMapping: true };
+exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
+    yield ['', 'template', startOffset, features];
+    let offset = 1;
+    for (const wrapCode of wrapCodes) {
+        if (typeof wrapCode !== 'string') {
+            offset++;
+        }
+        yield wrapCode;
+    }
+    yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
+}
+function collectVars(ts, node, ast, results = []) {
+    const identifiers = collectIdentifiers(ts, node, []);
+    for (const [id] of identifiers) {
+        results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
+    }
+    return results;
+}
+function collectIdentifiers(ts, node, results = [], isRest = false) {
+    if (ts.isIdentifier(node)) {
+        results.push([node, isRest]);
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+        }
+    }
+    else if (ts.isArrayBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, false));
+    }
+    return results;
+}
+function createTsAst(ts, astHolder, text) {
+    if (astHolder.__volar_ast_text !== text) {
+        astHolder.__volar_ast_text = text;
+        astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
+    }
+    return astHolder.__volar_ast;
+}
+function generateSfcBlockSection(block, start, end, features) {
+    return [
+        block.content.slice(start, end),
+        block.name,
+        start,
+        features,
+    ];
+}
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/lib/codegen/utils/stringLiteralKey.d.ts

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateStringLiteralKey(code: string, offset?: number, info?: VueCodeInformation): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/utils/stringLiteralKey.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStringLiteralKey = generateStringLiteralKey;
+const index_1 = require("./index");
+function* generateStringLiteralKey(code, offset, info) {
+    if (offset === undefined || !info) {
+        yield `'${code}'`;
+    }
+    else {
+        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
+    }
+}
+//# sourceMappingURL=stringLiteralKey.js.map

node_modules/@vue/language-core/lib/codegen/utils/unicode.d.ts

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateUnicode(code: string, offset: number, info: VueCodeInformation): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/utils/unicode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnicode = generateUnicode;
+const index_1 = require("./index");
+function* generateUnicode(code, offset, info) {
+    if (needToUnicode(code)) {
+        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
+    }
+    else {
+        yield [code, 'template', offset, info];
+    }
+}
+function needToUnicode(str) {
+    return str.includes('\\') || str.includes('\n');
+}
+function toUnicode(str) {
+    return str.split('').map(value => {
+        const temp = value.charCodeAt(0).toString(16).padStart(4, '0');
+        if (temp.length > 2) {
+            return '\\u' + temp;
+        }
+        return value;
+    }).join('');
+}
+//# sourceMappingURL=unicode.js.map

node_modules/@vue/language-core/lib/languagePlugin.d.ts

@@ -0,0 +1,6 @@
+import { LanguagePlugin } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { VueCompilerOptions } from './types';
+import { VueVirtualCode } from './virtualFile/vueFile';
+export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, asFileName: (scriptId: T) => string): LanguagePlugin<T, VueVirtualCode>;
+export declare function getAllExtensions(options: VueCompilerOptions): string[];

node_modules/@vue/language-core/lib/languagePlugin.js

@@ -0,0 +1,122 @@
+"use strict";
+/// <reference types="@volar/typescript" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVueLanguagePlugin = createVueLanguagePlugin;
+exports.getAllExtensions = getAllExtensions;
+const language_core_1 = require("@volar/language-core");
+const CompilerDOM = require("@vue/compiler-dom");
+const plugins_1 = require("./plugins");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const vueFile_1 = require("./virtualFile/vueFile");
+const fileRegistries = [];
+function getVueFileRegistry(key, plugins) {
+    let fileRegistry = fileRegistries.find(r => r.key === key
+        && r.plugins.length === plugins.length
+        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
+    if (!fileRegistry) {
+        fileRegistry = new Map();
+        fileRegistries.push({
+            key: key,
+            plugins: plugins,
+            files: fileRegistry,
+        });
+    }
+    return fileRegistry;
+}
+function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
+    const values = [
+        ...Object.keys(vueCompilerOptions)
+            .sort()
+            .filter(key => key !== 'plugins')
+            .map(key => [key, vueCompilerOptions[key]]),
+        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+            .sort()
+            .map(key => [key, compilerOptions[key]]),
+    ];
+    return JSON.stringify(values);
+}
+function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
+    const pluginContext = {
+        modules: {
+            '@vue/compiler-dom': vueCompilerOptions.target < 3
+                ? {
+                    ...CompilerDOM,
+                    compile: CompilerVue2.compile,
+                }
+                : CompilerDOM,
+            typescript: ts,
+        },
+        compilerOptions,
+        vueCompilerOptions,
+    };
+    const plugins = (0, plugins_1.createPlugins)(pluginContext);
+    const fileRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    return {
+        getLanguageId(scriptId) {
+            const fileName = asFileName(scriptId);
+            for (const plugin of plugins) {
+                const languageId = plugin.getLanguageId?.(fileName);
+                if (languageId) {
+                    return languageId;
+                }
+            }
+        },
+        createVirtualCode(scriptId, languageId, snapshot) {
+            const fileName = asFileName(scriptId);
+            if (plugins.some(plugin => plugin.isValidFile?.(fileName, languageId))) {
+                const code = fileRegistry.get(fileName);
+                if (code) {
+                    code.update(snapshot);
+                    return code;
+                }
+                else {
+                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    fileRegistry.set(fileName, code);
+                    return code;
+                }
+            }
+        },
+        updateVirtualCode(_fileId, code, snapshot) {
+            code.update(snapshot);
+            return code;
+        },
+        typescript: {
+            extraFileExtensions: getAllExtensions(vueCompilerOptions)
+                .map(ext => ({
+                extension: ext.slice(1),
+                isMixedContent: true,
+                scriptKind: 7,
+            })),
+            getServiceScript(root) {
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
+                    if (/script_(js|jsx|ts|tsx)/.test(code.id)) {
+                        const lang = code.id.slice('script_'.length);
+                        return {
+                            code,
+                            extension: '.' + lang,
+                            scriptKind: lang === 'js' ? ts.ScriptKind.JS
+                                : lang === 'jsx' ? ts.ScriptKind.JSX
+                                    : lang === 'tsx' ? ts.ScriptKind.TSX
+                                        : ts.ScriptKind.TS,
+                        };
+                    }
+                }
+            },
+        },
+    };
+}
+function getAllExtensions(options) {
+    const result = new Set();
+    for (const key in options) {
+        if (key === 'extensions' || key.endsWith('Extensions')) {
+            const value = options[key];
+            if (Array.isArray(value) && value.every(v => typeof v === 'string')) {
+                for (const ext of value) {
+                    result.add(ext);
+                }
+            }
+        }
+    }
+    return [...result];
+}
+//# sourceMappingURL=languagePlugin.js.map

node_modules/@vue/language-core/lib/parsers/scriptRanges.d.ts

@@ -0,0 +1,23 @@
+import type * as ts from 'typescript';
+import type { TextRange } from '../types';
+export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
+}
+export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
+    exportDefault: (TextRange & {
+        expression: TextRange;
+        args: TextRange;
+        argsNode: ts.ObjectLiteralExpression | undefined;
+        componentsOption: TextRange | undefined;
+        componentsOptionNode: ts.ObjectLiteralExpression | undefined;
+        directivesOption: TextRange | undefined;
+        nameOption: TextRange | undefined;
+        inheritAttrsOption: string | undefined;
+    }) | undefined;
+    classBlockEnd: number | undefined;
+    bindings: {
+        range: TextRange;
+        moduleName?: string;
+        isDefaultImport?: boolean;
+        isNamespace?: boolean;
+    }[];
+};

node_modules/@vue/language-core/lib/parsers/scriptRanges.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScriptRanges = parseScriptRanges;
+const scriptSetupRanges_1 = require("./scriptSetupRanges");
+function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
+    let exportDefault;
+    let classBlockEnd;
+    const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
+    ts.forEachChild(ast, raw => {
+        if (ts.isExportAssignment(raw)) {
+            let node = raw;
+            while (isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
+                node = node.expression;
+            }
+            let obj;
+            if (ts.isObjectLiteralExpression(node.expression)) {
+                obj = node.expression;
+            }
+            else if (ts.isCallExpression(node.expression) && node.expression.arguments.length) {
+                const arg0 = node.expression.arguments[0];
+                if (ts.isObjectLiteralExpression(arg0)) {
+                    obj = arg0;
+                }
+            }
+            if (obj) {
+                let componentsOptionNode;
+                let directivesOptionNode;
+                let nameOptionNode;
+                let inheritAttrsOption;
+                ts.forEachChild(obj, node => {
+                    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                        const name = (0, scriptSetupRanges_1.getNodeText)(ts, node.name, ast);
+                        if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
+                            componentsOptionNode = node.initializer;
+                        }
+                        else if (name === 'directives' && ts.isObjectLiteralExpression(node.initializer)) {
+                            directivesOptionNode = node.initializer;
+                        }
+                        else if (name === 'name') {
+                            nameOptionNode = node.initializer;
+                        }
+                        else if (name === 'inheritAttrs') {
+                            inheritAttrsOption = (0, scriptSetupRanges_1.getNodeText)(ts, node.initializer, ast);
+                        }
+                    }
+                });
+                exportDefault = {
+                    ..._getStartEnd(raw),
+                    expression: _getStartEnd(node.expression),
+                    args: _getStartEnd(obj),
+                    argsNode: withNode ? obj : undefined,
+                    componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
+                    componentsOptionNode: withNode ? componentsOptionNode : undefined,
+                    directivesOption: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
+                    nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+                    inheritAttrsOption,
+                };
+            }
+        }
+        if (ts.isClassDeclaration(raw)
+            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)
+            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
+            classBlockEnd = raw.end - 1;
+        }
+    });
+    return {
+        exportDefault,
+        classBlockEnd,
+        bindings,
+    };
+    function _getStartEnd(node) {
+        return (0, scriptSetupRanges_1.getStartEnd)(ts, node, ast);
+    }
+    // isAsExpression is missing in tsc
+    function isAsExpression(node) {
+        return node.kind === ts.SyntaxKind.AsExpression;
+    }
+}
+//# sourceMappingURL=scriptRanges.js.map

node_modules/@vue/language-core/lib/parsers/scriptSetupRanges.d.ts

@@ -0,0 +1,75 @@
+import type * as ts from 'typescript';
+import type { TextRange, VueCompilerOptions } from '../types';
+type CallExpressionRange = {
+    callExp: TextRange;
+    exp: TextRange;
+    arg?: TextRange;
+    typeArg?: TextRange;
+};
+type DefineProp = {
+    localName?: TextRange;
+    name?: TextRange;
+    type?: TextRange;
+    modifierType?: TextRange;
+    runtimeType?: TextRange;
+    defaultValue?: TextRange;
+    required?: boolean;
+    isModel?: boolean;
+};
+type DefineProps = CallExpressionRange & {
+    name?: string;
+    destructured?: Set<string>;
+    destructuredRest?: string;
+    statement: TextRange;
+};
+type WithDefaults = Pick<CallExpressionRange, 'callExp' | 'exp' | 'arg'>;
+type DefineEmits = CallExpressionRange & {
+    name?: string;
+    hasUnionTypeArg?: boolean;
+    statement: TextRange;
+};
+type DefineSlots = CallExpressionRange & {
+    name?: string;
+    isObjectBindingPattern?: boolean;
+    statement: TextRange;
+};
+type DefineOptions = {
+    name?: string;
+    inheritAttrs?: string;
+};
+type UseTemplateRef = CallExpressionRange & {
+    name?: string;
+};
+export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
+}
+export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    leadingCommentEndOffset: number;
+    importSectionEndOffset: number;
+    bindings: {
+        range: TextRange;
+        moduleName?: string;
+        isDefaultImport?: boolean;
+        isNamespace?: boolean;
+    }[];
+    defineProp: DefineProp[];
+    defineProps: DefineProps | undefined;
+    withDefaults: WithDefaults | undefined;
+    defineEmits: DefineEmits | undefined;
+    defineSlots: DefineSlots | undefined;
+    defineExpose: CallExpressionRange | undefined;
+    defineOptions: DefineOptions | undefined;
+    useAttrs: CallExpressionRange[];
+    useCssModule: CallExpressionRange[];
+    useSlots: CallExpressionRange[];
+    useTemplateRef: UseTemplateRef[];
+};
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
+    range: TextRange;
+    moduleName?: string;
+    isDefaultImport?: boolean;
+    isNamespace?: boolean;
+}[];
+export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, ast: ts.SourceFile): TextRange[];
+export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
+export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;
+export {};

node_modules/@vue/language-core/lib/parsers/scriptSetupRanges.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScriptSetupRanges = parseScriptSetupRanges;
+exports.parseBindingRanges = parseBindingRanges;
+exports.findBindingVars = findBindingVars;
+exports.getStartEnd = getStartEnd;
+exports.getNodeText = getNodeText;
+const utils_1 = require("../codegen/utils");
+const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
+function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
+    const defineProp = [];
+    let defineProps;
+    let withDefaults;
+    let defineEmits;
+    let defineSlots;
+    let defineExpose;
+    let defineOptions;
+    const useAttrs = [];
+    const useCssModule = [];
+    const useSlots = [];
+    const useTemplateRef = [];
+    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
+    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
+    const text = ast.text;
+    const leadingCommentRanges = ts.getLeadingCommentRanges(text, 0)?.reverse() ?? [];
+    const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckReg.test(text.slice(range.pos, range.end)))?.end ?? 0;
+    let bindings = parseBindingRanges(ts, ast);
+    let foundNonImportExportNode = false;
+    let importSectionEndOffset = 0;
+    ts.forEachChild(ast, node => {
+        const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node))
+            && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+        if (!foundNonImportExportNode
+            && !ts.isImportDeclaration(node)
+            && !isTypeExport
+            && !ts.isEmptyStatement(node)
+            // fix https://github.com/vuejs/language-tools/issues/1223
+            && !ts.isImportEqualsDeclaration(node)) {
+            const commentRanges = ts.getLeadingCommentRanges(text, node.pos);
+            if (commentRanges?.length) {
+                const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
+                importSectionEndOffset = commentRange.pos;
+            }
+            else {
+                importSectionEndOffset = getStartEnd(ts, node, ast).start;
+            }
+            foundNonImportExportNode = true;
+        }
+    });
+    ts.forEachChild(ast, node => visitNode(node, [ast]));
+    const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
+    bindings = bindings.filter(({ range }) => {
+        const name = text.slice(range.start, range.end);
+        return !templateRefNames.has(name);
+    });
+    return {
+        leadingCommentEndOffset,
+        importSectionEndOffset,
+        bindings,
+        defineProp,
+        defineProps,
+        withDefaults,
+        defineEmits,
+        defineSlots,
+        defineExpose,
+        defineOptions,
+        useAttrs,
+        useCssModule,
+        useSlots,
+        useTemplateRef,
+    };
+    function visitNode(node, parents) {
+        const parent = parents[parents.length - 1];
+        if (ts.isCallExpression(node)
+            && ts.isIdentifier(node.expression)) {
+            const callText = _getNodeText(node.expression);
+            if (vueCompilerOptions.macros.defineModel.includes(callText)) {
+                let localName;
+                let propName;
+                let options;
+                if (ts.isVariableDeclaration(parent) &&
+                    ts.isIdentifier(parent.name)) {
+                    localName = _getStartEnd(parent.name);
+                }
+                if (node.arguments.length >= 2) {
+                    propName = _getStartEnd(node.arguments[0]);
+                    options = node.arguments[1];
+                }
+                else if (node.arguments.length >= 1) {
+                    if (ts.isStringLiteralLike(node.arguments[0])) {
+                        propName = _getStartEnd(node.arguments[0]);
+                    }
+                    else {
+                        options = node.arguments[0];
+                    }
+                }
+                let runtimeType;
+                let defaultValue;
+                let required = false;
+                if (options && ts.isObjectLiteralExpression(options)) {
+                    for (const property of options.properties) {
+                        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                            continue;
+                        }
+                        const text = _getNodeText(property.name);
+                        if (text === 'type') {
+                            runtimeType = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'default') {
+                            defaultValue = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
+                        }
+                    }
+                }
+                defineProp.push({
+                    localName,
+                    name: propName,
+                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    modifierType: node.typeArguments && node.typeArguments?.length >= 2 ? _getStartEnd(node.typeArguments[1]) : undefined,
+                    runtimeType,
+                    defaultValue,
+                    required,
+                    isModel: true,
+                });
+            }
+            else if (callText === 'defineProp') {
+                let localName;
+                let propName;
+                let options;
+                if (ts.isVariableDeclaration(parent) &&
+                    ts.isIdentifier(parent.name)) {
+                    localName = _getStartEnd(parent.name);
+                }
+                let runtimeType;
+                let defaultValue;
+                let required = false;
+                if (definePropProposalA) {
+                    if (node.arguments.length >= 2) {
+                        options = node.arguments[1];
+                    }
+                    if (node.arguments.length >= 1) {
+                        propName = _getStartEnd(node.arguments[0]);
+                    }
+                    if (options && ts.isObjectLiteralExpression(options)) {
+                        for (const property of options.properties) {
+                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                                continue;
+                            }
+                            const text = _getNodeText(property.name);
+                            if (text === 'type') {
+                                runtimeType = _getStartEnd(property.initializer);
+                            }
+                            else if (text === 'default') {
+                                defaultValue = _getStartEnd(property.initializer);
+                            }
+                            else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                                required = true;
+                            }
+                        }
+                    }
+                }
+                else if (definePropProposalB) {
+                    if (node.arguments.length >= 3) {
+                        options = node.arguments[2];
+                    }
+                    if (node.arguments.length >= 2) {
+                        if (node.arguments[1].kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
+                        }
+                    }
+                    if (node.arguments.length >= 1) {
+                        defaultValue = _getStartEnd(node.arguments[0]);
+                    }
+                    if (options && ts.isObjectLiteralExpression(options)) {
+                        for (const property of options.properties) {
+                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                                continue;
+                            }
+                            const text = _getNodeText(property.name);
+                            if (text === 'type') {
+                                runtimeType = _getStartEnd(property.initializer);
+                            }
+                        }
+                    }
+                }
+                defineProp.push({
+                    localName,
+                    name: propName,
+                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    runtimeType,
+                    defaultValue,
+                    required,
+                });
+            }
+            else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                defineProps = {
+                    ...parseCallExpression(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
+                if (ts.isVariableDeclaration(parent)) {
+                    if (ts.isObjectBindingPattern(parent.name)) {
+                        defineProps.destructured = new Set();
+                        const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
+                        for (const [id, isRest] of identifiers) {
+                            const name = _getNodeText(id);
+                            if (isRest) {
+                                defineProps.destructuredRest = name;
+                            }
+                            else {
+                                defineProps.destructured.add(name);
+                            }
+                        }
+                    }
+                    else {
+                        defineProps.name = _getNodeText(parent.name);
+                    }
+                }
+                else if (ts.isCallExpression(parent)
+                    && vueCompilerOptions.macros.withDefaults.includes(_getNodeText(parent.expression))) {
+                    const grand = parents.at(-2);
+                    if (grand && ts.isVariableDeclaration(grand)) {
+                        defineProps.name = _getNodeText(grand.name);
+                    }
+                }
+            }
+            else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
+                const [, arg] = node.arguments;
+                withDefaults = {
+                    callExp: _getStartEnd(node),
+                    exp: _getStartEnd(node.expression),
+                    arg: arg ? _getStartEnd(arg) : undefined
+                };
+            }
+            else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
+                defineEmits = {
+                    ...parseCallExpression(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
+                if (ts.isVariableDeclaration(parent)) {
+                    defineEmits.name = _getNodeText(parent.name);
+                }
+                if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
+                    for (const member of node.typeArguments[0].members) {
+                        if (ts.isCallSignatureDeclaration(member)) {
+                            const type = member.parameters[0]?.type;
+                            if (type && ts.isUnionTypeNode(type)) {
+                                defineEmits.hasUnionTypeArg = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
+                defineSlots = {
+                    ...parseCallExpression(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
+                if (ts.isVariableDeclaration(parent)) {
+                    if (ts.isIdentifier(parent.name)) {
+                        defineSlots.name = _getNodeText(parent.name);
+                    }
+                    else {
+                        defineSlots.isObjectBindingPattern = ts.isObjectBindingPattern(parent.name);
+                    }
+                }
+            }
+            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                defineExpose = parseCallExpression(node);
+            }
+            else if (vueCompilerOptions.macros.defineOptions.includes(callText)
+                && node.arguments.length
+                && ts.isObjectLiteralExpression(node.arguments[0])) {
+                defineOptions = {};
+                const obj = node.arguments[0];
+                for (const prop of obj.properties) {
+                    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                        const name = _getNodeText(prop.name);
+                        if (name === 'inheritAttrs') {
+                            defineOptions.inheritAttrs = _getNodeText(prop.initializer);
+                        }
+                        else if (name === 'name' && ts.isStringLiteral(prop.initializer)) {
+                            defineOptions.name = prop.initializer.text;
+                        }
+                    }
+                }
+            }
+            else if (vueCompilerOptions.composables.useAttrs.includes(callText)) {
+                useAttrs.push(parseCallExpression(node));
+            }
+            else if (vueCompilerOptions.composables.useCssModule.includes(callText)) {
+                useCssModule.push(parseCallExpression(node));
+            }
+            else if (vueCompilerOptions.composables.useSlots.includes(callText)) {
+                useSlots.push(parseCallExpression(node));
+            }
+            else if (vueCompilerOptions.composables.useTemplateRef.includes(callText)
+                && !node.typeArguments?.length) {
+                useTemplateRef.push({
+                    name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
+                    ...parseCallExpression(node)
+                });
+            }
+        }
+        ts.forEachChild(node, child => {
+            if (ts.isFunctionLike(node)) {
+                return;
+            }
+            parents.push(node);
+            visitNode(child, parents);
+            parents.pop();
+        });
+    }
+    function parseCallExpression(node) {
+        return {
+            callExp: _getStartEnd(node),
+            exp: _getStartEnd(node.expression),
+            arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
+            typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+        };
+    }
+    function _getStartEnd(node) {
+        return getStartEnd(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return getNodeText(ts, node, ast);
+    }
+}
+function parseBindingRanges(ts, ast) {
+    const bindings = [];
+    ts.forEachChild(ast, node => {
+        if (ts.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                const vars = _findBindingVars(decl.name);
+                bindings.push(...vars.map(range => ({ range })));
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push({
+                    range: _getStartEnd(node.name)
+                });
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push({
+                    range: _getStartEnd(node.name)
+                });
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push({
+                range: _getStartEnd(node.name)
+            });
+        }
+        if (ts.isImportDeclaration(node)) {
+            const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                const { name, namedBindings } = node.importClause;
+                if (name) {
+                    bindings.push({
+                        range: _getStartEnd(name),
+                        moduleName,
+                        isDefaultImport: true
+                    });
+                }
+                if (namedBindings) {
+                    if (ts.isNamedImports(namedBindings)) {
+                        for (const element of namedBindings.elements) {
+                            if (element.isTypeOnly) {
+                                continue;
+                            }
+                            bindings.push({
+                                range: _getStartEnd(element.name),
+                                moduleName,
+                                isDefaultImport: element.propertyName?.text === 'default'
+                            });
+                        }
+                    }
+                    else {
+                        bindings.push({
+                            range: _getStartEnd(namedBindings.name),
+                            moduleName,
+                            isNamespace: true
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return getStartEnd(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return getNodeText(ts, node, ast);
+    }
+    function _findBindingVars(left) {
+        return findBindingVars(ts, left, ast);
+    }
+}
+function findBindingVars(ts, left, ast) {
+    const vars = [];
+    worker(left);
+    return vars;
+    function worker(node) {
+        if (ts.isIdentifier(node)) {
+            vars.push(getStartEnd(ts, node, ast));
+        }
+        // { ? } = ...
+        // [ ? ] = ...
+        else if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) {
+            for (const property of node.elements) {
+                if (ts.isBindingElement(property)) {
+                    worker(property.name);
+                }
+            }
+        }
+        // { foo: ? } = ...
+        else if (ts.isPropertyAssignment(node)) {
+            worker(node.initializer);
+        }
+        // { foo } = ...
+        else if (ts.isShorthandPropertyAssignment(node)) {
+            vars.push(getStartEnd(ts, node.name, ast));
+        }
+        // { ...? } = ...
+        // [ ...? ] = ...
+        else if (ts.isSpreadAssignment(node) || ts.isSpreadElement(node)) {
+            worker(node.expression);
+        }
+    }
+}
+function getStartEnd(ts, node, ast) {
+    return {
+        start: ts.getTokenPosOfNode(node, ast),
+        end: node.end,
+    };
+}
+function getNodeText(ts, node, ast) {
+    const { start, end } = getStartEnd(ts, node, ast);
+    return ast.text.slice(start, end);
+}
+function getStatementRange(ts, parents, node, ast) {
+    let statementRange;
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(parents[i])) {
+            const statement = parents[i];
+            ts.forEachChild(statement, child => {
+                const range = getStartEnd(ts, child, ast);
+                statementRange ??= range;
+                statementRange.end = range.end;
+            });
+            break;
+        }
+    }
+    if (!statementRange) {
+        statementRange = getStartEnd(ts, node, ast);
+    }
+    return statementRange;
+}
+//# sourceMappingURL=scriptSetupRanges.js.map

node_modules/@vue/language-core/lib/parsers/vueCompilerOptions.d.ts

@@ -0,0 +1,2 @@
+import type { VueCompilerOptions } from '../types';
+export declare function parseVueCompilerOptions(comments: string[]): Partial<VueCompilerOptions> | undefined;

node_modules/@vue/language-core/lib/parsers/vueCompilerOptions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVueCompilerOptions = parseVueCompilerOptions;
+const syntaxReg = /^\s*@(?<key>.+?)\s+(?<value>.+?)\s*$/m;
+function parseVueCompilerOptions(comments) {
+    const entries = comments
+        .map(text => {
+        try {
+            const match = text.match(syntaxReg);
+            if (match) {
+                const { key, value } = match.groups ?? {};
+                return [key, JSON.parse(value)];
+            }
+        }
+        catch { }
+        ;
+    })
+        .filter(item => !!item);
+    if (entries.length) {
+        return Object.fromEntries(entries);
+    }
+}
+//# sourceMappingURL=vueCompilerOptions.js.map

node_modules/@vue/language-core/lib/plugins.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from './types';
+export * from './plugins/shared';
+export declare function createPlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): import("./types").VueLanguagePluginReturn[];

node_modules/@vue/language-core/lib/plugins.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlugins = createPlugins;
+const file_html_1 = require("./plugins/file-html");
+const file_md_1 = require("./plugins/file-md");
+const file_vue_1 = require("./plugins/file-vue");
+const vue_root_tags_1 = require("./plugins/vue-root-tags");
+const vue_script_js_1 = require("./plugins/vue-script-js");
+const vue_sfc_customblocks_1 = require("./plugins/vue-sfc-customblocks");
+const vue_sfc_scripts_1 = require("./plugins/vue-sfc-scripts");
+const vue_sfc_styles_1 = require("./plugins/vue-sfc-styles");
+const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
+const vue_template_html_1 = require("./plugins/vue-template-html");
+const vue_template_inline_css_1 = require("./plugins/vue-template-inline-css");
+const vue_template_inline_ts_1 = require("./plugins/vue-template-inline-ts");
+const vue_tsx_1 = require("./plugins/vue-tsx");
+const types_1 = require("./types");
+__exportStar(require("./plugins/shared"), exports);
+function createPlugins(pluginContext) {
+    const plugins = [
+        file_vue_1.default,
+        file_md_1.default,
+        file_html_1.default,
+        vue_root_tags_1.default,
+        vue_script_js_1.default,
+        vue_template_html_1.default,
+        vue_template_inline_css_1.default,
+        vue_template_inline_ts_1.default,
+        vue_sfc_styles_1.default,
+        vue_sfc_customblocks_1.default,
+        vue_sfc_scripts_1.default,
+        vue_sfc_template_1.default,
+        vue_tsx_1.default,
+        ...pluginContext.vueCompilerOptions.plugins,
+    ];
+    const pluginInstances = plugins
+        .flatMap(plugin => {
+        try {
+            const instance = plugin(pluginContext);
+            const moduleName = plugin.__moduleName;
+            if (Array.isArray(instance)) {
+                for (let i = 0; i < instance.length; i++) {
+                    instance[i].name ??= `${moduleName} (${i})`;
+                }
+            }
+            else {
+                instance.name ??= moduleName;
+            }
+            return instance;
+        }
+        catch (err) {
+            console.warn('[Vue] Failed to create plugin', err);
+        }
+    })
+        .filter(plugin => !!plugin)
+        .sort((a, b) => {
+        const aOrder = a.order ?? 0;
+        const bOrder = b.order ?? 0;
+        return aOrder - bOrder;
+    });
+    return pluginInstances.filter(plugin => {
+        if (!types_1.validVersions.includes(plugin.version)) {
+            console.warn(`[Vue] Plugin ${plugin.name} is not compatible with the current Vue language tools version. (version: ${plugin.version}, supported versions: ${JSON.stringify(types_1.validVersions)})`);
+            return false;
+        }
+        return true;
+    });
+}
+//# sourceMappingURL=plugins.js.map

node_modules/@vue/language-core/lib/plugins/file-html.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;