@vue-vine/eslint-parser 0.1.32 → 0.2.0

package/dist/index.mjs

@@ -2340,32 +2340,6 @@ var require_sortedLastIndex = __commonJS({
   }
 });
 
-// ../../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 sortedIndexBy4(array, value, iteratee) {
-      return baseSortedIndexBy(array, value, baseIteratee(iteratee, 2));
-    }
-    module.exports = sortedIndexBy4;
-  }
-});
-
-// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/sortedLastIndexBy.js
-var require_sortedLastIndexBy = __commonJS({
-  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/sortedLastIndexBy.js"(exports, module) {
-    "use strict";
-    var baseIteratee = require_baseIteratee();
-    var baseSortedIndexBy = require_baseSortedIndexBy();
-    function sortedLastIndexBy2(array, value, iteratee) {
-      return baseSortedIndexBy(array, value, baseIteratee(iteratee, 2), true);
-    }
-    module.exports = sortedLastIndexBy2;
-  }
-});
-
 // ../../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) {
@@ -2385,6 +2359,19 @@ var require_first = __commonJS({
   }
 });
 
+// ../../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
 import { parseForESLint as tsParseForESLint } from "@typescript-eslint/parser";
 
@@ -3858,24 +3845,12 @@ var IntermediateTokenizer = class {
 };
 
 // src/common/error-utils.ts
-var import_sortedIndexBy = __toESM(require_sortedIndexBy());
-function byIndex(x) {
-  return x.index;
-}
 function insertError(templateMeta, error) {
-  const index = (0, import_sortedIndexBy.default)(templateMeta.errors, error, byIndex);
+  const index = templateMeta.errors.findIndex((e) => e.index === error.index);
   templateMeta.errors.splice(index, 0, error);
 }
 
 // src/common/token-utils.ts
-var import_sortedIndexBy2 = __toESM(require_sortedIndexBy());
-var import_sortedLastIndexBy = __toESM(require_sortedLastIndexBy());
-function byRange0(x) {
-  return x.range[0];
-}
-function byRange1(x) {
-  return x.range[1];
-}
 function createSimpleToken(type, start, end, value, linesAndColumns) {
   return {
     type,
@@ -3891,144 +3866,22 @@ function insertComments(templateMeta, newComments) {
   if (newComments.length === 0) {
     return;
   }
-  const index = (0, import_sortedIndexBy2.default)(templateMeta.comments, newComments[0], byRange0);
+  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 = (0, import_sortedIndexBy2.default)(templateMeta.tokens, node, byRange0);
-  const count = (0, import_sortedLastIndexBy.default)(templateMeta.tokens, node, byRange1) - index;
+  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_sortedIndexBy3 = __toESM(require_sortedIndexBy());
+var import_sortedIndexBy = __toESM(require_sortedIndexBy());
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
-// src/template/utils/process-vine-template-node.ts
-import { simpleTraverse as traverse2, TSESTree } from "@typescript-eslint/typescript-estree";
-function fixVineOffset(token, fixCtx) {
-  const {
-    posInfo: {
-      templateStartOffset,
-      templateStartLine,
-      templateStartColumn
-    },
-    fixedCache: cache
-  } = fixCtx;
-  if (token.type !== "VTemplateRoot") {
-    if (!cache.has(token.range)) {
-      token.range[0] += templateStartOffset;
-      token.range[1] += templateStartOffset;
-      cache.add(token.range);
-    }
-    if (!cache.has(token.loc.start)) {
-      token.loc.start.line += templateStartLine - 1;
-      token.loc.start.column = token.loc.start.line === templateStartLine ? templateStartColumn + token.loc.start.column : token.loc.start.column;
-      cache.add(token.loc.start);
-    }
-    if (!cache.has(token.loc.end)) {
-      token.loc.end.line += templateStartLine - 1;
-      token.loc.end.column = token.loc.end.line === templateStartLine ? templateStartColumn + token.loc.end.column : token.loc.end.column;
-      cache.add(token.loc.end);
-    }
-  }
-}
-function extractForVineTemplate(ast) {
-  const extractVineTemplateResult = [];
-  const extractedTemplateNodes = /* @__PURE__ */ new WeakSet();
-  try {
-    traverse2(ast, {
-      enter(node, parent) {
-        if (node.type === "TaggedTemplateExpression" && node.tag.type === "Identifier" && node.tag.name === "vine") {
-          const templateNode = node;
-          if (extractedTemplateNodes.has(templateNode)) {
-            return;
-          }
-          extractedTemplateNodes.add(templateNode);
-          let parentOfTemplate;
-          let bindVineTemplateESTree;
-          if (parent?.type === TSESTree.AST_NODE_TYPES.ReturnStatement) {
-            parent.argument = null;
-            parentOfTemplate = parent;
-            bindVineTemplateESTree = ({ templateRootAST: vineESTree, templateMeta: _, ...templateInfo }) => {
-              parent.argument = vineESTree;
-              vineESTree.parent = parent;
-              vineESTree.templateInfo = templateInfo;
-            };
-          } else if (parent?.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) {
-            parent.body = null;
-            parentOfTemplate = parent;
-            bindVineTemplateESTree = ({ templateRootAST: vineESTree, templateMeta: _, ...templateInfo }) => {
-              parent.body = vineESTree;
-              vineESTree.parent = parent;
-              vineESTree.templateInfo = templateInfo;
-            };
-          }
-          ast.tokens = ast.tokens?.filter(
-            (token) => token.range[0] < node.range[0] || token.range[1] > node.range[1]
-          );
-          if (parentOfTemplate && bindVineTemplateESTree) {
-            extractVineTemplateResult.push({
-              templateNode,
-              parentOfTemplate,
-              bindVineTemplateESTree
-            });
-          }
-        }
-      }
-    }, true);
-  } catch (err) {
-    if (!(err instanceof Error) || err.message !== "BREAK_TRAVERSE") {
-      throw err;
-    }
-  }
-  return extractVineTemplateResult;
-}
-function prepareTemplate(templateNode) {
-  const { quasi: { quasis } } = templateNode;
-  const templateRawNode = quasis[0];
-  const templateRawContent = templateRawNode.value.raw;
-  const templateStartLine = templateRawNode.loc.start.line;
-  const templateEndLine = templateRawNode.loc.end.line;
-  const templateStartColumn = templateRawNode.loc.start.column + 1;
-  const templateStartOffset = templateRawNode.range[0] + 1;
-  const templateEndColumn = templateRawNode.loc.end.column - 1;
-  const templateEndOffset = templateRawNode.range[1] - 1;
-  return {
-    templatePositionInfo: {
-      templateStartLine,
-      templateStartColumn,
-      templateStartOffset,
-      templateEndOffset,
-      templateEndLine,
-      templateEndColumn
-    },
-    templateRawContent
-  };
-}
-
 // src/common/fix-locations.ts
-function fixVineOffsetForScript(result, vineFixLocationContext) {
-  const traversed = /* @__PURE__ */ new WeakSet();
-  traverseNodes(result.ast, {
-    visitorKeys: result.visitorKeys,
-    enterNode(node) {
-      if (!traversed.has(node)) {
-        fixVineOffset(node, vineFixLocationContext);
-      }
-    },
-    leaveNode() {
-    }
-  });
-  for (const token of result.ast.tokens || []) {
-    fixVineOffset(token, vineFixLocationContext);
-  }
-  for (const comment of result.ast.comments || []) {
-    fixVineOffset(comment, vineFixLocationContext);
-  }
-}
 function fixLocations(result, locationCalculator) {
   fixNodeLocations(result.ast, result.visitorKeys, locationCalculator);
   for (const token of result.ast.tokens || []) {
@@ -4141,7 +3994,7 @@ function processVForAliasAndIterator(code) {
   };
 }
 function getCommaTokenBeforeNode(tokens, node) {
-  let tokenIndex = (0, import_sortedIndexBy3.default)(
+  let tokenIndex = (0, import_sortedIndexBy.default)(
     tokens,
     { range: node.range },
     (t) => t.range[0]
@@ -4186,14 +4039,13 @@ function throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator) {
   }
   throw err;
 }
-function parseScriptFragment(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseScriptFragment(code, locationCalculator, parserOptions) {
   try {
     const result = parseScript(
       code,
       parserOptions
     );
     fixLocations(result, locationCalculator);
-    fixVineOffsetForScript(result, vineFixLocationContext);
     return result;
   } catch (err) {
     const perr = ParseError.normalize(err);
@@ -4287,13 +4139,12 @@ function splitFilters(exp) {
   result.push(exp.slice(lastFilterIndex));
   return result;
 }
-function parseExpressionBody(code, locationCalculator, vineFixLocationContext, parserOptions, allowEmpty = false) {
+function parseExpressionBody(code, locationCalculator, parserOptions, allowEmpty = false) {
   debug('[script] parse expression: "0(%s)"', code);
   try {
     const result = parseScriptFragment(
       `0(${code})`,
       locationCalculator.getSubCalculatorShift(-2),
-      vineFixLocationContext,
       parserOptions
     );
     const { ast } = result;
@@ -4319,13 +4170,12 @@ function parseExpressionBody(code, locationCalculator, vineFixLocationContext, p
     tokens.shift();
     tokens.shift();
     tokens.pop();
-    fixVineOffset(expression, vineFixLocationContext);
     return { expression, tokens, comments, references, variables: [] };
   } catch (err) {
     return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
 }
-function parseFilter(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseFilter(code, locationCalculator, parserOptions) {
   debug('[script] parse filter: "%s"', code);
   try {
     const expression = {
@@ -4350,7 +4200,6 @@ function parseFilter(code, locationCalculator, vineFixLocationContext, parserOpt
       const { ast } = parseScriptFragment(
         `"${calleeCode.trim()}"`,
         subCalculator,
-        vineFixLocationContext,
         parserOptions
       );
       const statement = ast.body[0];
@@ -4394,7 +4243,6 @@ function parseFilter(code, locationCalculator, vineFixLocationContext, parserOpt
       const result = parseScriptFragment(
         `0${argsCode}`,
         locationCalculator.getSubCalculatorAfter(paren).getSubCalculatorShift(-1),
-        vineFixLocationContext,
         parserOptions
       );
       const { ast } = result;
@@ -4451,14 +4299,13 @@ function parseScript(code, parserOptions) {
   }
   return { ast: result };
 }
-function parseExpression(code, locationCalculator, vineFixLocationContext, parserOptions, { allowEmpty = false, allowFilters = false } = {}) {
+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,
-      vineFixLocationContext,
       parserOptions,
       allowEmpty
     );
@@ -4466,7 +4313,6 @@ function parseExpression(code, locationCalculator, vineFixLocationContext, parse
   const retB = parseExpressionBody(
     mainCode,
     locationCalculator,
-    vineFixLocationContext,
     parserOptions
   );
   if (!retB.expression) {
@@ -4498,7 +4344,6 @@ function parseExpression(code, locationCalculator, vineFixLocationContext, parse
     const retF = parseFilter(
       filterCode,
       locationCalculator.getSubCalculatorShift(prevLoc + 1),
-      vineFixLocationContext,
       parserOptions
     );
     if (retF) {
@@ -4517,7 +4362,7 @@ function parseExpression(code, locationCalculator, vineFixLocationContext, parse
   ret.expression.loc.end = lastToken.loc.end;
   return ret;
 }
-function parseVForExpression(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseVForExpression(code, locationCalculator, parserOptions) {
   if (code.trim() === "") {
     throwEmptyError(locationCalculator, "'<alias> in <expression>'");
   }
@@ -4525,7 +4370,6 @@ function parseVForExpression(code, locationCalculator, vineFixLocationContext, p
     return parseVForExpressionForEcmaVersion5(
       code,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions
     );
   }
@@ -4545,7 +4389,6 @@ function parseVForExpression(code, locationCalculator, vineFixLocationContext, p
       locationCalculator.getSubCalculatorShift(
         processed.hasParens ? -8 : -9
       ),
-      vineFixLocationContext,
       parserOptions
     );
     const { ast } = result;
@@ -4602,7 +4445,6 @@ function parseVForExpression(code, locationCalculator, vineFixLocationContext, p
       }
     }
     right.parent = expression;
-    fixVineOffset(expression, vineFixLocationContext);
     return { expression, tokens, comments, references, variables };
   } catch (err) {
     return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
@@ -4612,7 +4454,7 @@ function isEcmaVersion5(parserOptions) {
   const ecmaVersion = getEcmaVersionIfUseEspree(parserOptions);
   return ecmaVersion != null && ecmaVersion <= 5;
 }
-function parseVForExpressionForEcmaVersion5(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseVForExpressionForEcmaVersion5(code, locationCalculator, parserOptions) {
   const processed = processVForAliasAndIterator(code);
   if (!processed.aliases.trim()) {
     return throwEmptyError(locationCalculator, "an alias");
@@ -4625,7 +4467,6 @@ function parseVForExpressionForEcmaVersion5(code, locationCalculator, vineFixLoc
       locationCalculator.getSubCalculatorShift(
         processed.hasParens ? 0 : -1
       ),
-      vineFixLocationContext,
       parserOptions
     );
     if (processed.hasParens) {
@@ -4665,7 +4506,6 @@ function parseVForExpressionForEcmaVersion5(code, locationCalculator, vineFixLoc
     const parsedIterator = parseVForIteratorForEcmaVersion5(
       processed.iterator,
       locationCalculator.getSubCalculatorShift(delimiterEnd),
-      vineFixLocationContext,
       parserOptions
     );
     tokens.push(...parsedIterator.tokens);
@@ -4692,11 +4532,10 @@ function parseVForExpressionForEcmaVersion5(code, locationCalculator, vineFixLoc
     return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
 }
-function parseVForAliasesForEcmaVersion5(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseVForAliasesForEcmaVersion5(code, locationCalculator, parserOptions) {
   const result = parseScriptFragment(
     `0(${code})`,
     locationCalculator.getSubCalculatorShift(-2),
-    vineFixLocationContext,
     parserOptions
   );
   const { ast } = result;
@@ -4733,11 +4572,10 @@ function parseVForAliasesForEcmaVersion5(code, locationCalculator, vineFixLocati
     return ret;
   }
 }
-function parseVForIteratorForEcmaVersion5(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseVForIteratorForEcmaVersion5(code, locationCalculator, parserOptions) {
   const result = parseScriptFragment(
     `0(${code})`,
     locationCalculator.getSubCalculatorShift(-2),
-    vineFixLocationContext,
     parserOptions
   );
   const { ast } = result;
@@ -4759,23 +4597,21 @@ function parseVForIteratorForEcmaVersion5(code, locationCalculator, vineFixLocat
   tokens.pop();
   return { right, tokens, comments, references };
 }
-function parseVOnExpression(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseVOnExpression(code, locationCalculator, parserOptions) {
   if (IS_FUNCTION_EXPRESSION.test(code) || IS_SIMPLE_PATH.test(code)) {
     return parseExpressionBody(
       code,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions
     );
   }
   return parseVOnExpressionBody(
     code,
     locationCalculator,
-    vineFixLocationContext,
     parserOptions
   );
 }
-function parseVOnExpressionBody(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseVOnExpressionBody(code, locationCalculator, parserOptions) {
   debug('[script] parse v-on expression: "void function($event){%s}"', code);
   if (code.trim() === "") {
     throwEmptyError(locationCalculator, "statements");
@@ -4784,7 +4620,6 @@ function parseVOnExpressionBody(code, locationCalculator, vineFixLocationContext
     const result = parseScriptFragment(
       `void function($event){${code}}`,
       locationCalculator.getSubCalculatorShift(-22),
-      vineFixLocationContext,
       parserOptions
     );
     const { ast } = result;
@@ -4815,13 +4650,12 @@ function parseVOnExpressionBody(code, locationCalculator, vineFixLocationContext
     }
     tokens.splice(0, 6);
     tokens.pop();
-    fixVineOffset(expression, vineFixLocationContext);
     return { expression, tokens, comments, references, variables: [] };
   } catch (err) {
     return throwErrorAsAdjustingOutsideOfCode(err, code, locationCalculator);
   }
 }
-function parseSlotScopeExpression(code, locationCalculator, vineFixLocationContext, parserOptions) {
+function parseSlotScopeExpression(code, locationCalculator, parserOptions) {
   debug('[script] parse slot-scope expression: "void function(%s) {}"', code);
   if (code.trim() === "") {
     throwEmptyError(
@@ -4833,7 +4667,6 @@ function parseSlotScopeExpression(code, locationCalculator, vineFixLocationConte
     const result = parseScriptFragment(
       `void function(${code}) {}`,
       locationCalculator.getSubCalculatorShift(-14),
-      vineFixLocationContext,
       parserOptions
     );
     const { ast } = result;
@@ -4906,7 +4739,7 @@ function getStandardDirectiveKind(element, directiveKey) {
   }
   return null;
 }
-function parseAttributeValue(code, parserOptions, globalLocationCalculator, vineFixLocationContext, node, element, directiveKey) {
+function parseAttributeValue(code, parserOptions, globalLocationCalculator, node, element, directiveKey) {
   const firstChar = code[node.range[0]];
   const quoted = firstChar === '"' || firstChar === "'";
   const locationCalculator = globalLocationCalculator.getSubCalculatorAfter(
@@ -4929,28 +4762,24 @@ function parseAttributeValue(code, parserOptions, globalLocationCalculator, vine
     result = parseVForExpression(
       node.value,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions
     );
   } else if (directiveKind === "on" && directiveKey.argument != null) {
     result = parseVOnExpression(
       node.value,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions
     );
   } else if (directiveKind === "slot") {
     result = parseSlotScopeExpression(
       node.value,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions
     );
   } else if (directiveKind === "bind") {
     result = parseExpression(
       node.value,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions,
       { allowFilters: true }
     );
@@ -4958,7 +4787,6 @@ function parseAttributeValue(code, parserOptions, globalLocationCalculator, vine
     result = parseExpression(
       node.value,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions
     );
   }
@@ -4984,7 +4812,7 @@ function parseAttributeValue(code, parserOptions, globalLocationCalculator, vine
   }
   return result;
 }
-function parseDirectiveKeyStatically(node, templateMeta, vineFixLocationContext) {
+function parseDirectiveKeyStatically(node, templateMeta) {
   const {
     name: text,
     rawName: rawText,
@@ -5002,9 +4830,8 @@ function parseDirectiveKeyStatically(node, templateMeta, vineFixLocationContext)
     argument: null,
     modifiers: []
   };
-  fixVineOffset(directiveKey, vineFixLocationContext);
   let i = 0;
-  function createIdentifier(vineFixLocationContext2, start, end, name) {
+  function createIdentifier(start, end, name) {
     const id = {
       type: "VIdentifier",
       parent: directiveKey,
@@ -5016,29 +4843,28 @@ function parseDirectiveKeyStatically(node, templateMeta, vineFixLocationContext)
       name: name || text.slice(start, end),
       rawName: rawText.slice(start, end)
     };
-    fixVineOffset(id, vineFixLocationContext2);
     return id;
   }
   if (shorthandSign.test(text)) {
     const sign = text[0];
-    directiveKey.name = createIdentifier(vineFixLocationContext, 0, 1, shorthandNameMap[sign]);
+    directiveKey.name = createIdentifier(0, 1, shorthandNameMap[sign]);
     i = 1;
   } else {
     const colon = text.indexOf(":");
     if (colon !== -1) {
-      directiveKey.name = createIdentifier(vineFixLocationContext, 0, colon);
+      directiveKey.name = createIdentifier(0, colon);
       i = colon + 1;
     }
   }
   if (directiveKey.name != null && text[i] === "[") {
     const len = text.slice(i).lastIndexOf("]");
     if (len !== -1) {
-      directiveKey.argument = createIdentifier(vineFixLocationContext, i, i + len + 1);
+      directiveKey.argument = createIdentifier(i, i + len + 1);
       i = i + len + 1 + (text[i + len + 1] === "." ? 1 : 0);
     }
   }
   const modifiers = text.slice(i).split(".").map((modifierName) => {
-    const modifier = createIdentifier(vineFixLocationContext, i, i + modifierName.length);
+    const modifier = createIdentifier(i, i + modifierName.length);
     if (modifierName === "" && i < text.length) {
       insertError(
         templateMeta,
@@ -5074,7 +4900,7 @@ function parseDirectiveKeyStatically(node, templateMeta, vineFixLocationContext)
   }
   if (directiveKey.name.rawName === "." && !directiveKey.modifiers.some(isPropModifier)) {
     const pos = (directiveKey.argument || directiveKey.name).range[1] - offset;
-    const propModifier = createIdentifier(vineFixLocationContext, pos, pos, "prop");
+    const propModifier = createIdentifier(pos, pos, "prop");
     directiveKey.modifiers.unshift(propModifier);
   }
   return directiveKey;
@@ -5137,7 +4963,7 @@ function parseDirectiveKeyTokens(node) {
   }
   return tokens;
 }
-function convertDynamicArgument(node, templateMeta, parserOptions, locationCalculator, vineFixLocationContext) {
+function convertDynamicArgument(node, templateMeta, parserOptions, locationCalculator) {
   const { argument } = node;
   if (!(argument != null && argument.type === "VIdentifier" && argument.name.startsWith("[") && argument.name.endsWith("]"))) {
     return;
@@ -5147,7 +4973,6 @@ function convertDynamicArgument(node, templateMeta, parserOptions, locationCalcu
     const { comments, expression, references, tokens } = parseExpression(
       rawName.slice(1, -1),
       locationCalculator.getSubCalculatorAfter(range[0] + 1),
-      vineFixLocationContext,
       parserOptions
     );
     node.argument = {
@@ -5158,7 +4983,6 @@ function convertDynamicArgument(node, templateMeta, parserOptions, locationCalcu
       expression,
       references
     };
-    fixVineOffset(node.argument, vineFixLocationContext);
     if (expression != null) {
       expression.parent = node.argument;
     }
@@ -5199,8 +5023,8 @@ function convertDynamicArgument(node, templateMeta, parserOptions, locationCalcu
     }
   }
 }
-function createDirectiveKey(node, templateMeta, parserOptions, locationCalculator, vineFixLocationContext) {
-  const directiveKey = parseDirectiveKeyStatically(node, templateMeta, vineFixLocationContext);
+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-")) {
@@ -5213,8 +5037,7 @@ function createDirectiveKey(node, templateMeta, parserOptions, locationCalculato
     directiveKey,
     templateMeta,
     parserOptions,
-    locationCalculator,
-    vineFixLocationContext
+    locationCalculator
   );
   return directiveKey;
 }
@@ -5231,12 +5054,7 @@ function convertToDirective(node, code, templateMeta, locationCalculator, vineFi
     node.key,
     templateMeta,
     parserOptions,
-    locationCalculator,
-    vineFixLocationContext
-  );
-  fixVineOffset(
-    directive.key,
-    vineFixLocationContext
+    locationCalculator
   );
   const { argument } = directive.key;
   if (argument && argument.type === "VIdentifier" && argument.name.startsWith("[")) {
@@ -5263,7 +5081,6 @@ function convertToDirective(node, code, templateMeta, locationCalculator, vineFi
       code,
       parserOptions,
       locationCalculator,
-      vineFixLocationContext,
       node.value,
       node.parent.parent,
       directive.key
@@ -5276,10 +5093,6 @@ function convertToDirective(node, code, templateMeta, locationCalculator, vineFi
       expression: ret.expression,
       references: ret.references
     };
-    fixVineOffset(
-      directive.value,
-      vineFixLocationContext
-    );
     if (ret.expression != null) {
       ret.expression.parent = directive.value;
     }
@@ -5316,7 +5129,6 @@ function processMustache(parserOptions, globalLocationCalculator, vineFixLocatio
     const ret = parseExpression(
       mustache.value,
       locationCalculator,
-      vineFixLocationContext,
       parserOptions,
       { allowEmpty: true, allowFilters: true }
     );
@@ -5426,6 +5238,128 @@ var MATHML_ATTRIBUTE_NAME_MAP = /* @__PURE__ */ new Map([
   ["definitionurl", "definitionUrl"]
 ]);
 
+// src/template/utils/process-vine-template-node.ts
+import { simpleTraverse as tsESLintTravese, TSESTree } from "@typescript-eslint/typescript-estree";
+function fixVineOffset(token, fixCtx) {
+  const {
+    posInfo: {
+      templateStartOffset,
+      templateStartLine,
+      templateStartColumn
+    },
+    fixedCache: cache
+  } = fixCtx;
+  if (!cache.has(token.range)) {
+    token.range[0] += templateStartOffset;
+    token.range[1] += templateStartOffset;
+    cache.add(token.range);
+    if ("start" in token) {
+      token.start = token.range[0];
+    }
+    if ("end" in token) {
+      token.end = token.range[1];
+    }
+  }
+  if (!cache.has(token.loc.start)) {
+    token.loc.start.line += templateStartLine - 1;
+    token.loc.start.column = token.loc.start.line === templateStartLine ? templateStartColumn + token.loc.start.column : token.loc.start.column;
+    cache.add(token.loc.start);
+  }
+  if (!cache.has(token.loc.end)) {
+    token.loc.end.line += templateStartLine - 1;
+    token.loc.end.column = token.loc.end.line === templateStartLine ? templateStartColumn + token.loc.end.column : token.loc.end.column;
+    cache.add(token.loc.end);
+  }
+}
+function fixFromVineTemplateRoot(root, fixCtx) {
+  traverseNodes(
+    root,
+    {
+      enterNode: (node) => {
+        if (node.type === "VTemplateRoot") {
+          return;
+        }
+        fixVineOffset(node, fixCtx);
+      },
+      leaveNode: () => {
+      }
+    }
+  );
+}
+function extractForVineTemplate(ast) {
+  const extractVineTemplateResult = [];
+  const extractedTemplateNodes = /* @__PURE__ */ new WeakSet();
+  try {
+    tsESLintTravese(ast, {
+      enter(node, parent) {
+        if (node.type === "TaggedTemplateExpression" && node.tag.type === "Identifier" && node.tag.name === "vine") {
+          const templateNode = node;
+          if (extractedTemplateNodes.has(templateNode)) {
+            return;
+          }
+          extractedTemplateNodes.add(templateNode);
+          let parentOfTemplate;
+          let bindVineTemplateESTree;
+          if (parent?.type === TSESTree.AST_NODE_TYPES.ReturnStatement) {
+            parent.argument = null;
+            parentOfTemplate = parent;
+            bindVineTemplateESTree = ({ templateRootAST: vineESTree, templateMeta: _, ...templateInfo }) => {
+              parent.argument = vineESTree;
+              vineESTree.parent = parent;
+              vineESTree.templateInfo = templateInfo;
+            };
+          } else if (parent?.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) {
+            parent.body = null;
+            parentOfTemplate = parent;
+            bindVineTemplateESTree = ({ templateRootAST: vineESTree, templateMeta: _, ...templateInfo }) => {
+              parent.body = vineESTree;
+              vineESTree.parent = parent;
+              vineESTree.templateInfo = templateInfo;
+            };
+          }
+          ast.tokens = ast.tokens?.filter(
+            (token) => token.range[0] < node.range[0] || token.range[1] > node.range[1]
+          );
+          if (parentOfTemplate && bindVineTemplateESTree) {
+            extractVineTemplateResult.push({
+              templateNode,
+              parentOfTemplate,
+              bindVineTemplateESTree
+            });
+          }
+        }
+      }
+    }, true);
+  } catch (err) {
+    if (!(err instanceof Error) || err.message !== "BREAK_TRAVERSE") {
+      throw err;
+    }
+  }
+  return extractVineTemplateResult;
+}
+function prepareTemplate(templateNode) {
+  const { quasi: { quasis } } = templateNode;
+  const templateRawNode = quasis[0];
+  const templateRawContent = templateRawNode.value.raw;
+  const templateStartLine = templateRawNode.loc.start.line;
+  const templateEndLine = templateRawNode.loc.end.line;
+  const templateStartColumn = templateRawNode.loc.start.column + 1;
+  const templateStartOffset = templateRawNode.range[0] + 1;
+  const templateEndColumn = templateRawNode.loc.end.column - 1;
+  const templateEndOffset = templateRawNode.range[1] - 1;
+  return {
+    templatePositionInfo: {
+      templateStartLine,
+      templateStartColumn,
+      templateStartOffset,
+      templateEndOffset,
+      templateEndLine,
+      templateEndColumn
+    },
+    templateRawContent
+  };
+}
+
 // src/template/utils/tag-names.ts
 var HTML_VOID_ELEMENT_TAGS = /* @__PURE__ */ new Set([
   "area",
@@ -5686,9 +5620,10 @@ var VineTemplateParser = class {
   vTemplateMeta;
   templatePos;
   postProcessForScript = [];
-  offsetFixedTokenSet = /* @__PURE__ */ new WeakSet();
-  constructor(parserOptions, tokenizer, parentOfTemplate, templatePos) {
+  offsetFixedTokenSet;
+  constructor(parserOptions, tokenizer, parentOfTemplate, templatePos, offsetFixedTokenSet) {
     this.baseParserOptions = parserOptions;
+    this.offsetFixedTokenSet = offsetFixedTokenSet;
     this.tokenizer = new IntermediateTokenizer(tokenizer, parserOptions);
     this.locationCalculator = new LocationCalculatorForHtml(
       tokenizer.gaps,
@@ -5738,7 +5673,10 @@ var VineTemplateParser = class {
       comment,
       this.fixVineOffsetCtx
     ));
-    fixVineOffset(this.vTemplateRoot, this.fixVineOffsetCtx);
+    fixFromVineTemplateRoot(
+      this.vTemplateRoot,
+      this.fixVineOffsetCtx
+    );
   }
   /**
    * Get the current node.
@@ -6076,13 +6014,13 @@ var VineTemplateParser = class {
       this[token.type](token);
     } while (token != null);
     this.popElementStackUntil(0);
-    this.correctMetaTokenPos();
     const templateRoot = this.vTemplateRoot;
     const templateMeta = this.vTemplateMeta;
     for (const proc of this.postProcessForScript) {
       proc(this.baseParserOptions);
     }
     this.postProcessForScript = [];
+    this.correctMetaTokenPos();
     return [templateRoot, templateMeta];
   }
 };
@@ -10066,7 +10004,7 @@ function prepareForTemplateRootAST(tsFileAST) {
     };
   });
 }
-function getTemplateRootDataList(prepareResult, parserOptions) {
+function getTemplateRootDataList(prepareResult, offsetFixedTokenSet, parserOptions) {
   if (!prepareResult) {
     return null;
   }
@@ -10076,7 +10014,8 @@ function getTemplateRootDataList(prepareResult, parserOptions) {
     parserOptions,
     tokenizer,
     parentOfTemplate,
-    templatePositionInfo
+    templatePositionInfo,
+    offsetFixedTokenSet
   );
   return templateParser.parse();
 }
@@ -10097,6 +10036,7 @@ function runParse(code, parserOptions) {
     code,
     parserOptions
   );
+  const offsetFixedTokenSet = /* @__PURE__ */ new WeakSet();
   const prepareResults = prepareForTemplateRootAST(tsESLintAST);
   for (const prepareResult of prepareResults) {
     const {
@@ -10106,6 +10046,7 @@ function runParse(code, parserOptions) {
     } = prepareResult;
     const rootData = getTemplateRootDataList(
       prepareResult,
+      offsetFixedTokenSet,
       {
         ...parserOptions,
         ...forceEnableLocationOptions