@vue-vine/eslint-parser 0.2.14 → 0.2.16

package/dist/index.js

@@ -24,20 +24,34 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseFindIndex.js
-var require_baseFindIndex = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseFindIndex.js"(exports, module) {
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/head.js
+var require_head = __commonJS({
+  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/head.js"(exports, module) {
     "use strict";
-    function baseFindIndex(array, predicate, fromIndex, fromRight) {
-      var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
-      while (fromRight ? index-- : ++index < length) {
-        if (predicate(array[index], index, array)) {
-          return index;
-        }
-      }
-      return -1;
+    function head(array) {
+      return array && array.length ? array[0] : void 0;
     }
-    module.exports = baseFindIndex;
+    module.exports = head;
+  }
+});
+
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/first.js
+var require_first = __commonJS({
+  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/first.js"(exports, module) {
+    "use strict";
+    module.exports = require_head();
+  }
+});
+
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/last.js
+var require_last = __commonJS({
+  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/last.js"(exports, module) {
+    "use strict";
+    function last4(array) {
+      var length = array == null ? 0 : array.length;
+      return length ? array[length - 1] : void 0;
+    }
+    module.exports = last4;
   }
 });
 
@@ -2123,6 +2137,79 @@ var require_baseIteratee = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseSortedIndexBy.js
+var require_baseSortedIndexBy = __commonJS({
+  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseSortedIndexBy.js"(exports, module) {
+    "use strict";
+    var isSymbol = require_isSymbol();
+    var MAX_ARRAY_LENGTH = 4294967295;
+    var MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
+    var nativeFloor = Math.floor;
+    var nativeMin = Math.min;
+    function baseSortedIndexBy(array, value, iteratee, retHighest) {
+      var low = 0, high = array == null ? 0 : array.length;
+      if (high === 0) {
+        return 0;
+      }
+      value = iteratee(value);
+      var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === void 0;
+      while (low < high) {
+        var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), othIsDefined = computed !== void 0, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
+        if (valIsNaN) {
+          var setLow = retHighest || othIsReflexive;
+        } else if (valIsUndefined) {
+          setLow = othIsReflexive && (retHighest || othIsDefined);
+        } else if (valIsNull) {
+          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+        } else if (valIsSymbol) {
+          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+        } else if (othIsNull || othIsSymbol) {
+          setLow = false;
+        } else {
+          setLow = retHighest ? computed <= value : computed < value;
+        }
+        if (setLow) {
+          low = mid + 1;
+        } else {
+          high = mid;
+        }
+      }
+      return nativeMin(high, MAX_ARRAY_INDEX);
+    }
+    module.exports = baseSortedIndexBy;
+  }
+});
+
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/sortedIndexBy.js
+var require_sortedIndexBy = __commonJS({
+  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/sortedIndexBy.js"(exports, module) {
+    "use strict";
+    var baseIteratee = require_baseIteratee();
+    var baseSortedIndexBy = require_baseSortedIndexBy();
+    function sortedIndexBy2(array, value, iteratee) {
+      return baseSortedIndexBy(array, value, baseIteratee(iteratee, 2));
+    }
+    module.exports = sortedIndexBy2;
+  }
+});
+
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseFindIndex.js
+var require_baseFindIndex = __commonJS({
+  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseFindIndex.js"(exports, module) {
+    "use strict";
+    function baseFindIndex(array, predicate, fromIndex, fromRight) {
+      var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+      while (fromRight ? index-- : ++index < length) {
+        if (predicate(array[index], index, array)) {
+          return index;
+        }
+      }
+      return -1;
+    }
+    module.exports = baseFindIndex;
+  }
+});
+
 // ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_trimmedEndIndex.js
 var require_trimmedEndIndex = __commonJS({
   "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_trimmedEndIndex.js"(exports, module) {
@@ -2245,61 +2332,6 @@ var require_findLastIndex = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/last.js
-var require_last = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/last.js"(exports, module) {
-    "use strict";
-    function last4(array) {
-      var length = array == null ? 0 : array.length;
-      return length ? array[length - 1] : void 0;
-    }
-    module.exports = last4;
-  }
-});
-
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseSortedIndexBy.js
-var require_baseSortedIndexBy = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseSortedIndexBy.js"(exports, module) {
-    "use strict";
-    var isSymbol = require_isSymbol();
-    var MAX_ARRAY_LENGTH = 4294967295;
-    var MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
-    var nativeFloor = Math.floor;
-    var nativeMin = Math.min;
-    function baseSortedIndexBy(array, value, iteratee, retHighest) {
-      var low = 0, high = array == null ? 0 : array.length;
-      if (high === 0) {
-        return 0;
-      }
-      value = iteratee(value);
-      var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === void 0;
-      while (low < high) {
-        var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), othIsDefined = computed !== void 0, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
-        if (valIsNaN) {
-          var setLow = retHighest || othIsReflexive;
-        } else if (valIsUndefined) {
-          setLow = othIsReflexive && (retHighest || othIsDefined);
-        } else if (valIsNull) {
-          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
-        } else if (valIsSymbol) {
-          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
-        } else if (othIsNull || othIsSymbol) {
-          setLow = false;
-        } else {
-          setLow = retHighest ? computed <= value : computed < value;
-        }
-        if (setLow) {
-          low = mid + 1;
-        } else {
-          high = mid;
-        }
-      }
-      return nativeMin(high, MAX_ARRAY_INDEX);
-    }
-    module.exports = baseSortedIndexBy;
-  }
-});
-
 // ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseSortedIndex.js
 var require_baseSortedIndex = __commonJS({
   "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/_baseSortedIndex.js"(exports, module) {
@@ -2340,38 +2372,6 @@ var require_sortedLastIndex = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/head.js
-var require_head = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/head.js"(exports, module) {
-    "use strict";
-    function head(array) {
-      return array && array.length ? array[0] : void 0;
-    }
-    module.exports = head;
-  }
-});
-
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/first.js
-var require_first = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/first.js"(exports, module) {
-    "use strict";
-    module.exports = require_head();
-  }
-});
-
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/sortedIndexBy.js
-var require_sortedIndexBy = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/sortedIndexBy.js"(exports, module) {
-    "use strict";
-    var baseIteratee = require_baseIteratee();
-    var baseSortedIndexBy = require_baseSortedIndexBy();
-    function sortedIndexBy2(array, value, iteratee) {
-      return baseSortedIndexBy(array, value, baseIteratee(iteratee, 2));
-    }
-    module.exports = sortedIndexBy2;
-  }
-});
-
 // src/parse.ts
 var _parser = require('@typescript-eslint/parser');
 
@@ -3019,2159 +3019,2210 @@ function createVirtualVineFnPropsReference({
   return virtualReference;
 }
 
-// src/script/scope-analyzer.ts
-var BUILTIN_COMPONENTS = /* @__PURE__ */ new Set([
-  "template",
-  "slot",
-  "component",
-  "Component",
-  "transition",
-  "Transition",
-  "transition-group",
-  "TransitionGroup",
-  "keep-alive",
-  "KeepAlive",
-  "teleport",
-  "Teleport",
-  "suspense",
-  "Suspense"
-]);
-var BUILTIN_DIRECTIVES = /* @__PURE__ */ new Set([
-  "bind",
-  "on",
-  "text",
-  "html",
-  "show",
-  "if",
-  "else",
-  "else-if",
-  "for",
-  "model",
-  "slot",
-  "pre",
-  "cloak",
-  "once",
-  "memo",
-  "is"
-]);
-var HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
-var SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
-var NATIVE_TAGS = /* @__PURE__ */ new Set([...HTML_TAGS.split(","), ...SVG_TAGS.split(",")]);
-function isUnique(reference, index, references) {
-  return index === 0 || reference.identifier !== references[index - 1].identifier;
-}
-function camelize(str) {
-  return str.replace(/-(\w)/gu, (_, c) => c ? c.toUpperCase() : "");
-}
-function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1);
-}
-function hasDefinition(variable) {
-  return variable.defs.length >= 1;
+// src/common/debug.ts
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+var debug = _debug2.default.call(void 0, "vue-vine-eslint-parser");
+
+// src/common/error-utils.ts
+function insertError(templateMeta, error) {
+  const index = templateMeta.errors.findIndex((e) => e.index === error.index);
+  templateMeta.errors.splice(index, 0, error);
 }
-function transformReference(reference) {
-  const ret = {
-    id: reference.identifier,
-    mode: reference.isReadOnly() ? "r" : reference.isWriteOnly() ? "w" : (
-      /* otherwise */
-      "rw"
-    ),
-    variable: null,
-    isValueReference: reference.isValueReference,
-    isTypeReference: reference.isTypeReference
+
+// src/common/token-utils.ts
+function createSimpleToken(type, start, end, value, linesAndColumns) {
+  return {
+    type,
+    range: [start, end],
+    loc: {
+      start: linesAndColumns.getLocFromIndex(start),
+      end: linesAndColumns.getLocFromIndex(end)
+    },
+    value
   };
-  Object.defineProperty(ret, "variable", { enumerable: false });
-  return ret;
 }
-function transformVariable(variable, kind) {
-  const ret = {
-    id: variable.defs[0].name,
-    kind,
-    references: []
-  };
-  Object.defineProperty(ret, "references", { enumerable: false });
-  return ret;
+function insertComments(templateMeta, newComments) {
+  if (newComments.length === 0) {
+    return;
+  }
+  const index = templateMeta.comments.findIndex((comment) => comment.range[0] === newComments[0].range[0]);
+  templateMeta.comments.splice(index, 0, ...newComments);
 }
-function getForScope(scope) {
-  const child = scope.childScopes[0];
-  return child.block === scope.block ? child.childScopes[0] : child;
+function replaceTokens(templateMeta, node, newTokens) {
+  const index = templateMeta.tokens.findIndex((token) => token.range[0] === node.range[0]);
+  const count = templateMeta.tokens.findIndex((token) => token.range[1] === node.range[1]) - index + 1;
+  templateMeta.tokens.splice(index, count, ...newTokens);
 }
-function analyzeScope(ast, parserOptions) {
-  const ecmaVersion = getEcmaVersionIfUseEspree(parserOptions) || 2022;
-  const ecmaFeatures = parserOptions.ecmaFeatures || {};
-  const sourceType = parserOptions.sourceType || "script";
-  const result = getEslintScope().analyze(ast, {
-    ignoreEval: true,
-    nodejsScope: false,
-    impliedStrict: ecmaFeatures.impliedStrict,
-    ecmaVersion,
-    sourceType,
-    fallback: getFallbackKeys
+
+// src/script/index.ts
+var import_first = __toESM(require_first());
+var import_last = __toESM(require_last());
+var import_sortedIndexBy = __toESM(require_sortedIndexBy());
+
+
+// src/common/fix-locations.ts
+function fixLocations(result, locationCalculator) {
+  fixNodeLocations(result.ast, result.visitorKeys, locationCalculator);
+  for (const token of result.ast.tokens || []) {
+    fixLocation(token, locationCalculator);
+  }
+  for (const comment of result.ast.comments || []) {
+    fixLocation(comment, locationCalculator);
+  }
+}
+function fixNodeLocations(rootNode, visitorKeys, locationCalculator) {
+  const traversed = /* @__PURE__ */ new Map();
+  traverseNodes(rootNode, {
+    visitorKeys,
+    enterNode(node, parent) {
+      if (!traversed.has(node)) {
+        traversed.set(node, node);
+        node.parent = parent;
+        if (traversed.has(node.range)) {
+          if (!traversed.has(node.loc)) {
+            node.loc.start = locationCalculator.getLocFromIndex(
+              node.range[0]
+            );
+            node.loc.end = locationCalculator.getLocFromIndex(
+              node.range[1]
+            );
+            traversed.set(node.loc, node);
+          } else if (node.start != null || node.end != null) {
+            const traversedNode = traversed.get(node.range);
+            if (traversedNode.type === node.type) {
+              node.start = traversedNode.start;
+              node.end = traversedNode.end;
+            }
+          }
+        } else {
+          fixLocation(node, locationCalculator);
+          traversed.set(node.range, node);
+          traversed.set(node.loc, node);
+        }
+      }
+    },
+    leaveNode() {
+    }
   });
-  return result;
 }
-function analyze(parserResult, parserOptions) {
-  const scopeManager = parserResult.scopeManager || analyzeScope(parserResult.ast, parserOptions);
-  return scopeManager.globalScope;
+function fixLocation(node, locationCalculator) {
+  const range = node.range;
+  const loc = node.loc;
+  const d0 = locationCalculator.getFixOffset(range[0], "start");
+  const d1 = locationCalculator.getFixOffset(range[1], "end");
+  if (d0 !== 0) {
+    range[0] += d0;
+    if (node.start != null) {
+      node.start += d0;
+    }
+    loc.start = locationCalculator.getLocFromIndex(range[0]);
+  }
+  if (d1 !== 0) {
+    range[1] += d1;
+    if (node.end != null) {
+      node.end += d0;
+    }
+    loc.end = locationCalculator.getLocFromIndex(range[1]);
+  }
+  return node;
 }
-function analyzeExternalReferences(parserResult, parserOptions) {
-  const scope = analyze(parserResult, parserOptions);
-  return scope.through.filter(isUnique).map(transformReference);
+function fixErrorLocation(error, locationCalculator) {
+  const diff = locationCalculator.getFixOffset(error.index, "start");
+  error.index += diff;
+  const loc = locationCalculator.getLocFromIndex(error.index);
+  error.lineNumber = loc.line;
+  error.column = loc.column;
 }
-function analyzeVariablesAndExternalReferences(parserResult, kind, parserOptions) {
-  const scope = analyze(parserResult, parserOptions);
+
+// src/common/parser-object.ts
+function isParserObject(value) {
+  return isEnhancedParserObject(value) || isBasicParserObject(value);
+}
+function isEnhancedParserObject(value) {
+  return Boolean(value && typeof value.parseForESLint === "function");
+}
+function isBasicParserObject(value) {
+  return Boolean(value && typeof value.parse === "function");
+}
+
+// src/script/index.ts
+var ALIAS_ITERATOR = /^([\s\S]*?(?:\s|\)))(\bin\b|\bof\b)([\s\S]*)$/u;
+var PARENS = /^(\s*\()([\s\S]*?)(\)\s*)$/u;
+var DUMMY_PARENT = {};
+var IS_FUNCTION_EXPRESSION = /^\s*(?:[\w$]+|\([^)]*\))\s*=>|^function\s*\(/u;
+var IS_SIMPLE_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*'\]|\["[^"]*"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/u;
+function processVForAliasAndIterator(code) {
+  const match = ALIAS_ITERATOR.exec(code);
+  if (match != null) {
+    const aliases = match[1];
+    const parenMatch = PARENS.exec(aliases);
+    return {
+      aliases,
+      hasParens: Boolean(parenMatch),
+      aliasesWithBrackets: parenMatch ? `${parenMatch[1].slice(0, -1)}[${parenMatch[2]}]${parenMatch[3].slice(1)}` : `[${aliases.slice(0, -1)}]`,
+      delimiter: match[2] || "",
+      iterator: match[3]
+    };
+  }
   return {
-    variables: getForScope(scope).variables.filter(hasDefinition).map((v) => transformVariable(v, kind)),
-    references: scope.through.filter(isUnique).map(transformReference)
+    aliases: "",
+    hasParens: false,
+    aliasesWithBrackets: "",
+    delimiter: "",
+    iterator: code
   };
 }
-function collectVariablesForVCF(tsFileScopeManager, templateRoot) {
-  const scriptVariables = /* @__PURE__ */ new Map();
-  const globalScope = tsFileScopeManager.globalScope;
-  if (!globalScope) {
-    return scriptVariables;
-  }
-  for (const variable of globalScope.variables) {
-    scriptVariables.set(variable.name, variable);
-  }
-  const moduleScope = globalScope.childScopes.find(
-    (scope) => scope.type === "module"
+function getCommaTokenBeforeNode(tokens, node) {
+  let tokenIndex = (0, import_sortedIndexBy.default)(
+    tokens,
+    { range: node.range },
+    (t) => t.range[0]
   );
-  for (const variable of moduleScope && moduleScope.variables || []) {
-    scriptVariables.set(variable.name, variable);
-  }
-  let foundVCF = templateRoot.parent;
-  let foundVCFScope;
-  if (templateRoot.parent) {
-    do {
-      foundVCF = foundVCF.parent;
-    } while (foundVCF && foundVCF.type !== "FunctionDeclaration" && foundVCF.type !== "FunctionExpression" && foundVCF.type !== "ArrowFunctionExpression");
-    if (foundVCF) {
-      Object.assign(
-        foundVCF,
-        { __isVine__: true }
-      );
-      const tryGetVCFScope = tsFileScopeManager.nodeToScope.get(foundVCF);
-      if (_optionalChain([tryGetVCFScope, 'optionalAccess', _7 => _7[0]])) {
-        foundVCFScope = tryGetVCFScope[0];
-        for (const variable of foundVCFScope.variables) {
-          scriptVariables.set(variable.name, variable);
-        }
-        const compFnPropsIdentifier = _optionalChain([foundVCF, 'access', _8 => _8.params, 'optionalAccess', _9 => _9[0], 'optionalAccess', _10 => _10.type]) === "Identifier" && _optionalChain([foundVCF, 'access', _11 => _11.params, 'access', _12 => _12[0], 'optionalAccess', _13 => _13.name]) === "props" ? foundVCF.params[0] : null;
-        const propsVar = scriptVariables.get("props");
-        if (compFnPropsIdentifier && propsVar) {
-          ;
-          propsVar.eslintUsed = true;
-          propsVar.references.push(
-            createVirtualVineFnPropsReference({
-              foundVCFScope,
-              compFnPropsIdentifier
-            })
-          );
-        }
-      }
+  while (tokenIndex >= 0) {
+    const token = tokens[tokenIndex];
+    if (token.type === "Punctuator" && token.value === ",") {
+      return token;
     }
+    tokenIndex -= 1;
   }
-  return scriptVariables;
+  return null;
 }
-function analyzeUsedInTemplateVariables(scopeManager, templateRoot) {
-  const scriptVariables = collectVariablesForVCF(scopeManager, templateRoot);
-  const markedVariables = /* @__PURE__ */ new Set();
-  function markSetupReferenceVariableAsUsed(name) {
-    if (scriptVariables.has(name)) {
-      markVariableAsUsed(name);
-      return true;
-    }
-    const camelName = camelize(name);
-    if (scriptVariables.has(camelName)) {
-      markVariableAsUsed(camelName);
-      return true;
-    }
-    const pascalName = capitalize(camelName);
-    if (scriptVariables.has(pascalName)) {
-      markVariableAsUsed(pascalName);
-      return true;
-    }
-    return false;
-  }
-  function markVariableAsUsed(nameOrRef) {
-    let name;
-    let isValueReference;
-    let isTypeReference;
-    if (typeof nameOrRef === "string") {
-      name = nameOrRef;
-    } else {
-      name = nameOrRef.id.name;
-      isValueReference = nameOrRef.isValueReference;
-      isTypeReference = nameOrRef.isTypeReference;
-    }
-    const variable = scriptVariables.get(name);
-    if (!variable || variable.identifiers.length === 0) {
-      return;
-    }
-    if (markedVariables.has(name)) {
-      return;
+function throwEmptyError(locationCalculator, expected) {
+  const loc = locationCalculator.getLocation(0);
+  const err = new ParseError(
+    `Expected to be ${expected}, but got empty.`,
+    void 0,
+    0,
+    loc.line,
+    loc.column
+  );
+  fixErrorLocation(err, locationCalculator);
+  throw err;
+}
+function throwUnexpectedTokenError(name, token) {
+  const err = new ParseError(
+    `Unexpected token '${name}'.`,
+    void 0,
+    token.range[0],
+    token.loc.start.line,
+    token.loc.start.column
+  );
+  throw err;
+}
+function throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator) {
+  if (ParseError.isParseError(err)) {
+    const endOffset = locationCalculator.getOffsetWithGap(code.length);
+    if (err.index >= endOffset) {
+      err.message = "Unexpected end of expression.";
     }
-    markedVariables.add(name);
-    const reference = new tsEscopeTypes2.Reference(
-      variable.identifiers[0],
-      variable.scope,
-      1 /* Read */,
-      void 0,
-      void 0,
-      void 0,
-      isValueReference ? 1 /* Value */ : isTypeReference ? 2 /* Type */ : void 0
+  }
+  throw err;
+}
+function parseScriptFragment(code, locationCalculator, parserOptions) {
+  try {
+    const result = parseScript(
+      code,
+      parserOptions
     );
-    reference.vueUsedInTemplate = true;
-    reference.isWrite = () => false;
-    reference.isWriteOnly = () => false;
-    reference.isRead = () => true;
-    reference.isReadOnly = () => true;
-    reference.isReadWrite = () => false;
-    variable.references.push(reference);
-    reference.resolved = variable;
-    if (reference.isTypeReference) {
-      ;
-      variable.eslintUsed = true;
+    fixLocations(result, locationCalculator);
+    return result;
+  } catch (err) {
+    const perr = ParseError.normalize(err);
+    if (perr) {
+      fixErrorLocation(perr, locationCalculator);
+      throw perr;
     }
+    throw err;
   }
-  function processVExpressionContainer(node) {
-    for (const reference of node.references.filter(
-      (ref) => ref.variable == null
-    )) {
-      markVariableAsUsed(reference);
+}
+var validDivisionCharRE = /[\w).+\-$\]]/u;
+function splitFilters(exp) {
+  const result = [];
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplateString = false;
+  let inRegex = false;
+  let curly = 0;
+  let square = 0;
+  let paren = 0;
+  let lastFilterIndex = 0;
+  let c = 0;
+  let prev = 0;
+  for (let i = 0; i < exp.length; i++) {
+    prev = c;
+    c = exp.charCodeAt(i);
+    if (inSingle) {
+      if (c === 39 && prev !== 92) {
+        inSingle = false;
+      }
+    } else if (inDouble) {
+      if (c === 34 && prev !== 92) {
+        inDouble = false;
+      }
+    } else if (inTemplateString) {
+      if (c === 96 && prev !== 92) {
+        inTemplateString = false;
+      }
+    } else if (inRegex) {
+      if (c === 47 && prev !== 92) {
+        inRegex = false;
+      }
+    } else if (c === 124 && exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
+      result.push(exp.slice(lastFilterIndex, i));
+      lastFilterIndex = i + 1;
+    } else {
+      switch (c) {
+        case 34:
+          inDouble = true;
+          break;
+        case 39:
+          inSingle = true;
+          break;
+        case 96:
+          inTemplateString = true;
+          break;
+        case 40:
+          paren++;
+          break;
+        case 41:
+          paren--;
+          break;
+        case 91:
+          square++;
+          break;
+        case 93:
+          square--;
+          break;
+        case 123:
+          curly++;
+          break;
+        case 125:
+          curly--;
+          break;
+      }
+      if (c === 47) {
+        let j = i - 1;
+        let p;
+        for (; j >= 0; j--) {
+          p = exp.charAt(j);
+          if (p !== " ") {
+            break;
+          }
+        }
+        if (!p || !validDivisionCharRE.test(p)) {
+          inRegex = true;
+        }
+      }
     }
   }
-  function processVElement(node) {
-    if (node.rawName === node.name && NATIVE_TAGS.has(node.rawName) || BUILTIN_COMPONENTS.has(node.rawName)) {
-      return;
+  result.push(exp.slice(lastFilterIndex));
+  return result;
+}
+function parseExpressionBody(code, locationCalculator, parserOptions, allowEmpty = false) {
+  debug('[script] parse expression: "0(%s)"', code);
+  try {
+    const result = parseScriptFragment(
+      `0(${code})`,
+      locationCalculator.getSubCalculatorShift(-2),
+      parserOptions
+    );
+    const { ast } = result;
+    const tokens = ast.tokens || [];
+    const comments = ast.comments || [];
+    const references = analyzeExternalReferences(result, parserOptions);
+    const statement = ast.body[0];
+    const callExpression = statement.expression;
+    const expression = callExpression.arguments[0];
+    if (!allowEmpty && !expression) {
+      return throwEmptyError(locationCalculator, "an expression");
     }
-    if (!markSetupReferenceVariableAsUsed(node.rawName)) {
-      const dotIndex = node.rawName.indexOf(".");
-      if (dotIndex > 0) {
-        markSetupReferenceVariableAsUsed(
-          node.rawName.slice(0, dotIndex)
-        );
-      }
+    if (expression && expression.type === "SpreadElement") {
+      return throwUnexpectedTokenError("...", expression);
     }
-  }
-  function processVAttribute(node) {
-    if (node.directive) {
-      if (BUILTIN_DIRECTIVES.has(node.key.name.name)) {
-        return;
-      }
-      markSetupReferenceVariableAsUsed(`v-${node.key.name.rawName}`);
-    } else if (node.key.name === "ref" && node.value) {
-      markVariableAsUsed(node.value.value);
+    if (callExpression.arguments[1]) {
+      const node = callExpression.arguments[1];
+      return throwUnexpectedTokenError(
+        ",",
+        getCommaTokenBeforeNode(tokens, node) || node
+      );
     }
+    tokens.shift();
+    tokens.shift();
+    tokens.pop();
+    return { expression, tokens, comments, references, variables: [] };
+  } catch (err) {
+    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-  traverseNodes(templateRoot, {
-    enterNode(node) {
-      if (node.type === "VExpressionContainer") {
-        processVExpressionContainer(node);
-      } else if (node.type === "VElement") {
-        processVElement(node);
-      } else if (node.type === "VAttribute") {
-        processVAttribute(node);
-      }
-    },
-    leaveNode() {
-    }
-  });
 }
-
-// src/template/parser.ts
-var import_findLastIndex = __toESM(require_findLastIndex());
-var import_last3 = __toESM(require_last());
-var _assert = require('assert'); var _assert2 = _interopRequireDefault(_assert);
-
-// src/common/debug.ts
-var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
-var debug = _debug2.default.call(void 0, "vue-vine-eslint-parser");
-
-// src/common/location-calculator.ts
-var import_sortedLastIndex2 = __toESM(require_sortedLastIndex());
-
-// src/common/lines-and-columns.ts
-var import_sortedLastIndex = __toESM(require_sortedLastIndex());
-var LinesAndColumns = class {
-  
-  /**
-   * Initialize.
-   * @param ltOffsets The list of the offset of line terminators.
-   */
-  constructor(ltOffsets) {
-    this.ltOffsets = ltOffsets;
-  }
-  /**
-   * Calculate the location of the given index.
-   * @param index The index to calculate their location.
-   * @returns The location of the index.
-   */
-  getLocFromIndex(index) {
-    const line = (0, import_sortedLastIndex.default)(this.ltOffsets, index) + 1;
-    const column = index - (line === 1 ? 0 : this.ltOffsets[line - 2]);
-    return { line, column };
-  }
-  createOffsetLocationCalculator(offset) {
-    return {
-      getFixOffset() {
-        return offset;
-      },
-      getLocFromIndex: this.getLocFromIndex.bind(this)
+function parseFilter(code, locationCalculator, parserOptions) {
+  debug('[script] parse filter: "%s"', code);
+  try {
+    const expression = {
+      type: "VFilter",
+      parent: null,
+      range: [0, 0],
+      loc: {},
+      callee: null,
+      arguments: []
     };
+    const tokens = [];
+    const comments = [];
+    const references = [];
+    const paren = code.indexOf("(");
+    const calleeCode = paren === -1 ? code : code.slice(0, paren);
+    const argsCode = paren === -1 ? null : code.slice(paren);
+    if (calleeCode.trim()) {
+      const spaces = /^\s*/u.exec(calleeCode)[0];
+      const subCalculator = locationCalculator.getSubCalculatorShift(
+        spaces.length
+      );
+      const { ast } = parseScriptFragment(
+        `"${calleeCode.trim()}"`,
+        subCalculator,
+        parserOptions
+      );
+      const statement = ast.body[0];
+      const callee = statement.expression;
+      if (callee.type !== "Literal") {
+        const { loc, range } = ast.tokens[0];
+        return throwUnexpectedTokenError('"', {
+          range: [range[1] - 1, range[1]],
+          loc: {
+            start: {
+              line: loc.end.line,
+              column: loc.end.column - 1
+            },
+            end: loc.end
+          }
+        });
+      }
+      expression.callee = {
+        type: "Identifier",
+        parent: expression,
+        range: [
+          callee.range[0],
+          subCalculator.getOffsetWithGap(calleeCode.trim().length)
+        ],
+        loc: {
+          start: callee.loc.start,
+          end: subCalculator.getLocation(calleeCode.trim().length)
+        },
+        name: String(callee.value)
+      };
+      tokens.push({
+        type: "Identifier",
+        value: calleeCode.trim(),
+        range: expression.callee.range,
+        loc: expression.callee.loc
+      });
+    } else {
+      return throwEmptyError(locationCalculator, "a filter name");
+    }
+    if (argsCode != null) {
+      const result = parseScriptFragment(
+        `0${argsCode}`,
+        locationCalculator.getSubCalculatorAfter(paren).getSubCalculatorShift(-1),
+        parserOptions
+      );
+      const { ast } = result;
+      const statement = ast.body[0];
+      const callExpression = statement.expression;
+      ast.tokens.shift();
+      if (callExpression.type !== "CallExpression" || callExpression.callee.type !== "Literal") {
+        let nestCount = 1;
+        for (const token2 of ast.tokens.slice(1)) {
+          if (nestCount === 0) {
+            return throwUnexpectedTokenError(token2.value, token2);
+          }
+          if (token2.type === "Punctuator" && token2.value === "(") {
+            nestCount += 1;
+          }
+          if (token2.type === "Punctuator" && token2.value === ")") {
+            nestCount -= 1;
+          }
+        }
+        const token = (0, import_last.default)(ast.tokens);
+        return throwUnexpectedTokenError(token.value, token);
+      }
+      for (const argument of callExpression.arguments) {
+        argument.parent = expression;
+        expression.arguments.push(argument);
+      }
+      tokens.push(...ast.tokens);
+      comments.push(...ast.comments);
+      references.push(...analyzeExternalReferences(result, parserOptions));
+    }
+    const firstToken = tokens[0];
+    const lastToken = (0, import_last.default)(tokens);
+    expression.range = [firstToken.range[0], lastToken.range[1]];
+    expression.loc = { start: firstToken.loc.start, end: lastToken.loc.end };
+    return { expression, tokens, comments, references, variables: [] };
+  } catch (err) {
+    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-};
-
-// src/common/location-calculator.ts
-var LocationCalculatorForHtml = class _LocationCalculatorForHtml extends LinesAndColumns {
-  
-  
-  
-  
-  /**
-   * Initialize this calculator.
-   * @param gapOffsets The list of the offset of removed characters in tokenization phase.
-   * @param ltOffsets The list of the offset of line terminators.
-   * @param baseOffset The base offset to calculate locations.
-   * @param shiftOffset The shift offset to calculate locations.
-   */
-  constructor(gapOffsets, ltOffsets, baseOffset, shiftOffset = 0) {
-    super(ltOffsets);
-    this.gapOffsets = gapOffsets;
-    this.ltOffsets = ltOffsets;
-    this.baseOffset = baseOffset || 0;
-    this.baseIndexOfGap = this.baseOffset === 0 ? 0 : (0, import_sortedLastIndex2.default)(gapOffsets, this.baseOffset);
-    this.shiftOffset = shiftOffset;
-  }
-  /**
-   * Get sub calculator which have the given base offset.
-   * @param offset The base offset of new sub calculator.
-   * @returns Sub calculator.
-   */
-  getSubCalculatorAfter(offset) {
-    return new _LocationCalculatorForHtml(
-      this.gapOffsets,
-      this.ltOffsets,
-      this.baseOffset + offset,
-      this.shiftOffset
+}
+function loadParser(parser) {
+  if (parser !== "espree") {
+    const __require = createRequire(
+      typeof __filename ? __filename : fileURLToPath2(import.meta.url)
     );
+    return __require(parser);
   }
-  /**
-   * Get sub calculator that shifts the given offset.
-   * @param offset The shift of new sub calculator.
-   * @returns Sub calculator.
-   */
-  getSubCalculatorShift(offset) {
-    return new _LocationCalculatorForHtml(
-      this.gapOffsets,
-      this.ltOffsets,
-      this.baseOffset,
-      this.shiftOffset + offset
+  return getEspreeFromUser();
+}
+function parseScript(code, parserOptions) {
+  const parser = typeof parserOptions.parser === "string" ? loadParser(parserOptions.parser) : isParserObject(parserOptions.parser) ? parserOptions.parser : getEspreeFromEcmaVersion(parserOptions.ecmaVersion);
+  const result = isEnhancedParserObject(parser) ? parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
+  if (result.ast != null) {
+    return result;
+  }
+  return { ast: result };
+}
+function parseExpression(code, locationCalculator, parserOptions, { allowEmpty = false, allowFilters = false } = {}) {
+  debug('[script] parse expression: "%s"', code);
+  const [mainCode, ...filterCodes] = allowFilters ? splitFilters(code) : [code];
+  if (filterCodes.length === 0) {
+    return parseExpressionBody(
+      code,
+      locationCalculator,
+      parserOptions,
+      allowEmpty
     );
   }
-  /**
-   * Calculate gap at the given index.
-   * @param index The index to calculate gap.
-   */
-  _getGap(index) {
-    const offsets = this.gapOffsets;
-    let g0 = (0, import_sortedLastIndex2.default)(offsets, index + this.baseOffset);
-    let pos = index + this.baseOffset + g0 - this.baseIndexOfGap;
-    while (g0 < offsets.length && offsets[g0] <= pos) {
-      g0 += 1;
-      pos += 1;
+  const retB = parseExpressionBody(
+    mainCode,
+    locationCalculator,
+    parserOptions
+  );
+  if (!retB.expression) {
+    return retB;
+  }
+  const ret = retB;
+  ret.expression = {
+    type: "VFilterSequenceExpression",
+    parent: null,
+    expression: retB.expression,
+    filters: [],
+    range: retB.expression.range.slice(0),
+    loc: Object.assign({}, retB.expression.loc)
+  };
+  ret.expression.expression.parent = ret.expression;
+  let prevLoc = mainCode.length;
+  for (const filterCode of filterCodes) {
+    ret.tokens.push(
+      fixLocation(
+        {
+          type: "Punctuator",
+          value: "|",
+          range: [prevLoc, prevLoc + 1],
+          loc: {}
+        },
+        locationCalculator
+      )
+    );
+    const retF = parseFilter(
+      filterCode,
+      locationCalculator.getSubCalculatorShift(prevLoc + 1),
+      parserOptions
+    );
+    if (retF) {
+      if (retF.expression) {
+        ret.expression.filters.push(retF.expression);
+        retF.expression.parent = ret.expression;
+      }
+      ret.tokens.push(...retF.tokens);
+      ret.comments.push(...retF.comments);
+      ret.references.push(...retF.references);
     }
-    return g0 - this.baseIndexOfGap;
+    prevLoc += 1 + filterCode.length;
   }
-  /**
-   * Calculate the location of the given index.
-   * @param index The index to calculate their location.
-   * @returns The location of the index.
-   */
-  getLocation(index) {
-    return this.getLocFromIndex(this.getOffsetWithGap(index));
+  const lastToken = (0, import_last.default)(ret.tokens);
+  ret.expression.range[1] = lastToken.range[1];
+  ret.expression.loc.end = lastToken.loc.end;
+  return ret;
+}
+function parseVForExpression(code, locationCalculator, parserOptions) {
+  if (code.trim() === "") {
+    throwEmptyError(locationCalculator, "'<alias> in <expression>'");
   }
-  /**
-   * Calculate the offset of the given index.
-   * @param index The index to calculate their location.
-   * @returns The offset of the index.
-   */
-  getOffsetWithGap(index) {
-    return index + this.getFixOffset(index);
-  }
-  /**
-   * Gets the fix location offset of the given offset with using the base offset of this calculator.
-   * @param offset The offset to modify.
-   */
-  getFixOffset(offset) {
-    const shiftOffset = this.shiftOffset;
-    const gap = this._getGap(offset + shiftOffset);
-    return this.baseOffset + gap + shiftOffset;
-  }
-};
-
-// src/template/intermediate-tokenizer.ts
-var import_last = __toESM(require_last());
-
-var DUMMY_PARENT = Object.freeze({});
-function concat(text, token) {
-  return text + token.value;
-}
-var IntermediateTokenizer = class {
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  /**
-   * The source code text.
-   */
-  get text() {
-    return this.tokenizer.text;
-  }
-  /**
-   * The parse errors.
-   */
-  get errors() {
-    return this.tokenizer.errors;
-  }
-  /**
-   * The current state.
-   */
-  get state() {
-    return this.tokenizer.state;
-  }
-  set state(value) {
-    this.tokenizer.state = value;
-  }
-  /**
-   * The current namespace.
-   */
-  get namespace() {
-    return this.tokenizer.namespace;
-  }
-  set namespace(value) {
-    this.tokenizer.namespace = value;
-  }
-  /**
-   * The current flag of expression enabled.
-   */
-  get expressionEnabled() {
-    return this.tokenizer.expressionEnabled;
-  }
-  set expressionEnabled(value) {
-    this.tokenizer.expressionEnabled = value;
+  if (isEcmaVersion5(parserOptions)) {
+    return parseVForExpressionForEcmaVersion5(
+      code,
+      locationCalculator,
+      parserOptions
+    );
   }
-  /**
-   * Initialize this intermediate tokenizer.
-   * @param tokenizer The tokenizer.
-   */
-  constructor(tokenizer, parserOptions) {
-    this.tokenizer = tokenizer;
-    this.baseParserOptions = parserOptions;
-    this.currentToken = null;
-    this.attribute = null;
-    this.attributeNames = /* @__PURE__ */ new Set();
-    this.expressionStartToken = null;
-    this.expressionTokens = [];
-    this.tokens = [];
-    this.comments = [];
+  const processed = processVForAliasAndIterator(code);
+  if (!processed.aliases.trim()) {
+    return throwEmptyError(locationCalculator, "an alias");
   }
-  /**
-   * Get the next intermediate token.
-   * @returns The intermediate token or null.
-   */
-  nextToken() {
-    let token = null;
-    let result = null;
-    while (result == null) {
-      token = this.tokenizer.nextToken();
-      if (token == null) {
-        break;
-      }
-      result = this[token.type](token);
+  try {
+    debug(
+      '[script] parse v-for expression: "for(%s%s%s);"',
+      processed.aliasesWithBrackets,
+      processed.delimiter,
+      processed.iterator
+    );
+    const result = parseScriptFragment(
+      `for(let ${processed.aliasesWithBrackets}${processed.delimiter}${processed.iterator});`,
+      locationCalculator.getSubCalculatorShift(
+        processed.hasParens ? -8 : -9
+      ),
+      parserOptions
+    );
+    const { ast } = result;
+    const tokens = ast.tokens || [];
+    const comments = ast.comments || [];
+    const scope = analyzeVariablesAndExternalReferences(
+      result,
+      "v-for",
+      parserOptions
+    );
+    const references = scope.references;
+    const variables = scope.variables;
+    const statement = ast.body[0];
+    const varDecl = statement.left;
+    const id = varDecl.declarations[0].id;
+    const left = id.elements;
+    const right = statement.right;
+    if (!processed.hasParens && !left.length) {
+      return throwEmptyError(locationCalculator, "an alias");
     }
-    if (result == null && token == null && this.currentToken != null) {
-      result = this.commit();
+    tokens.shift();
+    tokens.shift();
+    tokens.shift();
+    tokens.pop();
+    tokens.pop();
+    const closeOffset = statement.left.range[1] - 1;
+    const closeIndex = tokens.findIndex((t) => t.range[0] === closeOffset);
+    if (processed.hasParens) {
+      const open = tokens[0];
+      if (open != null) {
+        open.value = "(";
+      }
+      const close = tokens[closeIndex];
+      if (close != null) {
+        close.value = ")";
+      }
+    } else {
+      tokens.splice(closeIndex, 1);
+      tokens.shift();
     }
-    return result;
-  }
-  /**
-   * Commit the current token.
-   */
-  commit() {
-    _assert2.default.call(void 0, this.currentToken != null || this.expressionStartToken != null);
-    let token = this.currentToken;
-    this.currentToken = null;
-    this.attribute = null;
-    if (this.expressionStartToken != null) {
-      const start = this.expressionStartToken;
-      const end = (0, import_last.default)(this.expressionTokens) || start;
-      const value = this.expressionTokens.reduce(concat, start.value);
-      this.expressionStartToken = null;
-      this.expressionTokens = [];
-      if (token == null) {
-        token = {
-          type: "Text",
-          range: [start.range[0], end.range[1]],
-          loc: { start: start.loc.start, end: end.loc.end },
-          value
-        };
-      } else if (token.type === "Text") {
-        token.range[1] = end.range[1];
-        token.loc.end = end.loc.end;
-        token.value += value;
-      } else {
-        throw new Error("unreachable");
+    const firstToken = tokens[0] || statement.left;
+    const lastToken = tokens[tokens.length - 1] || statement.right;
+    const expression = {
+      type: "VForExpression",
+      range: [firstToken.range[0], lastToken.range[1]],
+      loc: { start: firstToken.loc.start, end: lastToken.loc.end },
+      parent: DUMMY_PARENT,
+      left,
+      right
+    };
+    for (const l of left) {
+      if (l != null) {
+        l.parent = expression;
       }
     }
-    return token;
+    right.parent = expression;
+    return { expression, tokens, comments, references, variables };
+  } catch (err) {
+    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-  /**
-   * Report an invalid character error.
-   * @param token The invalid token.
-   * @param code The error code.
-   */
-  reportParseError(token, code) {
-    const error = ParseError.fromCode(
-      code,
-      token.range[0],
-      token.loc.start.line,
-      token.loc.start.column
-    );
-    this.errors.push(error);
-    debug("[html] syntax error:", error.message);
+}
+function isEcmaVersion5(parserOptions) {
+  const ecmaVersion = getEcmaVersionIfUseEspree(parserOptions);
+  return ecmaVersion != null && ecmaVersion <= 5;
+}
+function parseVForExpressionForEcmaVersion5(code, locationCalculator, parserOptions) {
+  const processed = processVForAliasAndIterator(code);
+  if (!processed.aliases.trim()) {
+    return throwEmptyError(locationCalculator, "an alias");
   }
-  /**
-   * Process the given comment token.
-   * @param token The comment token to process.
-   */
-  processComment(token) {
-    this.comments.push(token);
-    if (this.currentToken != null && this.currentToken.type === "Text") {
-      return this.commit();
+  try {
+    const tokens = [];
+    const comments = [];
+    const parsedAliases = parseVForAliasesForEcmaVersion5(
+      processed.aliasesWithBrackets,
+      locationCalculator.getSubCalculatorShift(
+        processed.hasParens ? 0 : -1
+      ),
+      parserOptions
+    );
+    if (processed.hasParens) {
+      const open = parsedAliases.tokens[0];
+      if (open != null) {
+        open.value = "(";
+      }
+      const close = (0, import_last.default)(parsedAliases.tokens);
+      if (close != null) {
+        close.value = ")";
+      }
+    } else {
+      parsedAliases.tokens.shift();
+      parsedAliases.tokens.pop();
     }
-    return null;
-  }
-  /**
-   * Process the given text token.
-   * @param token The text token to process.
-   */
-  processText(token) {
-    this.tokens.push(token);
-    let result = null;
-    if (this.expressionStartToken != null) {
-      const lastToken = (0, import_last.default)(this.expressionTokens) || this.expressionStartToken;
-      if (lastToken.range[1] === token.range[0]) {
-        this.expressionTokens.push(token);
-        return null;
-      }
-      result = this.commit();
-    } else if (this.currentToken != null) {
-      if (this.currentToken.type === "Text" && this.currentToken.range[1] === token.range[0]) {
-        this.currentToken.value += token.value;
-        this.currentToken.range[1] = token.range[1];
-        this.currentToken.loc.end = token.loc.end;
-        return null;
-      }
-      result = this.commit();
+    tokens.push(...parsedAliases.tokens);
+    comments.push(...parsedAliases.comments);
+    const { left, variables } = parsedAliases;
+    if (!processed.hasParens && !left.length) {
+      return throwEmptyError(locationCalculator, "an alias");
     }
-    _assert2.default.call(void 0, this.currentToken == null);
-    this.currentToken = {
-      type: "Text",
-      range: [token.range[0], token.range[1]],
-      loc: { start: token.loc.start, end: token.loc.end },
-      value: token.value
+    const delimiterStart = processed.aliases.length;
+    const delimiterEnd = delimiterStart + processed.delimiter.length;
+    tokens.push(
+      fixLocation(
+        {
+          type: processed.delimiter === "in" ? "Keyword" : "Identifier",
+          value: processed.delimiter,
+          start: delimiterStart,
+          end: delimiterEnd,
+          loc: {},
+          range: [delimiterStart, delimiterEnd]
+        },
+        locationCalculator
+      )
+    );
+    const parsedIterator = parseVForIteratorForEcmaVersion5(
+      processed.iterator,
+      locationCalculator.getSubCalculatorShift(delimiterEnd),
+      parserOptions
+    );
+    tokens.push(...parsedIterator.tokens);
+    comments.push(...parsedIterator.comments);
+    const { right, references } = parsedIterator;
+    const firstToken = tokens[0];
+    const lastToken = (0, import_last.default)(tokens) || firstToken;
+    const expression = {
+      type: "VForExpression",
+      range: [firstToken.range[0], lastToken.range[1]],
+      loc: { start: firstToken.loc.start, end: lastToken.loc.end },
+      parent: DUMMY_PARENT,
+      left,
+      right
     };
-    return result;
+    for (const l of left) {
+      if (l != null) {
+        l.parent = expression;
+      }
+    }
+    right.parent = expression;
+    return { expression, tokens, comments, references, variables };
+  } catch (err) {
+    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-  /**
-   * Process a HTMLAssociation token.
-   * @param token The token to process.
-   */
-  HTMLAssociation(token) {
-    this.tokens.push(token);
-    if (this.attribute != null) {
-      this.attribute.range[1] = token.range[1];
-      this.attribute.loc.end = token.loc.end;
-      if (this.currentToken == null || this.currentToken.type !== "StartTag") {
-        throw new Error("unreachable");
+}
+function parseVForAliasesForEcmaVersion5(code, locationCalculator, parserOptions) {
+  const result = parseScriptFragment(
+    `0(${code})`,
+    locationCalculator.getSubCalculatorShift(-2),
+    parserOptions
+  );
+  const { ast } = result;
+  const tokens = ast.tokens || [];
+  const comments = ast.comments || [];
+  const variables = analyzeExternalReferences(result, parserOptions).map(
+    transformVariable2
+  );
+  const statement = ast.body[0];
+  const callExpression = statement.expression;
+  const expression = callExpression.arguments[0];
+  const left = expression.elements.filter(
+    (e) => {
+      if (e == null || e.type === "Identifier") {
+        return true;
       }
-      this.currentToken.range[1] = token.range[1];
-      this.currentToken.loc.end = token.loc.end;
+      const errorToken = tokens.find(
+        (t) => e.range[0] <= t.range[0] && t.range[1] <= e.range[1]
+      );
+      return throwUnexpectedTokenError(errorToken.value, errorToken);
     }
-    return null;
+  );
+  tokens.shift();
+  tokens.shift();
+  tokens.pop();
+  return { left, tokens, comments, variables };
+  function transformVariable2(reference) {
+    const ret = {
+      id: reference.id,
+      kind: "v-for",
+      references: []
+    };
+    Object.defineProperty(ret, "references", { enumerable: false });
+    return ret;
   }
-  /**
-   * Process a HTMLBogusComment token.
-   * @param token The token to process.
-   */
-  HTMLBogusComment(token) {
-    return this.processComment(token);
+}
+function parseVForIteratorForEcmaVersion5(code, locationCalculator, parserOptions) {
+  const result = parseScriptFragment(
+    `0(${code})`,
+    locationCalculator.getSubCalculatorShift(-2),
+    parserOptions
+  );
+  const { ast } = result;
+  const tokens = ast.tokens || [];
+  const comments = ast.comments || [];
+  const references = analyzeExternalReferences(result, parserOptions);
+  const statement = ast.body[0];
+  const callExpression = statement.expression;
+  const expression = callExpression.arguments[0];
+  if (!expression) {
+    return throwEmptyError(locationCalculator, "an expression");
   }
-  /**
-   * Process a HTMLCDataText token.
-   * @param token The token to process.
-   */
-  HTMLCDataText(token) {
-    return this.processText(token);
+  if (expression && expression.type === "SpreadElement") {
+    return throwUnexpectedTokenError("...", expression);
   }
-  /**
-   * Process a HTMLComment token.
-   * @param token The token to process.
-   */
-  HTMLComment(token) {
-    return this.processComment(token);
+  const right = expression;
+  tokens.shift();
+  tokens.shift();
+  tokens.pop();
+  return { right, tokens, comments, references };
+}
+function parseVOnExpression(code, locationCalculator, parserOptions) {
+  if (IS_FUNCTION_EXPRESSION.test(code) || IS_SIMPLE_PATH.test(code)) {
+    return parseExpressionBody(
+      code,
+      locationCalculator,
+      parserOptions
+    );
   }
-  /**
-   * Process a HTMLEndTagOpen token.
-   * @param token The token to process.
-   */
-  HTMLEndTagOpen(token) {
-    this.tokens.push(token);
-    let result = null;
-    if (this.currentToken != null || this.expressionStartToken != null) {
-      result = this.commit();
-    }
-    this.currentToken = {
-      type: "EndTag",
-      range: [token.range[0], token.range[1]],
-      loc: { start: token.loc.start, end: token.loc.end },
-      name: token.value
-    };
-    return result;
+  return parseVOnExpressionBody(
+    code,
+    locationCalculator,
+    parserOptions
+  );
+}
+function parseVOnExpressionBody(code, locationCalculator, parserOptions) {
+  debug('[script] parse v-on expression: "void function($event){%s}"', code);
+  if (code.trim() === "") {
+    throwEmptyError(locationCalculator, "statements");
   }
-  /**
-   * Process a HTMLIdentifier token.
-   * @param token The token to process.
-   */
-  HTMLIdentifier(token) {
-    this.tokens.push(token);
-    if (this.currentToken == null || this.currentToken.type === "Text" || this.currentToken.type === "Mustache") {
-      throw new Error("unreachable");
-    }
-    if (this.currentToken.type === "EndTag") {
-      this.reportParseError(token, "end-tag-with-attributes");
-      return null;
-    }
-    if (this.attributeNames.has(token.value)) {
-      this.reportParseError(token, "duplicate-attribute");
-    }
-    this.attributeNames.add(token.value);
-    this.attribute = {
-      type: "VAttribute",
-      range: [token.range[0], token.range[1]],
-      loc: { start: token.loc.start, end: token.loc.end },
-      parent: DUMMY_PARENT,
-      directive: false,
-      key: {
-        type: "VIdentifier",
-        range: [token.range[0], token.range[1]],
-        loc: { start: token.loc.start, end: token.loc.end },
-        parent: DUMMY_PARENT,
-        name: token.value,
-        rawName: this.text.slice(token.range[0], token.range[1])
+  try {
+    const result = parseScriptFragment(
+      `void function($event){${code}}`,
+      locationCalculator.getSubCalculatorShift(-22),
+      parserOptions
+    );
+    const { ast } = result;
+    const references = analyzeExternalReferences(result, parserOptions);
+    const outermostStatement = ast.body[0];
+    const functionDecl = outermostStatement.expression.argument;
+    const block = functionDecl.body;
+    const body = block.body;
+    const firstStatement = (0, import_first.default)(body);
+    const lastStatement = (0, import_last.default)(body);
+    const expression = {
+      type: "VOnExpression",
+      range: [
+        firstStatement != null ? firstStatement.range[0] : block.range[0] + 1,
+        lastStatement != null ? lastStatement.range[1] : block.range[1] - 1
+      ],
+      loc: {
+        start: firstStatement != null ? firstStatement.loc.start : locationCalculator.getLocation(1),
+        end: lastStatement != null ? lastStatement.loc.end : locationCalculator.getLocation(code.length + 1)
       },
-      value: null
+      parent: DUMMY_PARENT,
+      body
     };
-    this.attribute.key.parent = this.attribute;
-    this.currentToken.range[1] = token.range[1];
-    this.currentToken.loc.end = token.loc.end;
-    this.currentToken.attributes.push(this.attribute);
-    return null;
-  }
-  /**
-   * Process a HTMLLiteral token.
-   * @param token The token to process.
-   */
-  HTMLLiteral(token) {
-    this.tokens.push(token);
-    if (this.attribute != null) {
-      this.attribute.range[1] = token.range[1];
-      this.attribute.loc.end = token.loc.end;
-      this.attribute.value = {
-        type: "VLiteral",
-        range: [token.range[0], token.range[1]],
-        loc: { start: token.loc.start, end: token.loc.end },
-        parent: this.attribute,
-        value: token.value
-      };
-      if (this.currentToken == null || this.currentToken.type !== "StartTag") {
-        throw new Error("unreachable");
-      }
-      this.currentToken.range[1] = token.range[1];
-      this.currentToken.loc.end = token.loc.end;
+    const tokens = ast.tokens || [];
+    const comments = ast.comments || [];
+    for (const b of body) {
+      b.parent = expression;
     }
-    return null;
-  }
-  /**
-   * Process a HTMLRCDataText token.
-   * @param token The token to process.
-   */
-  HTMLRCDataText(token) {
-    return this.processText(token);
+    tokens.splice(0, 6);
+    tokens.pop();
+    return { expression, tokens, comments, references, variables: [] };
+  } catch (err) {
+    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-  /**
-   * Process a HTMLRawText token.
-   * @param token The token to process.
-   */
-  HTMLRawText(token) {
-    return this.processText(token);
+}
+function parseSlotScopeExpression(code, locationCalculator, parserOptions) {
+  debug('[script] parse slot-scope expression: "void function(%s) {}"', code);
+  if (code.trim() === "") {
+    throwEmptyError(
+      locationCalculator,
+      "an identifier or an array/object pattern"
+    );
   }
-  /**
-   * Process a HTMLSelfClosingTagClose token.
-   * @param token The token to process.
-   */
-  HTMLSelfClosingTagClose(token) {
-    this.tokens.push(token);
-    if (this.currentToken == null || this.currentToken.type === "Text") {
-      throw new Error("unreachable");
+  try {
+    const result = parseScriptFragment(
+      `void function(${code}) {}`,
+      locationCalculator.getSubCalculatorShift(-14),
+      parserOptions
+    );
+    const { ast } = result;
+    const statement = ast.body[0];
+    const rawExpression = statement.expression;
+    const functionDecl = rawExpression.argument;
+    const params = functionDecl.params;
+    if (params.length === 0) {
+      return {
+        expression: null,
+        tokens: [],
+        comments: [],
+        references: [],
+        variables: []
+      };
     }
-    if (this.currentToken.type === "StartTag") {
-      this.currentToken.selfClosing = true;
-    } else {
-      this.reportParseError(token, "end-tag-with-trailing-solidus");
+    const tokens = ast.tokens || [];
+    const comments = ast.comments || [];
+    const scope = analyzeVariablesAndExternalReferences(
+      result,
+      "scope",
+      parserOptions
+    );
+    const references = scope.references;
+    const variables = scope.variables;
+    const firstParam = (0, import_first.default)(params);
+    const lastParam = (0, import_last.default)(params);
+    const expression = {
+      type: "VSlotScopeExpression",
+      range: [firstParam.range[0], lastParam.range[1]],
+      loc: { start: firstParam.loc.start, end: lastParam.loc.end },
+      parent: DUMMY_PARENT,
+      params: functionDecl.params
+    };
+    for (const param of params) {
+      param.parent = expression;
     }
-    this.currentToken.range[1] = token.range[1];
-    this.currentToken.loc.end = token.loc.end;
-    return this.commit();
+    tokens.shift();
+    tokens.shift();
+    tokens.shift();
+    tokens.pop();
+    tokens.pop();
+    tokens.pop();
+    return { expression, tokens, comments, references, variables };
+  } catch (err) {
+    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-  /**
-   * Process a HTMLTagClose token.
-   * @param token The token to process.
-   */
-  HTMLTagClose(token) {
-    this.tokens.push(token);
-    if (this.currentToken == null || this.currentToken.type === "Text") {
-      throw new Error("unreachable");
-    }
-    this.currentToken.range[1] = token.range[1];
-    this.currentToken.loc.end = token.loc.end;
-    return this.commit();
+}
+
+// src/template/utils/index.ts
+var shorthandSign = /^[.:@#]/u;
+var shorthandNameMap = { ":": "bind", ".": "bind", "@": "on", "#": "slot" };
+var invalidDynamicArgumentNextChar = /^[\s=/>]$/u;
+function camelize(str) {
+  return str.replace(/-(\w)/gu, (_, c) => c ? c.toUpperCase() : "");
+}
+function isPropModifier(node) {
+  return node.name === "prop";
+}
+function isNotEmptyModifier(node) {
+  return node.name !== "";
+}
+function getStandardDirectiveKind(element, directiveKey) {
+  const directiveName = directiveKey.name.name;
+  if (directiveName === "for") {
+    return "for";
+  } else if (directiveName === "on") {
+    return "on";
+  } else if (directiveName === "slot" || directiveName === "slot-scope" || directiveName === "scope" && element.rawName === "template") {
+    return "slot";
+  } else if (directiveName === "bind") {
+    return "bind";
   }
-  /**
-   * Process a HTMLTagOpen token.
-   * @param token The token to process.
-   */
-  HTMLTagOpen(token) {
-    this.tokens.push(token);
-    let result = null;
-    if (this.currentToken != null || this.expressionStartToken != null) {
-      result = this.commit();
-    }
-    this.currentToken = {
-      type: "StartTag",
-      range: [token.range[0], token.range[1]],
-      loc: { start: token.loc.start, end: token.loc.end },
-      name: token.value,
-      rawName: this.text.slice(token.range[0] + 1, token.range[1]),
-      selfClosing: false,
-      attributes: []
+  return null;
+}
+function parseAttributeValue(code, parserOptions, globalLocationCalculator, node, element, directiveKey) {
+  const firstChar = code[node.range[0]];
+  const quoted = firstChar === '"' || firstChar === "'";
+  const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(
+    node.range[0] + (quoted ? 1 : 0)
+  );
+  const directiveKind = getStandardDirectiveKind(
+    element,
+    directiveKey
+  );
+  let result;
+  if (quoted && node.value === "") {
+    result = {
+      expression: null,
+      tokens: [],
+      comments: [],
+      variables: [],
+      references: []
     };
-    this.attribute = null;
-    this.attributeNames.clear();
-    return result;
-  }
-  /**
-   * Process a HTMLText token.
-   * @param token The token to process.
-   */
-  HTMLText(token) {
-    return this.processText(token);
-  }
-  /**
-   * Process a HTMLWhitespace token.
-   * @param token The token to process.
-   */
-  HTMLWhitespace(token) {
-    return this.processText(token);
-  }
-  /**
-   * Process a VExpressionStart token.
-   * @param token The token to process.
-   */
-  VExpressionStart(token) {
-    if (this.expressionStartToken != null) {
-      return this.processText(token);
-    }
-    const separated = this.currentToken != null && this.currentToken.range[1] !== token.range[0];
-    const result = separated ? this.commit() : null;
-    this.tokens.push(token);
-    this.expressionStartToken = token;
-    return result;
+  } else if (directiveKind === "for") {
+    result = parseVForExpression(
+      node.value,
+      locationCalculator,
+      parserOptions
+    );
+  } else if (directiveKind === "on" && directiveKey.argument != null) {
+    result = parseVOnExpression(
+      node.value,
+      locationCalculator,
+      parserOptions
+    );
+  } else if (directiveKind === "slot") {
+    result = parseSlotScopeExpression(
+      node.value,
+      locationCalculator,
+      parserOptions
+    );
+  } else if (directiveKind === "bind") {
+    result = parseExpression(
+      node.value,
+      locationCalculator,
+      parserOptions,
+      { allowFilters: true }
+    );
+  } else {
+    result = parseExpression(
+      node.value,
+      locationCalculator,
+      parserOptions
+    );
   }
-  /**
-   * Process a VExpressionEnd token.
-   * @param token The token to process.
-   */
-  VExpressionEnd(token) {
-    if (this.expressionStartToken == null) {
-      return this.processText(token);
-    }
-    const start = this.expressionStartToken;
-    const end = (0, import_last.default)(this.expressionTokens) || start;
-    if (token.range[0] === start.range[1]) {
-      this.tokens.pop();
-      this.expressionStartToken = null;
-      const result2 = this.processText(start);
-      this.processText(token);
-      return result2;
-    }
-    if (end.range[1] !== token.range[0]) {
-      const result2 = this.commit();
-      this.processText(token);
-      return result2;
-    }
-    const value = this.expressionTokens.reduce(concat, "");
-    this.tokens.push(token);
-    this.expressionStartToken = null;
-    this.expressionTokens = [];
-    const result = this.currentToken != null ? this.commit() : null;
-    this.currentToken = {
-      type: "Mustache",
-      range: [start.range[0], token.range[1]],
-      loc: { start: start.loc.start, end: token.loc.end },
-      value,
-      startToken: start,
-      endToken: token
-    };
-    return result || this.commit();
+  if (quoted) {
+    result.tokens.unshift(
+      createSimpleToken(
+        "Punctuator",
+        node.range[0],
+        node.range[0] + 1,
+        firstChar,
+        globalLocationCalculator
+      )
+    );
+    result.tokens.push(
+      createSimpleToken(
+        "Punctuator",
+        node.range[1] - 1,
+        node.range[1],
+        firstChar,
+        globalLocationCalculator
+      )
+    );
   }
-};
-
-// src/common/error-utils.ts
-function insertError(templateMeta, error) {
-  const index = templateMeta.errors.findIndex((e) => e.index === error.index);
-  templateMeta.errors.splice(index, 0, error);
+  return result;
 }
-
-// src/common/token-utils.ts
-function createSimpleToken(type, start, end, value, linesAndColumns) {
-  return {
-    type,
-    range: [start, end],
+function parseDirectiveKeyStatically(node, templateMeta) {
+  const {
+    name: text,
+    rawName: rawText,
+    range: [offset],
     loc: {
-      start: linesAndColumns.getLocFromIndex(start),
-      end: linesAndColumns.getLocFromIndex(end)
-    },
-    value
+      start: { column, line }
+    }
+  } = node;
+  const directiveKey = {
+    type: "VDirectiveKey",
+    range: node.range,
+    loc: node.loc,
+    parent: node.parent,
+    name: null,
+    argument: null,
+    modifiers: []
   };
-}
-function insertComments(templateMeta, newComments) {
-  if (newComments.length === 0) {
-    return;
+  let i = 0;
+  function createIdentifier(start, end, name) {
+    const id = {
+      type: "VIdentifier",
+      parent: directiveKey,
+      range: [offset + start, offset + end],
+      loc: {
+        start: { column: column + start, line },
+        end: { column: column + end, line }
+      },
+      name: name || text.slice(start, end),
+      rawName: rawText.slice(start, end)
+    };
+    return id;
   }
-  const index = templateMeta.comments.findIndex((comment) => comment.range[0] === newComments[0].range[0]);
-  templateMeta.comments.splice(index, 0, ...newComments);
-}
-function replaceTokens(templateMeta, node, newTokens) {
-  const index = templateMeta.tokens.findIndex((token) => token.range[0] === node.range[0]);
-  const count = templateMeta.tokens.findIndex((token) => token.range[1] === node.range[1]) - index + 1;
-  templateMeta.tokens.splice(index, count, ...newTokens);
-}
-
-// src/script/index.ts
-var import_first = __toESM(require_first());
-var import_last2 = __toESM(require_last());
-var import_sortedIndexBy = __toESM(require_sortedIndexBy());
-
-
-// src/common/fix-locations.ts
-function fixLocations(result, locationCalculator) {
-  fixNodeLocations(result.ast, result.visitorKeys, locationCalculator);
-  for (const token of result.ast.tokens || []) {
-    fixLocation(token, locationCalculator);
+  if (shorthandSign.test(text)) {
+    const sign = text[0];
+    directiveKey.name = createIdentifier(0, 1, shorthandNameMap[sign]);
+    i = 1;
+  } else {
+    const colon = text.indexOf(":");
+    if (colon !== -1) {
+      directiveKey.name = createIdentifier(0, colon);
+      i = colon + 1;
+    }
   }
-  for (const comment of result.ast.comments || []) {
-    fixLocation(comment, locationCalculator);
+  if (directiveKey.name != null && text[i] === "[") {
+    const len = text.slice(i).lastIndexOf("]");
+    if (len !== -1) {
+      directiveKey.argument = createIdentifier(i, i + len + 1);
+      i = i + len + 1 + (text[i + len + 1] === "." ? 1 : 0);
+    }
   }
-}
-function fixNodeLocations(rootNode, visitorKeys, locationCalculator) {
-  const traversed = /* @__PURE__ */ new Map();
-  traverseNodes(rootNode, {
-    visitorKeys,
-    enterNode(node, parent) {
-      if (!traversed.has(node)) {
-        traversed.set(node, node);
-        node.parent = parent;
-        if (traversed.has(node.range)) {
-          if (!traversed.has(node.loc)) {
-            node.loc.start = locationCalculator.getLocFromIndex(
-              node.range[0]
-            );
-            node.loc.end = locationCalculator.getLocFromIndex(
-              node.range[1]
-            );
-            traversed.set(node.loc, node);
-          } else if (node.start != null || node.end != null) {
-            const traversedNode = traversed.get(node.range);
-            if (traversedNode.type === node.type) {
-              node.start = traversedNode.start;
-              node.end = traversedNode.end;
-            }
-          }
-        } else {
-          fixLocation(node, locationCalculator);
-          traversed.set(node.range, node);
-          traversed.set(node.loc, node);
-        }
-      }
-    },
-    leaveNode() {
+  const modifiers = text.slice(i).split(".").map((modifierName) => {
+    const modifier = createIdentifier(i, i + modifierName.length);
+    if (modifierName === "" && i < text.length) {
+      insertError(
+        templateMeta,
+        new ParseError(
+          `Unexpected token '${text[i]}'`,
+          void 0,
+          offset + i,
+          line,
+          column + i
+        )
+      );
     }
+    i += modifierName.length + 1;
+    return modifier;
   });
-}
-function fixLocation(node, locationCalculator) {
-  const range = node.range;
-  const loc = node.loc;
-  const d0 = locationCalculator.getFixOffset(range[0], "start");
-  const d1 = locationCalculator.getFixOffset(range[1], "end");
-  if (d0 !== 0) {
-    range[0] += d0;
-    if (node.start != null) {
-      node.start += d0;
-    }
-    loc.start = locationCalculator.getLocFromIndex(range[0]);
+  if (directiveKey.name == null) {
+    directiveKey.name = modifiers.shift();
+  } else if (directiveKey.argument == null && modifiers[0].name !== "") {
+    directiveKey.argument = modifiers.shift() || null;
   }
-  if (d1 !== 0) {
-    range[1] += d1;
-    if (node.end != null) {
-      node.end += d0;
-    }
-    loc.end = locationCalculator.getLocFromIndex(range[1]);
+  directiveKey.modifiers = modifiers.filter(isNotEmptyModifier);
+  if (directiveKey.name.name === "v-") {
+    insertError(
+      templateMeta,
+      new ParseError(
+        `Unexpected token '${text[directiveKey.name.range[1] - offset]}'`,
+        void 0,
+        directiveKey.name.range[1],
+        directiveKey.name.loc.end.line,
+        directiveKey.name.loc.end.column
+      )
+    );
   }
-  return node;
-}
-function fixErrorLocation(error, locationCalculator) {
-  const diff = locationCalculator.getFixOffset(error.index, "start");
-  error.index += diff;
-  const loc = locationCalculator.getLocFromIndex(error.index);
-  error.lineNumber = loc.line;
-  error.column = loc.column;
-}
-
-// src/common/parser-object.ts
-function isParserObject(value) {
-  return isEnhancedParserObject(value) || isBasicParserObject(value);
-}
-function isEnhancedParserObject(value) {
-  return Boolean(value && typeof value.parseForESLint === "function");
-}
-function isBasicParserObject(value) {
-  return Boolean(value && typeof value.parse === "function");
-}
-
-// src/script/index.ts
-var ALIAS_ITERATOR = /^([\s\S]*?(?:\s|\)))(\bin\b|\bof\b)([\s\S]*)$/u;
-var PARENS = /^(\s*\()([\s\S]*?)(\)\s*)$/u;
-var DUMMY_PARENT2 = {};
-var IS_FUNCTION_EXPRESSION = /^\s*(?:[\w$]+|\([^)]*\))\s*=>|^function\s*\(/u;
-var IS_SIMPLE_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*'\]|\["[^"]*"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/u;
-function processVForAliasAndIterator(code) {
-  const match = ALIAS_ITERATOR.exec(code);
-  if (match != null) {
-    const aliases = match[1];
-    const parenMatch = PARENS.exec(aliases);
-    return {
-      aliases,
-      hasParens: Boolean(parenMatch),
-      aliasesWithBrackets: parenMatch ? `${parenMatch[1].slice(0, -1)}[${parenMatch[2]}]${parenMatch[3].slice(1)}` : `[${aliases.slice(0, -1)}]`,
-      delimiter: match[2] || "",
-      iterator: match[3]
-    };
+  if (directiveKey.name.rawName === "." && !directiveKey.modifiers.some(isPropModifier)) {
+    const pos = (directiveKey.argument || directiveKey.name).range[1] - offset;
+    const propModifier = createIdentifier(pos, pos, "prop");
+    directiveKey.modifiers.unshift(propModifier);
   }
-  return {
-    aliases: "",
-    hasParens: false,
-    aliasesWithBrackets: "",
-    delimiter: "",
-    iterator: code
-  };
+  return directiveKey;
 }
-function getCommaTokenBeforeNode(tokens, node) {
-  let tokenIndex = (0, import_sortedIndexBy.default)(
-    tokens,
-    { range: node.range },
-    (t) => t.range[0]
-  );
-  while (tokenIndex >= 0) {
-    const token = tokens[tokenIndex];
-    if (token.type === "Punctuator" && token.value === ",") {
-      return token;
+function parseDirectiveKeyTokens(node) {
+  const { name, argument, modifiers } = node;
+  const shorthand = name.range[1] - name.range[0] === 1;
+  const tokens = [];
+  if (shorthand) {
+    tokens.push({
+      type: "Punctuator",
+      range: name.range,
+      loc: name.loc,
+      value: name.rawName
+    });
+  } else {
+    tokens.push({
+      type: "HTMLIdentifier",
+      range: name.range,
+      loc: name.loc,
+      value: name.rawName
+    });
+    if (argument) {
+      tokens.push({
+        type: "Punctuator",
+        range: [name.range[1], argument.range[0]],
+        loc: { start: name.loc.end, end: argument.loc.start },
+        value: ":"
+      });
     }
-    tokenIndex -= 1;
   }
-  return null;
-}
-function throwEmptyError(locationCalculator, expected) {
-  const loc = locationCalculator.getLocation(0);
-  const err = new ParseError(
-    `Expected to be ${expected}, but got empty.`,
-    void 0,
-    0,
-    loc.line,
-    loc.column
-  );
-  fixErrorLocation(err, locationCalculator);
-  throw err;
-}
-function throwUnexpectedTokenError(name, token) {
-  const err = new ParseError(
-    `Unexpected token '${name}'.`,
-    void 0,
-    token.range[0],
-    token.loc.start.line,
-    token.loc.start.column
-  );
-  throw err;
-}
-function throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator) {
-  if (ParseError.isParseError(err)) {
-    const endOffset = locationCalculator.getOffsetWithGap(code.length);
-    if (err.index >= endOffset) {
-      err.message = "Unexpected end of expression.";
+  if (argument) {
+    tokens.push({
+      type: "HTMLIdentifier",
+      range: argument.range,
+      loc: argument.loc,
+      value: argument.rawName
+    });
+  }
+  let lastNode = argument || name;
+  for (const modifier of modifiers) {
+    if (modifier.rawName === "") {
+      continue;
     }
+    tokens.push(
+      {
+        type: "Punctuator",
+        range: [lastNode.range[1], modifier.range[0]],
+        loc: { start: lastNode.loc.end, end: modifier.loc.start },
+        value: "."
+      },
+      {
+        type: "HTMLIdentifier",
+        range: modifier.range,
+        loc: modifier.loc,
+        value: modifier.rawName
+      }
+    );
+    lastNode = modifier;
   }
-  throw err;
+  return tokens;
 }
-function parseScriptFragment(code, locationCalculator, parserOptions) {
+function convertDynamicArgument(node, templateMeta, parserOptions, locationCalculator) {
+  const { argument } = node;
+  if (!(argument != null && argument.type === "VIdentifier" && argument.name.startsWith("[") && argument.name.endsWith("]"))) {
+    return;
+  }
+  const { rawName, range, loc } = argument;
   try {
-    const result = parseScript(
-      code,
+    const { comments, expression, references, tokens } = parseExpression(
+      rawName.slice(1, -1),
+      locationCalculator.getSubCalculatorAfter(range[0] + 1),
       parserOptions
     );
-    fixLocations(result, locationCalculator);
-    return result;
-  } catch (err) {
-    const perr = ParseError.normalize(err);
-    if (perr) {
-      fixErrorLocation(perr, locationCalculator);
-      throw perr;
+    node.argument = {
+      type: "VExpressionContainer",
+      range,
+      loc,
+      parent: node,
+      expression,
+      references
+    };
+    if (expression != null) {
+      expression.parent = node.argument;
+    }
+    tokens.unshift(
+      createSimpleToken(
+        "Punctuator",
+        range[0],
+        range[0] + 1,
+        "[",
+        locationCalculator
+      )
+    );
+    tokens.push(
+      createSimpleToken(
+        "Punctuator",
+        range[1] - 1,
+        range[1],
+        "]",
+        locationCalculator
+      )
+    );
+    replaceTokens(templateMeta, node.argument, tokens);
+    insertComments(templateMeta, comments);
+  } catch (error) {
+    debug("[template] Parse error: %s", error);
+    if (ParseError.isParseError(error)) {
+      node.argument = {
+        type: "VExpressionContainer",
+        range,
+        loc,
+        parent: node,
+        expression: null,
+        references: []
+      };
+      insertError(templateMeta, error);
+    } else {
+      throw error;
     }
-    throw err;
   }
 }
-var validDivisionCharRE = /[\w).+\-$\]]/u;
-function splitFilters(exp) {
-  const result = [];
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplateString = false;
-  let inRegex = false;
-  let curly = 0;
-  let square = 0;
-  let paren = 0;
-  let lastFilterIndex = 0;
-  let c = 0;
-  let prev = 0;
-  for (let i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 39 && prev !== 92) {
-        inSingle = false;
-      }
-    } else if (inDouble) {
-      if (c === 34 && prev !== 92) {
-        inDouble = false;
-      }
-    } else if (inTemplateString) {
-      if (c === 96 && prev !== 92) {
-        inTemplateString = false;
-      }
-    } else if (inRegex) {
-      if (c === 47 && prev !== 92) {
-        inRegex = false;
-      }
-    } else if (c === 124 && exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
-      result.push(exp.slice(lastFilterIndex, i));
-      lastFilterIndex = i + 1;
-    } else {
-      switch (c) {
-        case 34:
-          inDouble = true;
-          break;
-        case 39:
-          inSingle = true;
-          break;
-        case 96:
-          inTemplateString = true;
-          break;
-        case 40:
-          paren++;
-          break;
-        case 41:
-          paren--;
-          break;
-        case 91:
-          square++;
-          break;
-        case 93:
-          square--;
-          break;
-        case 123:
-          curly++;
-          break;
-        case 125:
-          curly--;
-          break;
-      }
-      if (c === 47) {
-        let j = i - 1;
-        let p;
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== " ") {
-            break;
-          }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
+function createDirectiveKey(node, templateMeta, parserOptions, locationCalculator) {
+  const directiveKey = parseDirectiveKeyStatically(node, templateMeta);
+  const tokens = parseDirectiveKeyTokens(directiveKey);
+  replaceTokens(templateMeta, directiveKey, tokens);
+  if (directiveKey.name.name.startsWith("v-")) {
+    directiveKey.name.name = directiveKey.name.name.slice(2);
+  }
+  if (directiveKey.name.rawName.startsWith("v-")) {
+    directiveKey.name.rawName = directiveKey.name.rawName.slice(2);
+  }
+  convertDynamicArgument(
+    directiveKey,
+    templateMeta,
+    parserOptions,
+    locationCalculator
+  );
+  return directiveKey;
+}
+function convertToDirective(node, code, templateMeta, locationCalculator, vineFixLocationContext, parserOptions) {
+  debug(
+    '[template] convert to directive: %s="%s" %j',
+    node.key.name,
+    node.value && node.value.value,
+    node.range
+  );
+  const directive = node;
+  directive.directive = true;
+  directive.key = createDirectiveKey(
+    node.key,
+    templateMeta,
+    parserOptions,
+    locationCalculator
+  );
+  const { argument } = directive.key;
+  if (argument && argument.type === "VIdentifier" && argument.name.startsWith("[")) {
+    const nextChar = code[argument.range[1]];
+    if (nextChar == null || invalidDynamicArgumentNextChar.test(nextChar)) {
+      const char = nextChar == null ? "EOF" : JSON.stringify(nextChar).slice(1, -1);
+      insertError(
+        templateMeta,
+        new ParseError(
+          `Dynamic argument cannot contain the '${char}' character.`,
+          void 0,
+          argument.range[1],
+          argument.loc.end.line,
+          argument.loc.end.column
+        )
+      );
+    }
+  }
+  if (node.value == null) {
+    if (directive.key.name.name === "bind") {
+      convertForVBindSameNameShorthandValue(
+        directive,
+        parserOptions,
+        locationCalculator
+      );
     }
+    return;
   }
-  result.push(exp.slice(lastFilterIndex));
-  return result;
-}
-function parseExpressionBody(code, locationCalculator, parserOptions, allowEmpty = false) {
-  debug('[script] parse expression: "0(%s)"', code);
   try {
-    const result = parseScriptFragment(
-      `0(${code})`,
-      locationCalculator.getSubCalculatorShift(-2),
-      parserOptions
+    const ret = parseAttributeValue(
+      code,
+      parserOptions,
+      locationCalculator,
+      node.value,
+      node.parent.parent,
+      directive.key
     );
-    const { ast } = result;
-    const tokens = ast.tokens || [];
-    const comments = ast.comments || [];
-    const references = analyzeExternalReferences(result, parserOptions);
-    const statement = ast.body[0];
-    const callExpression = statement.expression;
-    const expression = callExpression.arguments[0];
-    if (!allowEmpty && !expression) {
-      return throwEmptyError(locationCalculator, "an expression");
-    }
-    if (expression && expression.type === "SpreadElement") {
-      return throwUnexpectedTokenError("...", expression);
+    directive.value = {
+      type: "VExpressionContainer",
+      range: node.value.range,
+      loc: node.value.loc,
+      parent: directive,
+      expression: ret.expression,
+      references: ret.references
+    };
+    if (ret.expression != null) {
+      ret.expression.parent = directive.value;
     }
-    if (callExpression.arguments[1]) {
-      const node = callExpression.arguments[1];
-      return throwUnexpectedTokenError(
-        ",",
-        getCommaTokenBeforeNode(tokens, node) || node
-      );
+    for (const variable of ret.variables) {
+      node.parent.parent.variables.push(variable);
     }
-    tokens.shift();
-    tokens.shift();
-    tokens.pop();
-    return { expression, tokens, comments, references, variables: [] };
+    replaceTokens(templateMeta, node.value, ret.tokens);
+    insertComments(templateMeta, ret.comments);
   } catch (err) {
-    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
-  }
-}
-function parseFilter(code, locationCalculator, parserOptions) {
-  debug('[script] parse filter: "%s"', code);
-  try {
-    const expression = {
-      type: "VFilter",
-      parent: null,
-      range: [0, 0],
-      loc: {},
-      callee: null,
-      arguments: []
-    };
-    const tokens = [];
-    const comments = [];
-    const references = [];
-    const paren = code.indexOf("(");
-    const calleeCode = paren === -1 ? code : code.slice(0, paren);
-    const argsCode = paren === -1 ? null : code.slice(paren);
-    if (calleeCode.trim()) {
-      const spaces = /^\s*/u.exec(calleeCode)[0];
-      const subCalculator = locationCalculator.getSubCalculatorShift(
-        spaces.length
-      );
-      const { ast } = parseScriptFragment(
-        `"${calleeCode.trim()}"`,
-        subCalculator,
-        parserOptions
-      );
-      const statement = ast.body[0];
-      const callee = statement.expression;
-      if (callee.type !== "Literal") {
-        const { loc, range } = ast.tokens[0];
-        return throwUnexpectedTokenError('"', {
-          range: [range[1] - 1, range[1]],
-          loc: {
-            start: {
-              line: loc.end.line,
-              column: loc.end.column - 1
-            },
-            end: loc.end
-          }
-        });
-      }
-      expression.callee = {
-        type: "Identifier",
-        parent: expression,
-        range: [
-          callee.range[0],
-          subCalculator.getOffsetWithGap(calleeCode.trim().length)
-        ],
-        loc: {
-          start: callee.loc.start,
-          end: subCalculator.getLocation(calleeCode.trim().length)
-        },
-        name: String(callee.value)
+    debug("[template] Parse error: %s", err);
+    if (ParseError.isParseError(err)) {
+      directive.value = {
+        type: "VExpressionContainer",
+        range: node.value.range,
+        loc: node.value.loc,
+        parent: directive,
+        expression: null,
+        references: []
       };
-      tokens.push({
-        type: "Identifier",
-        value: calleeCode.trim(),
-        range: expression.callee.range,
-        loc: expression.callee.loc
-      });
+      insertError(templateMeta, err);
     } else {
-      return throwEmptyError(locationCalculator, "a filter name");
-    }
-    if (argsCode != null) {
-      const result = parseScriptFragment(
-        `0${argsCode}`,
-        locationCalculator.getSubCalculatorAfter(paren).getSubCalculatorShift(-1),
-        parserOptions
-      );
-      const { ast } = result;
-      const statement = ast.body[0];
-      const callExpression = statement.expression;
-      ast.tokens.shift();
-      if (callExpression.type !== "CallExpression" || callExpression.callee.type !== "Literal") {
-        let nestCount = 1;
-        for (const token2 of ast.tokens.slice(1)) {
-          if (nestCount === 0) {
-            return throwUnexpectedTokenError(token2.value, token2);
-          }
-          if (token2.type === "Punctuator" && token2.value === "(") {
-            nestCount += 1;
-          }
-          if (token2.type === "Punctuator" && token2.value === ")") {
-            nestCount -= 1;
-          }
-        }
-        const token = (0, import_last2.default)(ast.tokens);
-        return throwUnexpectedTokenError(token.value, token);
-      }
-      for (const argument of callExpression.arguments) {
-        argument.parent = expression;
-        expression.arguments.push(argument);
-      }
-      tokens.push(...ast.tokens);
-      comments.push(...ast.comments);
-      references.push(...analyzeExternalReferences(result, parserOptions));
+      throw err;
     }
-    const firstToken = tokens[0];
-    const lastToken = (0, import_last2.default)(tokens);
-    expression.range = [firstToken.range[0], lastToken.range[1]];
-    expression.loc = { start: firstToken.loc.start, end: lastToken.loc.end };
-    return { expression, tokens, comments, references, variables: [] };
-  } catch (err) {
-    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
-  }
-}
-function loadParser(parser) {
-  if (parser !== "espree") {
-    const __require = createRequire(
-      typeof __filename ? __filename : fileURLToPath2(import.meta.url)
-    );
-    return __require(parser);
-  }
-  return getEspreeFromUser();
-}
-function parseScript(code, parserOptions) {
-  const parser = typeof parserOptions.parser === "string" ? loadParser(parserOptions.parser) : isParserObject(parserOptions.parser) ? parserOptions.parser : getEspreeFromEcmaVersion(parserOptions.ecmaVersion);
-  const result = isEnhancedParserObject(parser) ? parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
-  if (result.ast != null) {
-    return result;
   }
-  return { ast: result };
 }
-function parseExpression(code, locationCalculator, parserOptions, { allowEmpty = false, allowFilters = false } = {}) {
-  debug('[script] parse expression: "%s"', code);
-  const [mainCode, ...filterCodes] = allowFilters ? splitFilters(code) : [code];
-  if (filterCodes.length === 0) {
-    return parseExpressionBody(
-      code,
+function processMustache(parserOptions, globalLocationCalculator, vineFixLocationContext, templateMeta, node, mustache) {
+  const range = [
+    mustache.startToken.range[1],
+    mustache.endToken.range[0]
+  ];
+  debug("[template] convert mustache {{%s}} %j", mustache.value, range);
+  try {
+    const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(range[0]);
+    const ret = parseExpression(
+      mustache.value,
       locationCalculator,
       parserOptions,
-      allowEmpty
-    );
-  }
-  const retB = parseExpressionBody(
-    mainCode,
-    locationCalculator,
-    parserOptions
-  );
-  if (!retB.expression) {
-    return retB;
-  }
-  const ret = retB;
-  ret.expression = {
-    type: "VFilterSequenceExpression",
-    parent: null,
-    expression: retB.expression,
-    filters: [],
-    range: retB.expression.range.slice(0),
-    loc: Object.assign({}, retB.expression.loc)
-  };
-  ret.expression.expression.parent = ret.expression;
-  let prevLoc = mainCode.length;
-  for (const filterCode of filterCodes) {
-    ret.tokens.push(
-      fixLocation(
-        {
-          type: "Punctuator",
-          value: "|",
-          range: [prevLoc, prevLoc + 1],
-          loc: {}
-        },
-        locationCalculator
-      )
-    );
-    const retF = parseFilter(
-      filterCode,
-      locationCalculator.getSubCalculatorShift(prevLoc + 1),
-      parserOptions
+      { allowEmpty: true, allowFilters: true }
     );
-    if (retF) {
-      if (retF.expression) {
-        ret.expression.filters.push(retF.expression);
-        retF.expression.parent = ret.expression;
+    node.expression = ret.expression || null;
+    node.references = ret.references;
+    if (ret.expression != null) {
+      ret.expression.parent = node;
+    }
+    replaceTokens(templateMeta, { range }, ret.tokens);
+    insertComments(templateMeta, ret.comments);
+  } catch (err) {
+    debug("[template] Parse error: %s", err);
+    if (ParseError.isParseError(err)) {
+      insertError(templateMeta, err);
+    } else {
+      throw err;
+    }
+  }
+}
+function resolveReference(referene, element) {
+  let node = element;
+  while (node != null && node.type === "VElement") {
+    for (const variable of node.variables) {
+      if (variable.id.name === referene.id.name) {
+        referene.variable = variable;
+        variable.references.push(referene);
+        return;
       }
-      ret.tokens.push(...retF.tokens);
-      ret.comments.push(...retF.comments);
-      ret.references.push(...retF.references);
     }
-    prevLoc += 1 + filterCode.length;
+    node = node.parent;
   }
-  const lastToken = (0, import_last2.default)(ret.tokens);
-  ret.expression.range[1] = lastToken.range[1];
-  ret.expression.loc.end = lastToken.loc.end;
-  return ret;
 }
-function parseVForExpression(code, locationCalculator, parserOptions) {
-  if (code.trim() === "") {
-    throwEmptyError(locationCalculator, "'<alias> in <expression>'");
+function resolveReferences(container) {
+  let element = container.parent;
+  while (element != null && element.type !== "VElement") {
+    element = element.parent;
   }
-  if (isEcmaVersion5(parserOptions)) {
-    return parseVForExpressionForEcmaVersion5(
-      code,
-      locationCalculator,
-      parserOptions
-    );
+  if (element != null) {
+    for (const reference of container.references) {
+      resolveReference(reference, element);
+    }
   }
-  const processed = processVForAliasAndIterator(code);
-  if (!processed.aliases.trim()) {
-    return throwEmptyError(locationCalculator, "an alias");
+}
+function convertForVBindSameNameShorthandValue(directive, parserOptions, locationCalculator) {
+  if (directive.key.name.name !== "bind" || directive.key.argument == null || directive.key.argument.type !== "VIdentifier") {
+    return;
   }
+  const vId = directive.key.argument;
+  const camelName = camelize(vId.name);
+  let result = null;
   try {
-    debug(
-      '[script] parse v-for expression: "for(%s%s%s);"',
-      processed.aliasesWithBrackets,
-      processed.delimiter,
-      processed.iterator
-    );
-    const result = parseScriptFragment(
-      `for(let ${processed.aliasesWithBrackets}${processed.delimiter}${processed.iterator});`,
-      locationCalculator.getSubCalculatorShift(
-        processed.hasParens ? -8 : -9
-      ),
-      parserOptions
-    );
-    const { ast } = result;
-    const tokens = ast.tokens || [];
-    const comments = ast.comments || [];
-    const scope = analyzeVariablesAndExternalReferences(
-      result,
-      "v-for",
+    result = parseScriptFragment(
+      camelName,
+      locationCalculator.getSubCalculatorAfter(vId.range[0]),
       parserOptions
     );
-    const references = scope.references;
-    const variables = scope.variables;
-    const statement = ast.body[0];
-    const varDecl = statement.left;
-    const id = varDecl.declarations[0].id;
-    const left = id.elements;
-    const right = statement.right;
-    if (!processed.hasParens && !left.length) {
-      return throwEmptyError(locationCalculator, "an alias");
-    }
-    tokens.shift();
-    tokens.shift();
-    tokens.shift();
-    tokens.pop();
-    tokens.pop();
-    const closeOffset = statement.left.range[1] - 1;
-    const closeIndex = tokens.findIndex((t) => t.range[0] === closeOffset);
-    if (processed.hasParens) {
-      const open = tokens[0];
-      if (open != null) {
-        open.value = "(";
-      }
-      const close = tokens[closeIndex];
-      if (close != null) {
-        close.value = ")";
+  } catch (err) {
+    debug("[template] Parse error: %s", err);
+  }
+  if (result == null || result.ast.body.length !== 1 || result.ast.body[0].type !== "ExpressionStatement" || result.ast.body[0].expression.type !== "Identifier") {
+    return;
+  }
+  const id = result.ast.body[0].expression;
+  id.range[1] = vId.range[1];
+  id.loc.end = { ...vId.loc.end };
+  if (id.end != null) {
+    id.end = vId.end;
+  }
+  directive.value = {
+    type: "VExpressionContainer",
+    range: [...vId.range],
+    loc: {
+      start: { ...vId.loc.start },
+      end: { ...vId.loc.end }
+    },
+    parent: directive,
+    expression: id,
+    references: [
+      {
+        id,
+        mode: "r",
+        variable: null
       }
-    } else {
-      tokens.splice(closeIndex, 1);
-      tokens.shift();
-    }
-    const firstToken = tokens[0] || statement.left;
-    const lastToken = tokens[tokens.length - 1] || statement.right;
-    const expression = {
-      type: "VForExpression",
-      range: [firstToken.range[0], lastToken.range[1]],
-      loc: { start: firstToken.loc.start, end: lastToken.loc.end },
-      parent: DUMMY_PARENT2,
-      left,
-      right
-    };
-    for (const l of left) {
-      if (l != null) {
-        l.parent = expression;
+    ]
+  };
+  id.parent = directive.value;
+}
+
+// src/script/scope-analyzer.ts
+var BUILTIN_COMPONENTS = /* @__PURE__ */ new Set([
+  "template",
+  "slot",
+  "component",
+  "Component",
+  "transition",
+  "Transition",
+  "transition-group",
+  "TransitionGroup",
+  "keep-alive",
+  "KeepAlive",
+  "teleport",
+  "Teleport",
+  "suspense",
+  "Suspense"
+]);
+var BUILTIN_DIRECTIVES = /* @__PURE__ */ new Set([
+  "bind",
+  "on",
+  "text",
+  "html",
+  "show",
+  "if",
+  "else",
+  "else-if",
+  "for",
+  "model",
+  "slot",
+  "pre",
+  "cloak",
+  "once",
+  "memo",
+  "is"
+]);
+var HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
+var SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
+var NATIVE_TAGS = /* @__PURE__ */ new Set([...HTML_TAGS.split(","), ...SVG_TAGS.split(",")]);
+function isUnique(reference, index, references) {
+  return index === 0 || reference.identifier !== references[index - 1].identifier;
+}
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+function hasDefinition(variable) {
+  return variable.defs.length >= 1;
+}
+function transformReference(reference) {
+  const ret = {
+    id: reference.identifier,
+    mode: reference.isReadOnly() ? "r" : reference.isWriteOnly() ? "w" : (
+      /* otherwise */
+      "rw"
+    ),
+    variable: null,
+    isValueReference: reference.isValueReference,
+    isTypeReference: reference.isTypeReference
+  };
+  Object.defineProperty(ret, "variable", { enumerable: false });
+  return ret;
+}
+function transformVariable(variable, kind) {
+  const ret = {
+    id: variable.defs[0].name,
+    kind,
+    references: []
+  };
+  Object.defineProperty(ret, "references", { enumerable: false });
+  return ret;
+}
+function getForScope(scope) {
+  const child = scope.childScopes[0];
+  return child.block === scope.block ? child.childScopes[0] : child;
+}
+function analyzeScope(ast, parserOptions) {
+  const ecmaVersion = getEcmaVersionIfUseEspree(parserOptions) || 2022;
+  const ecmaFeatures = parserOptions.ecmaFeatures || {};
+  const sourceType = parserOptions.sourceType || "script";
+  const result = getEslintScope().analyze(ast, {
+    ignoreEval: true,
+    nodejsScope: false,
+    impliedStrict: ecmaFeatures.impliedStrict,
+    ecmaVersion,
+    sourceType,
+    fallback: getFallbackKeys
+  });
+  return result;
+}
+function analyze(parserResult, parserOptions) {
+  const scopeManager = parserResult.scopeManager || analyzeScope(parserResult.ast, parserOptions);
+  return scopeManager.globalScope;
+}
+function analyzeExternalReferences(parserResult, parserOptions) {
+  const scope = analyze(parserResult, parserOptions);
+  return scope.through.filter(isUnique).map(transformReference);
+}
+function analyzeVariablesAndExternalReferences(parserResult, kind, parserOptions) {
+  const scope = analyze(parserResult, parserOptions);
+  return {
+    variables: getForScope(scope).variables.filter(hasDefinition).map((v) => transformVariable(v, kind)),
+    references: scope.through.filter(isUnique).map(transformReference)
+  };
+}
+function collectVariablesForVCF(tsFileScopeManager, templateRoot) {
+  const scriptVariables = /* @__PURE__ */ new Map();
+  const globalScope = tsFileScopeManager.globalScope;
+  if (!globalScope) {
+    return scriptVariables;
+  }
+  for (const variable of globalScope.variables) {
+    scriptVariables.set(variable.name, variable);
+  }
+  const moduleScope = globalScope.childScopes.find(
+    (scope) => scope.type === "module"
+  );
+  for (const variable of moduleScope && moduleScope.variables || []) {
+    scriptVariables.set(variable.name, variable);
+  }
+  let foundVCF = templateRoot.parent;
+  let foundVCFScope;
+  if (templateRoot.parent) {
+    do {
+      foundVCF = foundVCF.parent;
+    } while (foundVCF && foundVCF.type !== "FunctionDeclaration" && foundVCF.type !== "FunctionExpression" && foundVCF.type !== "ArrowFunctionExpression");
+    if (foundVCF) {
+      Object.assign(
+        foundVCF,
+        { __isVine__: true }
+      );
+      const tryGetVCFScope = tsFileScopeManager.nodeToScope.get(foundVCF);
+      if (_optionalChain([tryGetVCFScope, 'optionalAccess', _7 => _7[0]])) {
+        foundVCFScope = tryGetVCFScope[0];
+        for (const variable of foundVCFScope.variables) {
+          scriptVariables.set(variable.name, variable);
+        }
+        const compFnPropsIdentifier = _optionalChain([foundVCF, 'access', _8 => _8.params, 'optionalAccess', _9 => _9[0], 'optionalAccess', _10 => _10.type]) === "Identifier" && _optionalChain([foundVCF, 'access', _11 => _11.params, 'access', _12 => _12[0], 'optionalAccess', _13 => _13.name]) === "props" ? foundVCF.params[0] : null;
+        const propsVar = scriptVariables.get("props");
+        if (compFnPropsIdentifier && propsVar) {
+          ;
+          propsVar.eslintUsed = true;
+          propsVar.references.push(
+            createVirtualVineFnPropsReference({
+              foundVCFScope,
+              compFnPropsIdentifier
+            })
+          );
+        }
       }
     }
-    right.parent = expression;
-    return { expression, tokens, comments, references, variables };
-  } catch (err) {
-    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
+  return scriptVariables;
 }
-function isEcmaVersion5(parserOptions) {
-  const ecmaVersion = getEcmaVersionIfUseEspree(parserOptions);
-  return ecmaVersion != null && ecmaVersion <= 5;
-}
-function parseVForExpressionForEcmaVersion5(code, locationCalculator, parserOptions) {
-  const processed = processVForAliasAndIterator(code);
-  if (!processed.aliases.trim()) {
-    return throwEmptyError(locationCalculator, "an alias");
-  }
-  try {
-    const tokens = [];
-    const comments = [];
-    const parsedAliases = parseVForAliasesForEcmaVersion5(
-      processed.aliasesWithBrackets,
-      locationCalculator.getSubCalculatorShift(
-        processed.hasParens ? 0 : -1
-      ),
-      parserOptions
-    );
-    if (processed.hasParens) {
-      const open = parsedAliases.tokens[0];
-      if (open != null) {
-        open.value = "(";
-      }
-      const close = (0, import_last2.default)(parsedAliases.tokens);
-      if (close != null) {
-        close.value = ")";
-      }
-    } else {
-      parsedAliases.tokens.shift();
-      parsedAliases.tokens.pop();
+function analyzeUsedInTemplateVariables(scopeManager, templateRoot) {
+  const scriptVariables = collectVariablesForVCF(scopeManager, templateRoot);
+  const markedVariables = /* @__PURE__ */ new Set();
+  function markSetupReferenceVariableAsUsed(name) {
+    if (scriptVariables.has(name)) {
+      markVariableAsUsed(name);
+      return true;
     }
-    tokens.push(...parsedAliases.tokens);
-    comments.push(...parsedAliases.comments);
-    const { left, variables } = parsedAliases;
-    if (!processed.hasParens && !left.length) {
-      return throwEmptyError(locationCalculator, "an alias");
+    const camelName = camelize(name);
+    if (scriptVariables.has(camelName)) {
+      markVariableAsUsed(camelName);
+      return true;
     }
-    const delimiterStart = processed.aliases.length;
-    const delimiterEnd = delimiterStart + processed.delimiter.length;
-    tokens.push(
-      fixLocation(
-        {
-          type: processed.delimiter === "in" ? "Keyword" : "Identifier",
-          value: processed.delimiter,
-          start: delimiterStart,
-          end: delimiterEnd,
-          loc: {},
-          range: [delimiterStart, delimiterEnd]
-        },
-        locationCalculator
-      )
-    );
-    const parsedIterator = parseVForIteratorForEcmaVersion5(
-      processed.iterator,
-      locationCalculator.getSubCalculatorShift(delimiterEnd),
-      parserOptions
-    );
-    tokens.push(...parsedIterator.tokens);
-    comments.push(...parsedIterator.comments);
-    const { right, references } = parsedIterator;
-    const firstToken = tokens[0];
-    const lastToken = (0, import_last2.default)(tokens) || firstToken;
-    const expression = {
-      type: "VForExpression",
-      range: [firstToken.range[0], lastToken.range[1]],
-      loc: { start: firstToken.loc.start, end: lastToken.loc.end },
-      parent: DUMMY_PARENT2,
-      left,
-      right
-    };
-    for (const l of left) {
-      if (l != null) {
-        l.parent = expression;
-      }
+    const pascalName = capitalize(camelName);
+    if (scriptVariables.has(pascalName)) {
+      markVariableAsUsed(pascalName);
+      return true;
     }
-    right.parent = expression;
-    return { expression, tokens, comments, references, variables };
-  } catch (err) {
-    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
+    return false;
   }
-}
-function parseVForAliasesForEcmaVersion5(code, locationCalculator, parserOptions) {
-  const result = parseScriptFragment(
-    `0(${code})`,
-    locationCalculator.getSubCalculatorShift(-2),
-    parserOptions
-  );
-  const { ast } = result;
-  const tokens = ast.tokens || [];
-  const comments = ast.comments || [];
-  const variables = analyzeExternalReferences(result, parserOptions).map(
-    transformVariable2
-  );
-  const statement = ast.body[0];
-  const callExpression = statement.expression;
-  const expression = callExpression.arguments[0];
-  const left = expression.elements.filter(
-    (e) => {
-      if (e == null || e.type === "Identifier") {
-        return true;
-      }
-      const errorToken = tokens.find(
-        (t) => e.range[0] <= t.range[0] && t.range[1] <= e.range[1]
-      );
-      return throwUnexpectedTokenError(errorToken.value, errorToken);
+  function markVariableAsUsed(nameOrRef) {
+    let name;
+    let isValueReference;
+    let isTypeReference;
+    if (typeof nameOrRef === "string") {
+      name = nameOrRef;
+    } else {
+      name = nameOrRef.id.name;
+      isValueReference = nameOrRef.isValueReference;
+      isTypeReference = nameOrRef.isTypeReference;
     }
-  );
-  tokens.shift();
-  tokens.shift();
-  tokens.pop();
-  return { left, tokens, comments, variables };
-  function transformVariable2(reference) {
-    const ret = {
-      id: reference.id,
-      kind: "v-for",
-      references: []
-    };
-    Object.defineProperty(ret, "references", { enumerable: false });
-    return ret;
-  }
-}
-function parseVForIteratorForEcmaVersion5(code, locationCalculator, parserOptions) {
-  const result = parseScriptFragment(
-    `0(${code})`,
-    locationCalculator.getSubCalculatorShift(-2),
-    parserOptions
-  );
-  const { ast } = result;
-  const tokens = ast.tokens || [];
-  const comments = ast.comments || [];
-  const references = analyzeExternalReferences(result, parserOptions);
-  const statement = ast.body[0];
-  const callExpression = statement.expression;
-  const expression = callExpression.arguments[0];
-  if (!expression) {
-    return throwEmptyError(locationCalculator, "an expression");
-  }
-  if (expression && expression.type === "SpreadElement") {
-    return throwUnexpectedTokenError("...", expression);
-  }
-  const right = expression;
-  tokens.shift();
-  tokens.shift();
-  tokens.pop();
-  return { right, tokens, comments, references };
-}
-function parseVOnExpression(code, locationCalculator, parserOptions) {
-  if (IS_FUNCTION_EXPRESSION.test(code) || IS_SIMPLE_PATH.test(code)) {
-    return parseExpressionBody(
-      code,
-      locationCalculator,
-      parserOptions
-    );
-  }
-  return parseVOnExpressionBody(
-    code,
-    locationCalculator,
-    parserOptions
-  );
-}
-function parseVOnExpressionBody(code, locationCalculator, parserOptions) {
-  debug('[script] parse v-on expression: "void function($event){%s}"', code);
-  if (code.trim() === "") {
-    throwEmptyError(locationCalculator, "statements");
-  }
-  try {
-    const result = parseScriptFragment(
-      `void function($event){${code}}`,
-      locationCalculator.getSubCalculatorShift(-22),
-      parserOptions
-    );
-    const { ast } = result;
-    const references = analyzeExternalReferences(result, parserOptions);
-    const outermostStatement = ast.body[0];
-    const functionDecl = outermostStatement.expression.argument;
-    const block = functionDecl.body;
-    const body = block.body;
-    const firstStatement = (0, import_first.default)(body);
-    const lastStatement = (0, import_last2.default)(body);
-    const expression = {
-      type: "VOnExpression",
-      range: [
-        firstStatement != null ? firstStatement.range[0] : block.range[0] + 1,
-        lastStatement != null ? lastStatement.range[1] : block.range[1] - 1
-      ],
-      loc: {
-        start: firstStatement != null ? firstStatement.loc.start : locationCalculator.getLocation(1),
-        end: lastStatement != null ? lastStatement.loc.end : locationCalculator.getLocation(code.length + 1)
-      },
-      parent: DUMMY_PARENT2,
-      body
-    };
-    const tokens = ast.tokens || [];
-    const comments = ast.comments || [];
-    for (const b of body) {
-      b.parent = expression;
+    const variable = scriptVariables.get(name);
+    if (!variable || variable.identifiers.length === 0) {
+      return;
+    }
+    if (markedVariables.has(name)) {
+      return;
+    }
+    markedVariables.add(name);
+    const reference = new tsEscopeTypes2.Reference(
+      variable.identifiers[0],
+      variable.scope,
+      1 /* Read */,
+      void 0,
+      void 0,
+      void 0,
+      isValueReference ? 1 /* Value */ : isTypeReference ? 2 /* Type */ : void 0
+    );
+    reference.vueUsedInTemplate = true;
+    reference.isWrite = () => false;
+    reference.isWriteOnly = () => false;
+    reference.isRead = () => true;
+    reference.isReadOnly = () => true;
+    reference.isReadWrite = () => false;
+    variable.references.push(reference);
+    reference.resolved = variable;
+    if (reference.isTypeReference) {
+      ;
+      variable.eslintUsed = true;
     }
-    tokens.splice(0, 6);
-    tokens.pop();
-    return { expression, tokens, comments, references, variables: [] };
-  } catch (err) {
-    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
-}
-function parseSlotScopeExpression(code, locationCalculator, parserOptions) {
-  debug('[script] parse slot-scope expression: "void function(%s) {}"', code);
-  if (code.trim() === "") {
-    throwEmptyError(
-      locationCalculator,
-      "an identifier or an array/object pattern"
-    );
+  function processVExpressionContainer(node) {
+    for (const reference of node.references.filter(
+      (ref) => ref.variable == null
+    )) {
+      markVariableAsUsed(reference);
+    }
   }
-  try {
-    const result = parseScriptFragment(
-      `void function(${code}) {}`,
-      locationCalculator.getSubCalculatorShift(-14),
-      parserOptions
-    );
-    const { ast } = result;
-    const statement = ast.body[0];
-    const rawExpression = statement.expression;
-    const functionDecl = rawExpression.argument;
-    const params = functionDecl.params;
-    if (params.length === 0) {
-      return {
-        expression: null,
-        tokens: [],
-        comments: [],
-        references: [],
-        variables: []
-      };
+  function processVElement(node) {
+    if (node.rawName === node.name && NATIVE_TAGS.has(node.rawName) || BUILTIN_COMPONENTS.has(node.rawName)) {
+      return;
     }
-    const tokens = ast.tokens || [];
-    const comments = ast.comments || [];
-    const scope = analyzeVariablesAndExternalReferences(
-      result,
-      "scope",
-      parserOptions
-    );
-    const references = scope.references;
-    const variables = scope.variables;
-    const firstParam = (0, import_first.default)(params);
-    const lastParam = (0, import_last2.default)(params);
-    const expression = {
-      type: "VSlotScopeExpression",
-      range: [firstParam.range[0], lastParam.range[1]],
-      loc: { start: firstParam.loc.start, end: lastParam.loc.end },
-      parent: DUMMY_PARENT2,
-      params: functionDecl.params
-    };
-    for (const param of params) {
-      param.parent = expression;
+    if (!markSetupReferenceVariableAsUsed(node.rawName)) {
+      const dotIndex = node.rawName.indexOf(".");
+      if (dotIndex > 0) {
+        markSetupReferenceVariableAsUsed(
+          node.rawName.slice(0, dotIndex)
+        );
+      }
+    }
+  }
+  function processVAttribute(node) {
+    if (node.directive) {
+      if (BUILTIN_DIRECTIVES.has(node.key.name.name)) {
+        return;
+      }
+      markSetupReferenceVariableAsUsed(`v-${node.key.name.rawName}`);
+    } else if (node.key.name === "ref" && node.value) {
+      markVariableAsUsed(node.value.value);
     }
-    tokens.shift();
-    tokens.shift();
-    tokens.shift();
-    tokens.pop();
-    tokens.pop();
-    tokens.pop();
-    return { expression, tokens, comments, references, variables };
-  } catch (err) {
-    return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
+  traverseNodes(templateRoot, {
+    enterNode(node) {
+      if (node.type === "VExpressionContainer") {
+        processVExpressionContainer(node);
+      } else if (node.type === "VElement") {
+        processVElement(node);
+      } else if (node.type === "VAttribute") {
+        processVAttribute(node);
+      }
+    },
+    leaveNode() {
+    }
+  });
 }
 
-// src/template/utils/index.ts
-var shorthandSign = /^[.:@#]/u;
-var shorthandNameMap = { ":": "bind", ".": "bind", "@": "on", "#": "slot" };
-var invalidDynamicArgumentNextChar = /^[\s=/>]$/u;
-function isPropModifier(node) {
-  return node.name === "prop";
-}
-function isNotEmptyModifier(node) {
-  return node.name !== "";
-}
-function getStandardDirectiveKind(element, directiveKey) {
-  const directiveName = directiveKey.name.name;
-  if (directiveName === "for") {
-    return "for";
-  } else if (directiveName === "on") {
-    return "on";
-  } else if (directiveName === "slot" || directiveName === "slot-scope" || directiveName === "scope" && element.rawName === "template") {
-    return "slot";
-  } else if (directiveName === "bind") {
-    return "bind";
+// src/template/parser.ts
+var import_findLastIndex = __toESM(require_findLastIndex());
+var import_last3 = __toESM(require_last());
+var _assert = require('assert'); var _assert2 = _interopRequireDefault(_assert);
+
+// src/common/location-calculator.ts
+var import_sortedLastIndex2 = __toESM(require_sortedLastIndex());
+
+// src/common/lines-and-columns.ts
+var import_sortedLastIndex = __toESM(require_sortedLastIndex());
+var LinesAndColumns = class {
+  
+  /**
+   * Initialize.
+   * @param ltOffsets The list of the offset of line terminators.
+   */
+  constructor(ltOffsets) {
+    this.ltOffsets = ltOffsets;
   }
-  return null;
-}
-function parseAttributeValue(code, parserOptions, globalLocationCalculator, node, element, directiveKey) {
-  const firstChar = code[node.range[0]];
-  const quoted = firstChar === '"' || firstChar === "'";
-  const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(
-    node.range[0] + (quoted ? 1 : 0)
-  );
-  const directiveKind = getStandardDirectiveKind(
-    element,
-    directiveKey
-  );
-  let result;
-  if (quoted && node.value === "") {
-    result = {
-      expression: null,
-      tokens: [],
-      comments: [],
-      variables: [],
-      references: []
+  /**
+   * Calculate the location of the given index.
+   * @param index The index to calculate their location.
+   * @returns The location of the index.
+   */
+  getLocFromIndex(index) {
+    const line = (0, import_sortedLastIndex.default)(this.ltOffsets, index) + 1;
+    const column = index - (line === 1 ? 0 : this.ltOffsets[line - 2]);
+    return { line, column };
+  }
+  createOffsetLocationCalculator(offset) {
+    return {
+      getFixOffset() {
+        return offset;
+      },
+      getLocFromIndex: this.getLocFromIndex.bind(this)
     };
-  } else if (directiveKind === "for") {
-    result = parseVForExpression(
-      node.value,
-      locationCalculator,
-      parserOptions
-    );
-  } else if (directiveKind === "on" && directiveKey.argument != null) {
-    result = parseVOnExpression(
-      node.value,
-      locationCalculator,
-      parserOptions
-    );
-  } else if (directiveKind === "slot") {
-    result = parseSlotScopeExpression(
-      node.value,
-      locationCalculator,
-      parserOptions
-    );
-  } else if (directiveKind === "bind") {
-    result = parseExpression(
-      node.value,
-      locationCalculator,
-      parserOptions,
-      { allowFilters: true }
-    );
-  } else {
-    result = parseExpression(
-      node.value,
-      locationCalculator,
-      parserOptions
-    );
   }
-  if (quoted) {
-    result.tokens.unshift(
-      createSimpleToken(
-        "Punctuator",
-        node.range[0],
-        node.range[0] + 1,
-        firstChar,
-        globalLocationCalculator
-      )
+};
+
+// src/common/location-calculator.ts
+var LocationCalculatorForHtml = class _LocationCalculatorForHtml extends LinesAndColumns {
+  
+  
+  
+  
+  /**
+   * Initialize this calculator.
+   * @param gapOffsets The list of the offset of removed characters in tokenization phase.
+   * @param ltOffsets The list of the offset of line terminators.
+   * @param baseOffset The base offset to calculate locations.
+   * @param shiftOffset The shift offset to calculate locations.
+   */
+  constructor(gapOffsets, ltOffsets, baseOffset, shiftOffset = 0) {
+    super(ltOffsets);
+    this.gapOffsets = gapOffsets;
+    this.ltOffsets = ltOffsets;
+    this.baseOffset = baseOffset || 0;
+    this.baseIndexOfGap = this.baseOffset === 0 ? 0 : (0, import_sortedLastIndex2.default)(gapOffsets, this.baseOffset);
+    this.shiftOffset = shiftOffset;
+  }
+  /**
+   * Get sub calculator which have the given base offset.
+   * @param offset The base offset of new sub calculator.
+   * @returns Sub calculator.
+   */
+  getSubCalculatorAfter(offset) {
+    return new _LocationCalculatorForHtml(
+      this.gapOffsets,
+      this.ltOffsets,
+      this.baseOffset + offset,
+      this.shiftOffset
     );
-    result.tokens.push(
-      createSimpleToken(
-        "Punctuator",
-        node.range[1] - 1,
-        node.range[1],
-        firstChar,
-        globalLocationCalculator
-      )
+  }
+  /**
+   * Get sub calculator that shifts the given offset.
+   * @param offset The shift of new sub calculator.
+   * @returns Sub calculator.
+   */
+  getSubCalculatorShift(offset) {
+    return new _LocationCalculatorForHtml(
+      this.gapOffsets,
+      this.ltOffsets,
+      this.baseOffset,
+      this.shiftOffset + offset
     );
   }
-  return result;
-}
-function parseDirectiveKeyStatically(node, templateMeta) {
-  const {
-    name: text,
-    rawName: rawText,
-    range: [offset],
-    loc: {
-      start: { column, line }
+  /**
+   * Calculate gap at the given index.
+   * @param index The index to calculate gap.
+   */
+  _getGap(index) {
+    const offsets = this.gapOffsets;
+    let g0 = (0, import_sortedLastIndex2.default)(offsets, index + this.baseOffset);
+    let pos = index + this.baseOffset + g0 - this.baseIndexOfGap;
+    while (g0 < offsets.length && offsets[g0] <= pos) {
+      g0 += 1;
+      pos += 1;
     }
-  } = node;
-  const directiveKey = {
-    type: "VDirectiveKey",
-    range: node.range,
-    loc: node.loc,
-    parent: node.parent,
-    name: null,
-    argument: null,
-    modifiers: []
-  };
-  let i = 0;
-  function createIdentifier(start, end, name) {
-    const id = {
-      type: "VIdentifier",
-      parent: directiveKey,
-      range: [offset + start, offset + end],
-      loc: {
-        start: { column: column + start, line },
-        end: { column: column + end, line }
-      },
-      name: name || text.slice(start, end),
-      rawName: rawText.slice(start, end)
-    };
-    return id;
+    return g0 - this.baseIndexOfGap;
   }
-  if (shorthandSign.test(text)) {
-    const sign = text[0];
-    directiveKey.name = createIdentifier(0, 1, shorthandNameMap[sign]);
-    i = 1;
-  } else {
-    const colon = text.indexOf(":");
-    if (colon !== -1) {
-      directiveKey.name = createIdentifier(0, colon);
-      i = colon + 1;
-    }
+  /**
+   * Calculate the location of the given index.
+   * @param index The index to calculate their location.
+   * @returns The location of the index.
+   */
+  getLocation(index) {
+    return this.getLocFromIndex(this.getOffsetWithGap(index));
   }
-  if (directiveKey.name != null && text[i] === "[") {
-    const len = text.slice(i).lastIndexOf("]");
-    if (len !== -1) {
-      directiveKey.argument = createIdentifier(i, i + len + 1);
-      i = i + len + 1 + (text[i + len + 1] === "." ? 1 : 0);
-    }
+  /**
+   * Calculate the offset of the given index.
+   * @param index The index to calculate their location.
+   * @returns The offset of the index.
+   */
+  getOffsetWithGap(index) {
+    return index + this.getFixOffset(index);
   }
-  const modifiers = text.slice(i).split(".").map((modifierName) => {
-    const modifier = createIdentifier(i, i + modifierName.length);
-    if (modifierName === "" && i < text.length) {
-      insertError(
-        templateMeta,
-        new ParseError(
-          `Unexpected token '${text[i]}'`,
-          void 0,
-          offset + i,
-          line,
-          column + i
-        )
-      );
-    }
-    i += modifierName.length + 1;
-    return modifier;
-  });
-  if (directiveKey.name == null) {
-    directiveKey.name = modifiers.shift();
-  } else if (directiveKey.argument == null && modifiers[0].name !== "") {
-    directiveKey.argument = modifiers.shift() || null;
+  /**
+   * Gets the fix location offset of the given offset with using the base offset of this calculator.
+   * @param offset The offset to modify.
+   */
+  getFixOffset(offset) {
+    const shiftOffset = this.shiftOffset;
+    const gap = this._getGap(offset + shiftOffset);
+    return this.baseOffset + gap + shiftOffset;
   }
-  directiveKey.modifiers = modifiers.filter(isNotEmptyModifier);
-  if (directiveKey.name.name === "v-") {
-    insertError(
-      templateMeta,
-      new ParseError(
-        `Unexpected token '${text[directiveKey.name.range[1] - offset]}'`,
-        void 0,
-        directiveKey.name.range[1],
-        directiveKey.name.loc.end.line,
-        directiveKey.name.loc.end.column
-      )
-    );
+};
+
+// src/template/intermediate-tokenizer.ts
+var import_last2 = __toESM(require_last());
+
+var DUMMY_PARENT2 = Object.freeze({});
+function concat(text, token) {
+  return text + token.value;
+}
+var IntermediateTokenizer = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  /**
+   * The source code text.
+   */
+  get text() {
+    return this.tokenizer.text;
   }
-  if (directiveKey.name.rawName === "." && !directiveKey.modifiers.some(isPropModifier)) {
-    const pos = (directiveKey.argument || directiveKey.name).range[1] - offset;
-    const propModifier = createIdentifier(pos, pos, "prop");
-    directiveKey.modifiers.unshift(propModifier);
+  /**
+   * The parse errors.
+   */
+  get errors() {
+    return this.tokenizer.errors;
   }
-  return directiveKey;
-}
-function parseDirectiveKeyTokens(node) {
-  const { name, argument, modifiers } = node;
-  const shorthand = name.range[1] - name.range[0] === 1;
-  const tokens = [];
-  if (shorthand) {
-    tokens.push({
-      type: "Punctuator",
-      range: name.range,
-      loc: name.loc,
-      value: name.rawName
-    });
-  } else {
-    tokens.push({
-      type: "HTMLIdentifier",
-      range: name.range,
-      loc: name.loc,
-      value: name.rawName
-    });
-    if (argument) {
-      tokens.push({
-        type: "Punctuator",
-        range: [name.range[1], argument.range[0]],
-        loc: { start: name.loc.end, end: argument.loc.start },
-        value: ":"
-      });
-    }
+  /**
+   * The current state.
+   */
+  get state() {
+    return this.tokenizer.state;
   }
-  if (argument) {
-    tokens.push({
-      type: "HTMLIdentifier",
-      range: argument.range,
-      loc: argument.loc,
-      value: argument.rawName
-    });
+  set state(value) {
+    this.tokenizer.state = value;
   }
-  let lastNode = argument || name;
-  for (const modifier of modifiers) {
-    if (modifier.rawName === "") {
-      continue;
-    }
-    tokens.push(
-      {
-        type: "Punctuator",
-        range: [lastNode.range[1], modifier.range[0]],
-        loc: { start: lastNode.loc.end, end: modifier.loc.start },
-        value: "."
-      },
-      {
-        type: "HTMLIdentifier",
-        range: modifier.range,
-        loc: modifier.loc,
-        value: modifier.rawName
+  /**
+   * The current namespace.
+   */
+  get namespace() {
+    return this.tokenizer.namespace;
+  }
+  set namespace(value) {
+    this.tokenizer.namespace = value;
+  }
+  /**
+   * The current flag of expression enabled.
+   */
+  get expressionEnabled() {
+    return this.tokenizer.expressionEnabled;
+  }
+  set expressionEnabled(value) {
+    this.tokenizer.expressionEnabled = value;
+  }
+  /**
+   * Initialize this intermediate tokenizer.
+   * @param tokenizer The tokenizer.
+   */
+  constructor(tokenizer, parserOptions) {
+    this.tokenizer = tokenizer;
+    this.baseParserOptions = parserOptions;
+    this.currentToken = null;
+    this.attribute = null;
+    this.attributeNames = /* @__PURE__ */ new Set();
+    this.expressionStartToken = null;
+    this.expressionTokens = [];
+    this.tokens = [];
+    this.comments = [];
+  }
+  /**
+   * Get the next intermediate token.
+   * @returns The intermediate token or null.
+   */
+  nextToken() {
+    let token = null;
+    let result = null;
+    while (result == null) {
+      token = this.tokenizer.nextToken();
+      if (token == null) {
+        break;
       }
-    );
-    lastNode = modifier;
+      result = this[token.type](token);
+    }
+    if (result == null && token == null && this.currentToken != null) {
+      result = this.commit();
+    }
+    return result;
   }
-  return tokens;
-}
-function convertDynamicArgument(node, templateMeta, parserOptions, locationCalculator) {
-  const { argument } = node;
-  if (!(argument != null && argument.type === "VIdentifier" && argument.name.startsWith("[") && argument.name.endsWith("]"))) {
-    return;
+  /**
+   * Commit the current token.
+   */
+  commit() {
+    _assert2.default.call(void 0, this.currentToken != null || this.expressionStartToken != null);
+    let token = this.currentToken;
+    this.currentToken = null;
+    this.attribute = null;
+    if (this.expressionStartToken != null) {
+      const start = this.expressionStartToken;
+      const end = (0, import_last2.default)(this.expressionTokens) || start;
+      const value = this.expressionTokens.reduce(concat, start.value);
+      this.expressionStartToken = null;
+      this.expressionTokens = [];
+      if (token == null) {
+        token = {
+          type: "Text",
+          range: [start.range[0], end.range[1]],
+          loc: { start: start.loc.start, end: end.loc.end },
+          value
+        };
+      } else if (token.type === "Text") {
+        token.range[1] = end.range[1];
+        token.loc.end = end.loc.end;
+        token.value += value;
+      } else {
+        throw new Error("unreachable");
+      }
+    }
+    return token;
   }
-  const { rawName, range, loc } = argument;
-  try {
-    const { comments, expression, references, tokens } = parseExpression(
-      rawName.slice(1, -1),
-      locationCalculator.getSubCalculatorAfter(range[0] + 1),
-      parserOptions
+  /**
+   * Report an invalid character error.
+   * @param token The invalid token.
+   * @param code The error code.
+   */
+  reportParseError(token, code) {
+    const error = ParseError.fromCode(
+      code,
+      token.range[0],
+      token.loc.start.line,
+      token.loc.start.column
     );
-    node.argument = {
-      type: "VExpressionContainer",
-      range,
-      loc,
-      parent: node,
-      expression,
-      references
-    };
-    if (expression != null) {
-      expression.parent = node.argument;
+    this.errors.push(error);
+    debug("[html] syntax error:", error.message);
+  }
+  /**
+   * Process the given comment token.
+   * @param token The comment token to process.
+   */
+  processComment(token) {
+    this.comments.push(token);
+    if (this.currentToken != null && this.currentToken.type === "Text") {
+      return this.commit();
     }
-    tokens.unshift(
-      createSimpleToken(
-        "Punctuator",
-        range[0],
-        range[0] + 1,
-        "[",
-        locationCalculator
-      )
-    );
-    tokens.push(
-      createSimpleToken(
-        "Punctuator",
-        range[1] - 1,
-        range[1],
-        "]",
-        locationCalculator
-      )
-    );
-    replaceTokens(templateMeta, node.argument, tokens);
-    insertComments(templateMeta, comments);
-  } catch (error) {
-    debug("[template] Parse error: %s", error);
-    if (ParseError.isParseError(error)) {
-      node.argument = {
-        type: "VExpressionContainer",
-        range,
-        loc,
-        parent: node,
-        expression: null,
-        references: []
-      };
-      insertError(templateMeta, error);
-    } else {
-      throw error;
+    return null;
+  }
+  /**
+   * Process the given text token.
+   * @param token The text token to process.
+   */
+  processText(token) {
+    this.tokens.push(token);
+    let result = null;
+    if (this.expressionStartToken != null) {
+      const lastToken = (0, import_last2.default)(this.expressionTokens) || this.expressionStartToken;
+      if (lastToken.range[1] === token.range[0]) {
+        this.expressionTokens.push(token);
+        return null;
+      }
+      result = this.commit();
+    } else if (this.currentToken != null) {
+      if (this.currentToken.type === "Text" && this.currentToken.range[1] === token.range[0]) {
+        this.currentToken.value += token.value;
+        this.currentToken.range[1] = token.range[1];
+        this.currentToken.loc.end = token.loc.end;
+        return null;
+      }
+      result = this.commit();
     }
+    _assert2.default.call(void 0, this.currentToken == null);
+    this.currentToken = {
+      type: "Text",
+      range: [token.range[0], token.range[1]],
+      loc: { start: token.loc.start, end: token.loc.end },
+      value: token.value
+    };
+    return result;
   }
-}
-function createDirectiveKey(node, templateMeta, parserOptions, locationCalculator) {
-  const directiveKey = parseDirectiveKeyStatically(node, templateMeta);
-  const tokens = parseDirectiveKeyTokens(directiveKey);
-  replaceTokens(templateMeta, directiveKey, tokens);
-  if (directiveKey.name.name.startsWith("v-")) {
-    directiveKey.name.name = directiveKey.name.name.slice(2);
+  /**
+   * Process a HTMLAssociation token.
+   * @param token The token to process.
+   */
+  HTMLAssociation(token) {
+    this.tokens.push(token);
+    if (this.attribute != null) {
+      this.attribute.range[1] = token.range[1];
+      this.attribute.loc.end = token.loc.end;
+      if (this.currentToken == null || this.currentToken.type !== "StartTag") {
+        throw new Error("unreachable");
+      }
+      this.currentToken.range[1] = token.range[1];
+      this.currentToken.loc.end = token.loc.end;
+    }
+    return null;
   }
-  if (directiveKey.name.rawName.startsWith("v-")) {
-    directiveKey.name.rawName = directiveKey.name.rawName.slice(2);
+  /**
+   * Process a HTMLBogusComment token.
+   * @param token The token to process.
+   */
+  HTMLBogusComment(token) {
+    return this.processComment(token);
   }
-  convertDynamicArgument(
-    directiveKey,
-    templateMeta,
-    parserOptions,
-    locationCalculator
-  );
-  return directiveKey;
-}
-function convertToDirective(node, code, templateMeta, locationCalculator, vineFixLocationContext, parserOptions) {
-  debug(
-    '[template] convert to directive: %s="%s" %j',
-    node.key.name,
-    node.value && node.value.value,
-    node.range
-  );
-  const directive = node;
-  directive.directive = true;
-  directive.key = createDirectiveKey(
-    node.key,
-    templateMeta,
-    parserOptions,
-    locationCalculator
-  );
-  const { argument } = directive.key;
-  if (argument && argument.type === "VIdentifier" && argument.name.startsWith("[")) {
-    const nextChar = code[argument.range[1]];
-    if (nextChar == null || invalidDynamicArgumentNextChar.test(nextChar)) {
-      const char = nextChar == null ? "EOF" : JSON.stringify(nextChar).slice(1, -1);
-      insertError(
-        templateMeta,
-        new ParseError(
-          `Dynamic argument cannot contain the '${char}' character.`,
-          void 0,
-          argument.range[1],
-          argument.loc.end.line,
-          argument.loc.end.column
-        )
-      );
-    }
+  /**
+   * Process a HTMLCDataText token.
+   * @param token The token to process.
+   */
+  HTMLCDataText(token) {
+    return this.processText(token);
   }
-  if (node.value == null) {
-    return;
+  /**
+   * Process a HTMLComment token.
+   * @param token The token to process.
+   */
+  HTMLComment(token) {
+    return this.processComment(token);
   }
-  try {
-    const ret = parseAttributeValue(
-      code,
-      parserOptions,
-      locationCalculator,
-      node.value,
-      node.parent.parent,
-      directive.key
-    );
-    directive.value = {
-      type: "VExpressionContainer",
-      range: node.value.range,
-      loc: node.value.loc,
-      parent: directive,
-      expression: ret.expression,
-      references: ret.references
+  /**
+   * Process a HTMLEndTagOpen token.
+   * @param token The token to process.
+   */
+  HTMLEndTagOpen(token) {
+    this.tokens.push(token);
+    let result = null;
+    if (this.currentToken != null || this.expressionStartToken != null) {
+      result = this.commit();
+    }
+    this.currentToken = {
+      type: "EndTag",
+      range: [token.range[0], token.range[1]],
+      loc: { start: token.loc.start, end: token.loc.end },
+      name: token.value
     };
-    if (ret.expression != null) {
-      ret.expression.parent = directive.value;
+    return result;
+  }
+  /**
+   * Process a HTMLIdentifier token.
+   * @param token The token to process.
+   */
+  HTMLIdentifier(token) {
+    this.tokens.push(token);
+    if (this.currentToken == null || this.currentToken.type === "Text" || this.currentToken.type === "Mustache") {
+      throw new Error("unreachable");
     }
-    for (const variable of ret.variables) {
-      node.parent.parent.variables.push(variable);
+    if (this.currentToken.type === "EndTag") {
+      this.reportParseError(token, "end-tag-with-attributes");
+      return null;
     }
-    replaceTokens(templateMeta, node.value, ret.tokens);
-    insertComments(templateMeta, ret.comments);
-  } catch (err) {
-    debug("[template] Parse error: %s", err);
-    if (ParseError.isParseError(err)) {
-      directive.value = {
-        type: "VExpressionContainer",
-        range: node.value.range,
-        loc: node.value.loc,
-        parent: directive,
-        expression: null,
-        references: []
+    if (this.attributeNames.has(token.value)) {
+      this.reportParseError(token, "duplicate-attribute");
+    }
+    this.attributeNames.add(token.value);
+    this.attribute = {
+      type: "VAttribute",
+      range: [token.range[0], token.range[1]],
+      loc: { start: token.loc.start, end: token.loc.end },
+      parent: DUMMY_PARENT2,
+      directive: false,
+      key: {
+        type: "VIdentifier",
+        range: [token.range[0], token.range[1]],
+        loc: { start: token.loc.start, end: token.loc.end },
+        parent: DUMMY_PARENT2,
+        name: token.value,
+        rawName: this.text.slice(token.range[0], token.range[1])
+      },
+      value: null
+    };
+    this.attribute.key.parent = this.attribute;
+    this.currentToken.range[1] = token.range[1];
+    this.currentToken.loc.end = token.loc.end;
+    this.currentToken.attributes.push(this.attribute);
+    return null;
+  }
+  /**
+   * Process a HTMLLiteral token.
+   * @param token The token to process.
+   */
+  HTMLLiteral(token) {
+    this.tokens.push(token);
+    if (this.attribute != null) {
+      this.attribute.range[1] = token.range[1];
+      this.attribute.loc.end = token.loc.end;
+      this.attribute.value = {
+        type: "VLiteral",
+        range: [token.range[0], token.range[1]],
+        loc: { start: token.loc.start, end: token.loc.end },
+        parent: this.attribute,
+        value: token.value
       };
-      insertError(templateMeta, err);
-    } else {
-      throw err;
+      if (this.currentToken == null || this.currentToken.type !== "StartTag") {
+        throw new Error("unreachable");
+      }
+      this.currentToken.range[1] = token.range[1];
+      this.currentToken.loc.end = token.loc.end;
     }
+    return null;
   }
-}
-function processMustache(parserOptions, globalLocationCalculator, vineFixLocationContext, templateMeta, node, mustache) {
-  const range = [
-    mustache.startToken.range[1],
-    mustache.endToken.range[0]
-  ];
-  debug("[template] convert mustache {{%s}} %j", mustache.value, range);
-  try {
-    const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(range[0]);
-    const ret = parseExpression(
-      mustache.value,
-      locationCalculator,
-      parserOptions,
-      { allowEmpty: true, allowFilters: true }
-    );
-    node.expression = ret.expression || null;
-    node.references = ret.references;
-    if (ret.expression != null) {
-      ret.expression.parent = node;
+  /**
+   * Process a HTMLRCDataText token.
+   * @param token The token to process.
+   */
+  HTMLRCDataText(token) {
+    return this.processText(token);
+  }
+  /**
+   * Process a HTMLRawText token.
+   * @param token The token to process.
+   */
+  HTMLRawText(token) {
+    return this.processText(token);
+  }
+  /**
+   * Process a HTMLSelfClosingTagClose token.
+   * @param token The token to process.
+   */
+  HTMLSelfClosingTagClose(token) {
+    this.tokens.push(token);
+    if (this.currentToken == null || this.currentToken.type === "Text") {
+      throw new Error("unreachable");
     }
-    replaceTokens(templateMeta, { range }, ret.tokens);
-    insertComments(templateMeta, ret.comments);
-  } catch (err) {
-    debug("[template] Parse error: %s", err);
-    if (ParseError.isParseError(err)) {
-      insertError(templateMeta, err);
+    if (this.currentToken.type === "StartTag") {
+      this.currentToken.selfClosing = true;
     } else {
-      throw err;
+      this.reportParseError(token, "end-tag-with-trailing-solidus");
     }
+    this.currentToken.range[1] = token.range[1];
+    this.currentToken.loc.end = token.loc.end;
+    return this.commit();
   }
-}
-function resolveReference(referene, element) {
-  let node = element;
-  while (node != null && node.type === "VElement") {
-    for (const variable of node.variables) {
-      if (variable.id.name === referene.id.name) {
-        referene.variable = variable;
-        variable.references.push(referene);
-        return;
-      }
+  /**
+   * Process a HTMLTagClose token.
+   * @param token The token to process.
+   */
+  HTMLTagClose(token) {
+    this.tokens.push(token);
+    if (this.currentToken == null || this.currentToken.type === "Text") {
+      throw new Error("unreachable");
     }
-    node = node.parent;
+    this.currentToken.range[1] = token.range[1];
+    this.currentToken.loc.end = token.loc.end;
+    return this.commit();
   }
-}
-function resolveReferences(container) {
-  let element = container.parent;
-  while (element != null && element.type !== "VElement") {
-    element = element.parent;
+  /**
+   * Process a HTMLTagOpen token.
+   * @param token The token to process.
+   */
+  HTMLTagOpen(token) {
+    this.tokens.push(token);
+    let result = null;
+    if (this.currentToken != null || this.expressionStartToken != null) {
+      result = this.commit();
+    }
+    this.currentToken = {
+      type: "StartTag",
+      range: [token.range[0], token.range[1]],
+      loc: { start: token.loc.start, end: token.loc.end },
+      name: token.value,
+      rawName: this.text.slice(token.range[0] + 1, token.range[1]),
+      selfClosing: false,
+      attributes: []
+    };
+    this.attribute = null;
+    this.attributeNames.clear();
+    return result;
   }
-  if (element != null) {
-    for (const reference of container.references) {
-      resolveReference(reference, element);
+  /**
+   * Process a HTMLText token.
+   * @param token The token to process.
+   */
+  HTMLText(token) {
+    return this.processText(token);
+  }
+  /**
+   * Process a HTMLWhitespace token.
+   * @param token The token to process.
+   */
+  HTMLWhitespace(token) {
+    return this.processText(token);
+  }
+  /**
+   * Process a VExpressionStart token.
+   * @param token The token to process.
+   */
+  VExpressionStart(token) {
+    if (this.expressionStartToken != null) {
+      return this.processText(token);
     }
+    const separated = this.currentToken != null && this.currentToken.range[1] !== token.range[0];
+    const result = separated ? this.commit() : null;
+    this.tokens.push(token);
+    this.expressionStartToken = token;
+    return result;
   }
-}
+  /**
+   * Process a VExpressionEnd token.
+   * @param token The token to process.
+   */
+  VExpressionEnd(token) {
+    if (this.expressionStartToken == null) {
+      return this.processText(token);
+    }
+    const start = this.expressionStartToken;
+    const end = (0, import_last2.default)(this.expressionTokens) || start;
+    if (token.range[0] === start.range[1]) {
+      this.tokens.pop();
+      this.expressionStartToken = null;
+      const result2 = this.processText(start);
+      this.processText(token);
+      return result2;
+    }
+    if (end.range[1] !== token.range[0]) {
+      const result2 = this.commit();
+      this.processText(token);
+      return result2;
+    }
+    const value = this.expressionTokens.reduce(concat, "");
+    this.tokens.push(token);
+    this.expressionStartToken = null;
+    this.expressionTokens = [];
+    const result = this.currentToken != null ? this.commit() : null;
+    this.currentToken = {
+      type: "Mustache",
+      range: [start.range[0], token.range[1]],
+      loc: { start: start.loc.start, end: token.loc.end },
+      value,
+      startToken: start,
+      endToken: token
+    };
+    return result || this.commit();
+  }
+};
 
 // src/template/utils/attribute-names.ts
 var SVG_ATTRIBUTE_NAME_MAP = /* @__PURE__ */ new Map([