astro-eslint-parser 0.7.4 → 0.8.0

package/lib/index.js

@@ -122,6 +122,19 @@ function isBasicParserObject(value) {
 function maybeTSESLintParserObject(value) {
   return isEnhancedParserObject(value) && isBasicParserObject(value) && typeof value.createProgram === "function" && typeof value.clearCaches === "function" && typeof value.version === "string";
 }
+function isTSESLintParserObject(value) {
+  if (!isEnhancedParserObject(value))
+    return false;
+  try {
+    const result = value.parseForESLint("", {});
+    const services = result.services;
+    return Boolean(
+      services && services.esTreeNodeToTSNodeMap && services.tsNodeToESTreeNodeMap && services.program
+    );
+  } catch {
+    return false;
+  }
+}
 
 // src/parser/script.ts
 function parseScript(code, _ctx, parserOptions) {
@@ -554,51 +567,41 @@ function traverseNodes(node, visitor) {
   traverse(node, null, visitor);
 }
 
-// src/context/script.ts
+// src/context/restore.ts
 var RestoreNodeProcessContext = class {
-  constructor(result, parentMap) {
+  constructor(result, nodeMap) {
     this.removeTokens = /* @__PURE__ */ new Set();
     this.result = result;
-    this.parentMap = parentMap;
+    this.nodeMap = nodeMap;
   }
   addRemoveToken(test) {
     this.removeTokens.add(test);
   }
   getParent(node) {
-    return this.parentMap.get(node) || null;
+    return this.nodeMap.get(node) || null;
   }
 };
-var ScriptContext = class {
+var RestoreContext = class {
   constructor(ctx) {
-    this.script = "";
-    this.consumedIndex = 0;
     this.offsets = [];
-    this.fragments = [];
-    this.tokens = [];
+    this.virtualFragments = [];
     this.restoreNodeProcesses = [];
+    this.tokens = [];
     this.ctx = ctx;
   }
-  get originalCode() {
-    return this.ctx.code;
+  addRestoreNodeProcess(process2) {
+    this.restoreNodeProcesses.push(process2);
   }
-  skipOriginalOffset(offset) {
-    this.consumedIndex += offset;
+  addOffset(offset) {
+    this.offsets.push(offset);
   }
-  appendOriginal(index) {
-    if (this.consumedIndex >= index) {
+  addVirtualFragmentRange(start, end) {
+    const peek = this.virtualFragments[this.virtualFragments.length - 1];
+    if (peek && peek.end === start) {
+      peek.end = end;
       return;
     }
-    this.offsets.push({
-      original: this.consumedIndex,
-      script: this.script.length
-    });
-    this.script += this.ctx.code.slice(this.consumedIndex, index);
-    this.consumedIndex = index;
-  }
-  appendScript(fragment) {
-    const start = this.script.length;
-    this.script += fragment;
-    this.fragments.push({ start, end: this.script.length });
+    this.virtualFragments.push({ start, end });
   }
   addToken(type, range) {
     if (range[0] >= range[1]) {
@@ -606,63 +609,17 @@ var ScriptContext = class {
     }
     this.tokens.push(this.ctx.buildToken(type, range));
   }
-  addRestoreNodeProcess(process2) {
-    this.restoreNodeProcesses.push(process2);
-  }
   restore(result) {
     var _a, _b;
-    const traversed = /* @__PURE__ */ new Map();
-    traverseNodes(result.ast, {
-      visitorKeys: result.visitorKeys,
-      enterNode: (node, p) => {
-        if (!traversed.has(node)) {
-          traversed.set(node, p);
-          this.remapLocation(node);
-        }
-      },
-      leaveNode: (_node) => {
-      }
-    });
-    const tokens = [...this.tokens];
-    for (const token of result.ast.tokens || []) {
-      if (this.fragments.some(
+    const nodeMap = remapLocationsAndGetNodeMap(result, this.tokens, {
+      remapLocation: (n) => this.remapLocation(n),
+      removeToken: (token) => this.virtualFragments.some(
         (f) => f.start <= token.range[0] && token.range[1] <= f.end
-      )) {
-        continue;
-      }
-      this.remapLocation(token);
-      tokens.push(token);
-    }
-    result.ast.tokens = tokens;
-    for (const token of result.ast.comments || []) {
-      this.remapLocation(token);
-    }
-    const context = new RestoreNodeProcessContext(result, traversed);
-    let restoreNodeProcesses = this.restoreNodeProcesses;
-    for (const [node, parent] of traversed) {
-      if (!parent)
-        continue;
-      restoreNodeProcesses = restoreNodeProcesses.filter(
-        (proc) => !proc(node, context)
-      );
-    }
-    if (context.removeTokens.size) {
-      const tokens2 = result.ast.tokens || [];
-      for (let index = tokens2.length - 1; index >= 0; index--) {
-        const token = tokens2[index];
-        for (const rt of context.removeTokens) {
-          if (rt(token)) {
-            tokens2.splice(index, 1);
-            context.removeTokens.delete(rt);
-            if (!context.removeTokens.size) {
-              break;
-            }
-          }
-        }
-      }
-    }
+      )
+    });
+    restoreNodes(result, nodeMap, this.restoreNodeProcesses);
     const firstOffset = Math.min(
-      ...[result.ast.body[0], (_a = result.ast.tokens) == null ? void 0 : _a[0], (_b = result.ast.comments) == null ? void 0 : _b[0]].filter(Boolean).map((t) => t.range[0])
+      ...[result.ast.body[0], (_a = result.ast.tokens) == null ? void 0 : _a[0], (_b = result.ast.comments) == null ? void 0 : _b[0]].filter((t) => Boolean(t)).map((t) => t.range[0])
     );
     if (firstOffset < result.ast.range[0]) {
       result.ast.range[0] = firstOffset;
@@ -671,17 +628,20 @@ var ScriptContext = class {
   }
   remapLocation(node) {
     let [start, end] = node.range;
-    const startFragment = this.fragments.find(
+    const startFragment = this.virtualFragments.find(
       (f) => f.start <= start && start < f.end
     );
     if (startFragment) {
       start = startFragment.end;
     }
-    const endFragment = this.fragments.find(
+    const endFragment = this.virtualFragments.find(
       (f) => f.start < end && end <= f.end
     );
     if (endFragment) {
       end = endFragment.start;
+      if (startFragment === endFragment) {
+        start = startFragment.start;
+      }
     }
     if (end < start) {
       const w = start;
@@ -705,39 +665,128 @@ var ScriptContext = class {
     let lastStart = this.offsets[0];
     let lastEnd = this.offsets[0];
     for (const offset of this.offsets) {
-      if (offset.script <= start) {
+      if (offset.dist <= start) {
         lastStart = offset;
       }
-      if (offset.script < end) {
+      if (offset.dist < end) {
         lastEnd = offset;
       } else {
-        if (offset.script === end) {
-          const remapStart2 = lastStart.original + (start - lastStart.script);
-          if (this.tokens.some(
-            (t) => t.range[0] <= remapStart2 && offset.original <= t.range[1]
-          )) {
-            lastEnd = offset;
-          }
+        if (offset.dist === end && start === end) {
+          lastEnd = offset;
         }
         break;
       }
     }
-    const remapStart = lastStart.original + (start - lastStart.script);
-    const remapEnd = lastEnd.original + (end - lastEnd.script);
+    const remapStart = lastStart.original + (start - lastStart.dist);
+    const remapEnd = lastEnd.original + (end - lastEnd.dist);
+    if (remapEnd < remapStart) {
+      return [remapEnd, remapStart];
+    }
     return [remapStart, remapEnd];
   }
 };
+function remapLocationsAndGetNodeMap(result, restoreTokens, {
+  remapLocation,
+  removeToken
+}) {
+  const traversed = /* @__PURE__ */ new Map();
+  traverseNodes(result.ast, {
+    visitorKeys: result.visitorKeys,
+    enterNode: (node, p) => {
+      if (!traversed.has(node)) {
+        traversed.set(node, p);
+        remapLocation(node);
+      }
+    },
+    leaveNode: (_node) => {
+    }
+  });
+  const tokens = [...restoreTokens];
+  for (const token of result.ast.tokens || []) {
+    if (removeToken(token)) {
+      continue;
+    }
+    remapLocation(token);
+    tokens.push(token);
+  }
+  result.ast.tokens = tokens;
+  for (const token of result.ast.comments || []) {
+    remapLocation(token);
+  }
+  return traversed;
+}
+function restoreNodes(result, nodeMap, restoreNodeProcesses) {
+  const context = new RestoreNodeProcessContext(result, nodeMap);
+  const restoreNodeProcessesSet = new Set(restoreNodeProcesses);
+  for (const [node] of nodeMap) {
+    if (!restoreNodeProcessesSet.size) {
+      break;
+    }
+    for (const proc of [...restoreNodeProcessesSet]) {
+      if (proc(node, context)) {
+        restoreNodeProcessesSet.delete(proc);
+      }
+    }
+  }
+  if (context.removeTokens.size) {
+    const tokens = result.ast.tokens || [];
+    for (let index = tokens.length - 1; index >= 0; index--) {
+      const token = tokens[index];
+      for (const rt of context.removeTokens) {
+        if (rt(token)) {
+          tokens.splice(index, 1);
+          context.removeTokens.delete(rt);
+          if (!context.removeTokens.size) {
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/context/script.ts
+var VirtualScriptContext = class {
+  constructor(ctx) {
+    this.script = "";
+    this.consumedIndex = 0;
+    this.originalCode = ctx.code;
+    this.restoreContext = new RestoreContext(ctx);
+  }
+  skipOriginalOffset(offset) {
+    this.consumedIndex += offset;
+  }
+  skipUntilOriginalOffset(offset) {
+    this.consumedIndex = Math.max(offset, this.consumedIndex);
+  }
+  appendOriginal(index) {
+    if (this.consumedIndex >= index) {
+      return;
+    }
+    this.restoreContext.addOffset({
+      original: this.consumedIndex,
+      dist: this.script.length
+    });
+    this.script += this.originalCode.slice(this.consumedIndex, index);
+    this.consumedIndex = index;
+  }
+  appendVirtualScript(virtualFragment) {
+    const start = this.script.length;
+    this.script += virtualFragment;
+    this.restoreContext.addVirtualFragmentRange(start, this.script.length);
+  }
+};
 
 // src/parser/process-template.ts
 function processTemplate(ctx, resultTemplate) {
   let uniqueIdSeq = 0;
   const usedUniqueIds = /* @__PURE__ */ new Set();
-  const script = new ScriptContext(ctx);
+  const script = new VirtualScriptContext(ctx);
   let fragmentOpened = false;
   function openRootFragment(startOffset) {
-    script.appendScript("<>");
+    script.appendVirtualScript("<>");
     fragmentOpened = true;
-    script.addRestoreNodeProcess((scriptNode, { result }) => {
+    script.restoreContext.addRestoreNodeProcess((scriptNode, { result }) => {
       if (scriptNode.type === import_types.AST_NODE_TYPES.ExpressionStatement && scriptNode.expression.type === import_types.AST_NODE_TYPES.JSXFragment && scriptNode.range[0] === startOffset && result.ast.body.includes(scriptNode)) {
         const index = result.ast.body.indexOf(scriptNode);
         const rootFragment = result.ast.body[index] = scriptNode.expression;
@@ -756,7 +805,7 @@ function processTemplate(ctx, resultTemplate) {
       if (node.type === "frontmatter") {
         const start = node.position.start.offset;
         if (fragmentOpened) {
-          script.appendScript("</>;");
+          script.appendVirtualScript("</>;");
           fragmentOpened = false;
         }
         script.appendOriginal(start);
@@ -765,29 +814,34 @@ function processTemplate(ctx, resultTemplate) {
         const scriptStart = start + 3;
         let scriptEnd = end - 3;
         let endChar;
-        while (scriptStart < scriptEnd - 1 && (endChar = script.originalCode[scriptEnd - 1]) && !endChar.trim()) {
+        while (scriptStart < scriptEnd - 1 && (endChar = ctx.code[scriptEnd - 1]) && !endChar.trim()) {
           scriptEnd--;
         }
         script.appendOriginal(scriptEnd);
-        script.appendScript("\n;");
+        script.appendVirtualScript("\n;");
         script.skipOriginalOffset(end - scriptEnd);
-        script.addRestoreNodeProcess((_scriptNode, { result }) => {
-          for (let index = 0; index < result.ast.body.length; index++) {
-            const st = result.ast.body[index];
-            if (st.type === import_types.AST_NODE_TYPES.EmptyStatement) {
-              if (st.range[0] === scriptEnd && st.range[1] <= end) {
-                result.ast.body.splice(index, 1);
-                break;
+        script.restoreContext.addRestoreNodeProcess(
+          (_scriptNode, { result }) => {
+            for (let index = 0; index < result.ast.body.length; index++) {
+              const st = result.ast.body[index];
+              if (st.type === import_types.AST_NODE_TYPES.EmptyStatement) {
+                if (st.range[0] === scriptEnd && st.range[1] === scriptEnd) {
+                  result.ast.body.splice(index, 1);
+                  break;
+                }
               }
             }
+            return true;
           }
-          return true;
-        });
-        script.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
+        );
+        script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
           node.position.start.offset,
           node.position.start.offset + 3
         ]);
-        script.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [end - 3, end]);
+        script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
+          end - 3,
+          end
+        ]);
       } else if (isTag(node)) {
         if (parent.type === "expression") {
           const index = parent.children.indexOf(node);
@@ -797,8 +851,8 @@ function processTemplate(ctx, resultTemplate) {
             if (after && (isTag(after) || after.type === "comment")) {
               const start2 = node.position.start.offset;
               script.appendOriginal(start2);
-              script.appendScript("<>");
-              script.addRestoreNodeProcess((scriptNode) => {
+              script.appendVirtualScript("<>");
+              script.restoreContext.addRestoreNodeProcess((scriptNode) => {
                 if (scriptNode.range[0] === start2 && scriptNode.type === import_types.AST_NODE_TYPES.JSXFragment) {
                   delete scriptNode.openingFragment;
                   delete scriptNode.closingFragment;
@@ -830,60 +884,62 @@ function processTemplate(ctx, resultTemplate) {
               const start2 = attr.position.start.offset;
               script.appendOriginal(start2 + colonIndex);
               script.skipOriginalOffset(1);
-              script.appendScript(`_`);
-              script.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
+              script.appendVirtualScript(`_`);
+              script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
                 start2,
                 start2 + colonIndex
               ]);
-              script.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
+              script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
                 start2 + colonIndex,
                 start2 + colonIndex + 1
               ]);
-              script.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
+              script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
                 start2 + colonIndex + 1,
                 start2 + attr.name.length
               ]);
-              script.addRestoreNodeProcess((scriptNode, context) => {
-                if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
-                  const baseNameNode = scriptNode.name;
-                  const nsn = {
-                    ...baseNameNode,
-                    type: import_types.AST_NODE_TYPES.JSXNamespacedName,
-                    namespace: {
-                      type: import_types.AST_NODE_TYPES.JSXIdentifier,
-                      name: attr.name.slice(0, colonIndex),
-                      ...ctx.getLocations(
-                        baseNameNode.range[0],
-                        baseNameNode.range[0] + colonIndex
-                      )
-                    },
-                    name: {
-                      type: import_types.AST_NODE_TYPES.JSXIdentifier,
-                      name: attr.name.slice(colonIndex + 1),
-                      ...ctx.getLocations(
-                        baseNameNode.range[0] + colonIndex + 1,
-                        baseNameNode.range[1]
-                      )
-                    }
-                  };
-                  scriptNode.name = nsn;
-                  nsn.namespace.parent = nsn;
-                  nsn.name.parent = nsn;
-                  context.addRemoveToken(
-                    (token) => token.range[0] === baseNameNode.range[0] && token.range[1] === baseNameNode.range[1]
-                  );
-                  return true;
+              script.restoreContext.addRestoreNodeProcess(
+                (scriptNode, context) => {
+                  if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
+                    const baseNameNode = scriptNode.name;
+                    const nsn = {
+                      ...baseNameNode,
+                      type: import_types.AST_NODE_TYPES.JSXNamespacedName,
+                      namespace: {
+                        type: import_types.AST_NODE_TYPES.JSXIdentifier,
+                        name: attr.name.slice(0, colonIndex),
+                        ...ctx.getLocations(
+                          baseNameNode.range[0],
+                          baseNameNode.range[0] + colonIndex
+                        )
+                      },
+                      name: {
+                        type: import_types.AST_NODE_TYPES.JSXIdentifier,
+                        name: attr.name.slice(colonIndex + 1),
+                        ...ctx.getLocations(
+                          baseNameNode.range[0] + colonIndex + 1,
+                          baseNameNode.range[1]
+                        )
+                      }
+                    };
+                    scriptNode.name = nsn;
+                    nsn.namespace.parent = nsn;
+                    nsn.name.parent = nsn;
+                    context.addRemoveToken(
+                      (token) => token.range[0] === baseNameNode.range[0] && token.range[1] === baseNameNode.range[1]
+                    );
+                    return true;
+                  }
+                  return false;
                 }
-                return false;
-              });
+              );
             }
           }
           if (attr.kind === "shorthand") {
             const start2 = attr.position.start.offset;
             script.appendOriginal(start2);
             const jsxName = /[\s"'[\]{}]/u.test(attr.name) ? generateUniqueId(attr.name) : attr.name;
-            script.appendScript(`${jsxName}=`);
-            script.addRestoreNodeProcess((scriptNode) => {
+            script.appendVirtualScript(`${jsxName}=`);
+            script.restoreContext.addRestoreNodeProcess((scriptNode) => {
               if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
                 const attrNode = scriptNode;
                 attrNode.type = "AstroShorthandAttribute";
@@ -904,10 +960,10 @@ function processTemplate(ctx, resultTemplate) {
             const start2 = calcAttributeValueStartOffset(attr, ctx);
             const end = calcAttributeEndOffset(attr, ctx);
             script.appendOriginal(start2);
-            script.appendScript("{");
+            script.appendVirtualScript("{");
             script.appendOriginal(end);
-            script.appendScript("}");
-            script.addRestoreNodeProcess((scriptNode) => {
+            script.appendVirtualScript("}");
+            script.restoreContext.addRestoreNodeProcess((scriptNode) => {
               if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
                 const attrNode = scriptNode;
                 attrNode.type = "AstroTemplateLiteralAttribute";
@@ -920,7 +976,7 @@ function processTemplate(ctx, resultTemplate) {
         const closing = getSelfClosingTag(node, ctx);
         if (closing && closing.end === ">") {
           script.appendOriginal(closing.offset - 1);
-          script.appendScript("/");
+          script.appendVirtualScript("/");
         }
         if (node.name === "script" || node.name === "style") {
           const text = node.children[0];
@@ -929,7 +985,7 @@ function processTemplate(ctx, resultTemplate) {
             const start2 = text.position.start.offset;
             script.appendOriginal(start2);
             script.skipOriginalOffset(text.value.length);
-            script.addRestoreNodeProcess((scriptNode) => {
+            script.restoreContext.addRestoreNodeProcess((scriptNode) => {
               if (scriptNode.type === import_types.AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
                 const textNode = {
                   type: "AstroRawText",
@@ -943,7 +999,7 @@ function processTemplate(ctx, resultTemplate) {
               }
               return false;
             });
-            script.addToken(import_types.AST_TOKEN_TYPES.JSXText, [
+            script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXText, [
               start2,
               start2 + text.value.length
             ]);
@@ -958,10 +1014,10 @@ function processTemplate(ctx, resultTemplate) {
           openRootFragment(start);
         }
         script.appendOriginal(start + 1);
-        script.appendScript(`></`);
+        script.appendVirtualScript(`></`);
         script.skipOriginalOffset(length - 2);
         script.appendOriginal(end);
-        script.addRestoreNodeProcess((scriptNode, context) => {
+        script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
           if (scriptNode.range[0] === start && scriptNode.type === import_types.AST_NODE_TYPES.JSXFragment) {
             delete scriptNode.children;
             delete scriptNode.openingFragment;
@@ -980,7 +1036,7 @@ function processTemplate(ctx, resultTemplate) {
           }
           return false;
         });
-        script.addToken("HTMLComment", [
+        script.restoreContext.addToken("HTMLComment", [
           start,
           start + length
         ]);
@@ -993,10 +1049,10 @@ function processTemplate(ctx, resultTemplate) {
           openRootFragment(start);
         }
         script.appendOriginal(start + 1);
-        script.appendScript(`></`);
+        script.appendVirtualScript(`></`);
         script.skipOriginalOffset(length - 2);
         script.appendOriginal(end);
-        script.addRestoreNodeProcess((scriptNode, context) => {
+        script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
           if (scriptNode.range[0] === start && scriptNode.type === import_types.AST_NODE_TYPES.JSXFragment) {
             delete scriptNode.children;
             delete scriptNode.openingFragment;
@@ -1014,7 +1070,10 @@ function processTemplate(ctx, resultTemplate) {
           }
           return false;
         });
-        script.addToken("HTMLDocType", [start, end]);
+        script.restoreContext.addToken("HTMLDocType", [
+          start,
+          end
+        ]);
       } else {
         const start = node.position.start.offset;
         script.appendOriginal(start);
@@ -1031,15 +1090,17 @@ function processTemplate(ctx, resultTemplate) {
           if (!end) {
             const offset = calcContentEndOffset(node, ctx);
             script.appendOriginal(offset);
-            script.appendScript(`</${node.name}>`);
-            script.addRestoreNodeProcess((scriptNode, context) => {
-              const parent2 = context.getParent(scriptNode);
-              if (scriptNode.range[0] === offset && scriptNode.type === import_types.AST_NODE_TYPES.JSXClosingElement && parent2.type === import_types.AST_NODE_TYPES.JSXElement) {
-                parent2.closingElement = null;
-                return true;
+            script.appendVirtualScript(`</${node.name}>`);
+            script.restoreContext.addRestoreNodeProcess(
+              (scriptNode, context) => {
+                const parent2 = context.getParent(scriptNode);
+                if (scriptNode.range[0] === offset && scriptNode.type === import_types.AST_NODE_TYPES.JSXClosingElement && parent2.type === import_types.AST_NODE_TYPES.JSXElement) {
+                  parent2.closingElement = null;
+                  return true;
+                }
+                return false;
               }
-              return false;
-            });
+            );
           }
         }
       }
@@ -1051,7 +1112,7 @@ function processTemplate(ctx, resultTemplate) {
           if (before && (isTag(before) || before.type === "comment")) {
             const end = getEndOffset(node, ctx);
             script.appendOriginal(end);
-            script.appendScript("</>");
+            script.appendVirtualScript("</>");
           }
         }
       }
@@ -1061,7 +1122,7 @@ function processTemplate(ctx, resultTemplate) {
     const last = resultTemplate.ast.children[resultTemplate.ast.children.length - 1];
     const end = getEndOffset(last, ctx);
     script.appendOriginal(end);
-    script.appendScript("</>");
+    script.appendVirtualScript("</>;");
   }
   script.appendOriginal(ctx.code.length);
   return script;
@@ -1075,13 +1136,54 @@ function processTemplate(ctx, resultTemplate) {
   }
 }
 
+// src/util/index.ts
+function sortedLastIndex(array, compare) {
+  let lower = 0;
+  let upper = array.length;
+  while (lower < upper) {
+    const mid = Math.floor(lower + (upper - lower) / 2);
+    const target = compare(array[mid]);
+    if (target < 0) {
+      lower = mid + 1;
+    } else if (target > 0) {
+      upper = mid;
+    } else {
+      return mid + 1;
+    }
+  }
+  return upper;
+}
+function addElementToSortedArray(array, element, compare) {
+  const index = sortedLastIndex(array, (target) => compare(target, element));
+  array.splice(index, 0, element);
+}
+function addElementsToSortedArray(array, elements, compare) {
+  if (!elements.length) {
+    return;
+  }
+  let last = elements[0];
+  let index = sortedLastIndex(array, (target) => compare(target, last));
+  for (const element of elements) {
+    if (compare(last, element) > 0) {
+      index = sortedLastIndex(array, (target) => compare(target, element));
+    }
+    let e = array[index];
+    while (e && compare(e, element) <= 0) {
+      e = array[++index];
+    }
+    array.splice(index, 0, element);
+    last = element;
+  }
+}
+
 // src/context/index.ts
 var Context = class {
-  constructor(code) {
+  constructor(code, filePath) {
     this.locsMap = /* @__PURE__ */ new Map();
     this.state = {};
     this.locs = new LinesAndColumns(code);
     this.code = code;
+    this.filePath = filePath;
   }
   getLocFromIndex(index) {
     let loc = this.locsMap.get(index);
@@ -1153,7 +1255,10 @@ ${next}`;
     this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
   }
   getLocFromIndex(index) {
-    const lineNumber = sortedLastIndex(this.lineStartIndices, index);
+    const lineNumber = sortedLastIndex(
+      this.lineStartIndices,
+      (target) => target - index
+    );
     return {
       line: lineNumber,
       column: index - this.lineStartIndices[lineNumber - 1]
@@ -1197,22 +1302,6 @@ var NormalizedLineFeed = class {
     }
   }
 };
-function sortedLastIndex(array, value) {
-  let lower = 0;
-  let upper = array.length;
-  while (lower < upper) {
-    const mid = Math.floor(lower + (upper - lower) / 2);
-    const target = array[mid];
-    if (target < value) {
-      lower = mid + 1;
-    } else if (target > value) {
-      upper = mid;
-    } else {
-      return mid + 1;
-    }
-  }
-  return upper;
-}
 
 // src/parser/astro-parser/parse.ts
 var service = __toESM(require("astrojs-compiler-sync"));
@@ -1466,14 +1555,14 @@ var LruCache = class extends Map {
 
 // src/parser/template.ts
 var lruCache = new LruCache(5);
-function parseTemplate(code) {
+function parseTemplate(code, filePath) {
   const cache = lruCache.get(code);
   if (cache) {
     return cache;
   }
-  const ctx = new Context(code);
+  const ctx = new Context(code, filePath);
   const normalized = ctx.locs.getNormalizedLineFeed();
-  const ctxForAstro = normalized.needRemap ? new Context(normalized.code) : ctx;
+  const ctxForAstro = normalized.needRemap ? new Context(normalized.code, filePath) : ctx;
   try {
     const result = parse2((normalized == null ? void 0 : normalized.code) ?? code, ctxForAstro);
     if (normalized.needRemap) {
@@ -1608,6 +1697,10 @@ function getParser(attrs, parser) {
 }
 
 // src/context/parser-options.ts
+var TS_PARSER_NAMES = [
+  "@typescript-eslint/parser",
+  "typescript-eslint-parser-for-extra-files"
+];
 var ParserOptionsContext = class {
   constructor(options) {
     this.state = {};
@@ -1642,20 +1735,22 @@ var ParserOptionsContext = class {
       return this.state.isTypeScript;
     }
     const parserValue = getParserForLang({}, (_a = this.parserOptions) == null ? void 0 : _a.parser);
-    if (maybeTSESLintParserObject(parserValue) || parserValue === "@typescript-eslint/parser") {
-      return this.state.isTypeScript = true;
-    }
     if (typeof parserValue !== "string") {
-      return this.state.isTypeScript = false;
+      return this.state.isTypeScript = maybeTSESLintParserObject(parserValue) || isTSESLintParserObject(parserValue);
     }
     const parserName = parserValue;
-    if (parserName.includes("@typescript-eslint/parser")) {
+    if (TS_PARSER_NAMES.includes(parserName)) {
+      return this.state.isTypeScript = true;
+    }
+    if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
       let targetPath = parserName;
       while (targetPath) {
         const pkgPath = import_path3.default.join(targetPath, "package.json");
         if (import_fs2.default.existsSync(pkgPath)) {
           try {
-            return this.state.isTypeScript = ((_b = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf-8"))) == null ? void 0 : _b.name) === "@typescript-eslint/parser";
+            return this.state.isTypeScript = TS_PARSER_NAMES.includes(
+              (_b = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf-8"))) == null ? void 0 : _b.name
+            );
           } catch {
             return this.state.isTypeScript = false;
           }
@@ -1671,13 +1766,292 @@ var ParserOptionsContext = class {
   }
 };
 
+// src/parser/scope/index.ts
+var import_eslint_scope = require("eslint-scope");
+function getProgramScope(scopeManager) {
+  const globalScope = scopeManager.globalScope;
+  return globalScope.childScopes.find((s) => s.type === "module") || globalScope;
+}
+function removeAllScopeAndVariableAndReference(target, info) {
+  const targetScopes = /* @__PURE__ */ new Set();
+  traverseNodes(target, {
+    visitorKeys: info.visitorKeys,
+    enterNode(node) {
+      const scope = info.scopeManager.acquire(node);
+      if (scope) {
+        targetScopes.add(scope);
+        return;
+      }
+      if (node.type === "Identifier") {
+        let scope2 = getInnermostScopeFromNode(info.scopeManager, node);
+        while (scope2 && scope2.block.type !== "Program" && target.range[0] <= scope2.block.range[0] && scope2.block.range[1] <= target.range[1]) {
+          scope2 = scope2.upper;
+        }
+        if (targetScopes.has(scope2)) {
+          return;
+        }
+        removeIdentifierVariable(node, scope2);
+        removeIdentifierReference(node, scope2);
+      }
+    },
+    leaveNode() {
+    }
+  });
+  for (const scope of targetScopes) {
+    removeScope(info.scopeManager, scope);
+  }
+}
+function addVirtualReference(node, variable, scope, readWrite) {
+  const reference = new import_eslint_scope.Reference();
+  reference.astroVirtualReference = true;
+  reference.from = scope;
+  reference.identifier = node;
+  reference.isWrite = () => Boolean(readWrite.write);
+  reference.isWriteOnly = () => Boolean(readWrite.write) && !readWrite.read;
+  reference.isRead = () => Boolean(readWrite.read);
+  reference.isReadOnly = () => Boolean(readWrite.read) && !readWrite.write;
+  reference.isReadWrite = () => Boolean(readWrite.read && readWrite.write);
+  addReference(variable.references, reference);
+  reference.resolved = variable;
+  return reference;
+}
+function addGlobalVariable(reference, scopeManager) {
+  const globalScope = scopeManager.globalScope;
+  const name = reference.identifier.name;
+  let variable = globalScope.set.get(name);
+  if (!variable) {
+    variable = new import_eslint_scope.Variable();
+    variable.name = name;
+    variable.scope = globalScope;
+    globalScope.variables.push(variable);
+    globalScope.set.set(name, variable);
+  }
+  reference.resolved = variable;
+  variable.references.push(reference);
+  return variable;
+}
+function removeReferenceFromThrough(reference, baseScope) {
+  const variable = reference.resolved;
+  const name = reference.identifier.name;
+  let scope = baseScope;
+  while (scope) {
+    for (const ref of [...scope.through]) {
+      if (reference === ref) {
+        scope.through.splice(scope.through.indexOf(ref), 1);
+      } else if (ref.identifier.name === name) {
+        ref.resolved = variable;
+        if (!variable.references.includes(ref)) {
+          addReference(variable.references, ref);
+        }
+        scope.through.splice(scope.through.indexOf(ref), 1);
+      }
+    }
+    scope = scope.upper;
+  }
+}
+function removeScope(scopeManager, scope) {
+  for (const childScope of scope.childScopes) {
+    removeScope(scopeManager, childScope);
+  }
+  while (scope.references[0]) {
+    removeReference(scope.references[0], scope);
+  }
+  const upper = scope.upper;
+  if (upper) {
+    const index2 = upper.childScopes.indexOf(scope);
+    if (index2 >= 0) {
+      upper.childScopes.splice(index2, 1);
+    }
+  }
+  const index = scopeManager.scopes.indexOf(scope);
+  if (index >= 0) {
+    scopeManager.scopes.splice(index, 1);
+  }
+}
+function removeReference(reference, baseScope) {
+  if (reference.resolved) {
+    if (reference.resolved.defs.some((d) => d.name === reference.identifier)) {
+      const varIndex = baseScope.variables.indexOf(reference.resolved);
+      if (varIndex >= 0) {
+        baseScope.variables.splice(varIndex, 1);
+      }
+      const name = reference.identifier.name;
+      if (reference.resolved === baseScope.set.get(name)) {
+        baseScope.set.delete(name);
+      }
+    } else {
+      const refIndex = reference.resolved.references.indexOf(reference);
+      if (refIndex >= 0) {
+        reference.resolved.references.splice(refIndex, 1);
+      }
+    }
+  }
+  let scope = baseScope;
+  while (scope) {
+    const refIndex = scope.references.indexOf(reference);
+    if (refIndex >= 0) {
+      scope.references.splice(refIndex, 1);
+    }
+    const throughIndex = scope.through.indexOf(reference);
+    if (throughIndex >= 0) {
+      scope.through.splice(throughIndex, 1);
+    }
+    scope = scope.upper;
+  }
+}
+function removeIdentifierVariable(node, scope) {
+  for (let varIndex = 0; varIndex < scope.variables.length; varIndex++) {
+    const variable = scope.variables[varIndex];
+    const defIndex = variable.defs.findIndex((def) => def.name === node);
+    if (defIndex < 0) {
+      continue;
+    }
+    variable.defs.splice(defIndex, 1);
+    if (variable.defs.length === 0) {
+      referencesToThrough(variable.references, scope);
+      variable.references.forEach((r) => {
+        if (r.init)
+          r.init = false;
+        r.resolved = null;
+      });
+      scope.variables.splice(varIndex, 1);
+      const name = node.name;
+      if (variable === scope.set.get(name)) {
+        scope.set.delete(name);
+      }
+    } else {
+      const idIndex = variable.identifiers.indexOf(node);
+      if (idIndex >= 0) {
+        variable.identifiers.splice(idIndex, 1);
+      }
+    }
+    return;
+  }
+}
+function removeIdentifierReference(node, scope) {
+  const reference = scope.references.find((ref) => ref.identifier === node);
+  if (reference) {
+    removeReference(reference, scope);
+    return true;
+  }
+  const location = node.range[0];
+  const pendingScopes = [];
+  for (const childScope of scope.childScopes) {
+    const range = childScope.block.range;
+    if (range[0] <= location && location < range[1]) {
+      if (removeIdentifierReference(node, childScope)) {
+        return true;
+      }
+    } else {
+      pendingScopes.push(childScope);
+    }
+  }
+  for (const childScope of pendingScopes) {
+    if (removeIdentifierReference(node, childScope)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getInnermostScopeFromNode(scopeManager, currentNode) {
+  return getInnermostScope(
+    getScopeFromNode(scopeManager, currentNode),
+    currentNode
+  );
+}
+function getScopeFromNode(scopeManager, currentNode) {
+  let node = currentNode;
+  for (; node; node = node.parent || null) {
+    const scope = scopeManager.acquire(node, false);
+    if (scope) {
+      if (scope.type === "function-expression-name") {
+        return scope.childScopes[0];
+      }
+      if (scope.type === "global" && node.type === "Program" && node.sourceType === "module") {
+        return scope.childScopes.find((s) => s.type === "module") || scope;
+      }
+      return scope;
+    }
+  }
+  const global = scopeManager.globalScope;
+  return global;
+}
+function getInnermostScope(initialScope, node) {
+  for (const childScope of initialScope.childScopes) {
+    const range = childScope.block.range;
+    if (range[0] <= node.range[0] && node.range[1] <= range[1]) {
+      return getInnermostScope(childScope, node);
+    }
+  }
+  return initialScope;
+}
+function referencesToThrough(references, baseScope) {
+  let scope = baseScope;
+  while (scope) {
+    addAllReferences(scope.through, references);
+    scope = scope.upper;
+  }
+}
+function addAllReferences(list, elements) {
+  addElementsToSortedArray(
+    list,
+    elements,
+    (a, b) => a.identifier.range[0] - b.identifier.range[0]
+  );
+}
+function addReference(list, reference) {
+  addElementToSortedArray(
+    list,
+    reference,
+    (a, b) => a.identifier.range[0] - b.identifier.range[0]
+  );
+}
+
 // src/parser/index.ts
 function parseForESLint(code, options) {
-  const { result: resultTemplate, context: ctx } = parseTemplate(code);
+  const { result: resultTemplate, context: ctx } = parseTemplate(
+    code,
+    (options == null ? void 0 : options.filePath) ?? "<input>"
+  );
   const scriptContext = processTemplate(ctx, resultTemplate);
   const parserOptions = new ParserOptionsContext(options);
+  if (parserOptions.isTypeScript() && /\bAstro\b/u.test(code)) {
+    scriptContext.appendVirtualScript(
+      `declare const Astro: Readonly<import('astro').AstroGlobal<Props>>;`
+    );
+    scriptContext.restoreContext.addRestoreNodeProcess(
+      (_scriptNode, { result }) => {
+        const declareNode = result.ast.body.pop();
+        const scopeManager = result.scopeManager;
+        if (scopeManager) {
+          removeAllScopeAndVariableAndReference(declareNode, {
+            visitorKeys: result.visitorKeys,
+            scopeManager
+          });
+          const scope = getProgramScope(scopeManager);
+          const propsVariable = scope.set.get("Props");
+          if (propsVariable) {
+            addVirtualReference(
+              propsVariable.identifiers[0],
+              propsVariable,
+              scope,
+              {}
+            );
+          }
+          const astroGlobalReferences = scope.through.filter(
+            (ref) => ref.identifier.name === "Astro" || ref.identifier.name === "Fragment"
+          );
+          for (const astroGlobalReference of astroGlobalReferences) {
+            addGlobalVariable(astroGlobalReference, scopeManager);
+            removeReferenceFromThrough(astroGlobalReference, scope);
+          }
+        }
+        return true;
+      }
+    );
+  }
   const resultScript = parseScript(scriptContext.script, ctx, parserOptions);
-  scriptContext.restore(resultScript);
+  scriptContext.restoreContext.restore(resultScript);
   sort(resultScript.ast.comments);
   sort(resultScript.ast.tokens);
   extractTokens(resultScript, ctx);