astro-eslint-parser 1.0.0 → 1.0.2

package/lib/index.mjs

@@ -484,21 +484,384 @@ function isTSESLintParserObject(value) {
 }
 
 // src/parser/script.ts
-import { analyze } from "@typescript-eslint/scope-manager";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import {
+  analyze as analyzeForTypeScript,
+  Reference
+} from "@typescript-eslint/scope-manager";
+import {
+  Referencer as BaseReferencer,
+  ScopeManager
+} from "eslint-scope";
+
+// src/traverse.ts
+function fallbackKeysFilter(key) {
+  let value = null;
+  return key !== "comments" && key !== "leadingComments" && key !== "loc" && key !== "parent" && key !== "range" && key !== "tokens" && key !== "trailingComments" && (value = this[key]) !== null && typeof value === "object" && (typeof value.type === "string" || Array.isArray(value));
+}
+function getFallbackKeys(node) {
+  return Object.keys(node).filter(fallbackKeysFilter, node);
+}
+function getKeys(node, visitorKeys) {
+  const keys = (visitorKeys || KEYS)[node.type] || getFallbackKeys(node);
+  return keys.filter((key) => !getNodes(node, key).next().done);
+}
+function* getNodes(node, key) {
+  const child = node[key];
+  if (Array.isArray(child)) {
+    for (const c of child) {
+      if (isNode(c)) {
+        yield c;
+      }
+    }
+  } else if (isNode(child)) {
+    yield child;
+  }
+}
+function isNode(x) {
+  return x !== null && typeof x === "object" && typeof x.type === "string";
+}
+function traverse(node, parent, visitor) {
+  visitor.enterNode(node, parent);
+  const keys = getKeys(node, visitor.visitorKeys);
+  for (const key of keys) {
+    for (const child of getNodes(node, key)) {
+      traverse(child, node, visitor);
+    }
+  }
+  visitor.leaveNode(node, parent);
+}
+function traverseNodes(node, visitor) {
+  traverse(node, null, visitor);
+}
+
+// src/parser/scope/index.ts
+import {
+  Reference as ReferenceClass,
+  Variable as VariableClass
+} from "@typescript-eslint/scope-manager";
+
+// 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/parser/scope/index.ts
+var READ_FLAG = 1;
+var WRITE_FLAG = 2;
+var READ_WRITE_FLAG = 3;
+var REFERENCE_TYPE_VALUE_FLAG = 1;
+var REFERENCE_TYPE_TYPE_FLAG = 2;
+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, status) {
+  const reference = new ReferenceClass(
+    node,
+    scope,
+    status.write && status.read ? READ_WRITE_FLAG : status.write ? WRITE_FLAG : READ_FLAG,
+    void 0,
+    // writeExpr
+    void 0,
+    // maybeImplicitGlobal
+    void 0,
+    // init
+    status.typeRef ? REFERENCE_TYPE_TYPE_FLAG : REFERENCE_TYPE_VALUE_FLAG
+  );
+  reference.astroVirtualReference = true;
+  addReference(variable.references, reference);
+  reference.resolved = variable;
+  if (status.forceUsed) {
+    variable.eslintUsed = true;
+  }
+  return reference;
+}
+function addGlobalVariable(reference, scopeManager) {
+  const globalScope = scopeManager.globalScope;
+  const name2 = reference.identifier.name;
+  let variable = globalScope.set.get(name2);
+  if (!variable) {
+    variable = new VariableClass(name2, globalScope);
+    globalScope.variables.push(variable);
+    globalScope.set.set(name2, variable);
+  }
+  reference.resolved = variable;
+  variable.references.push(reference);
+  return variable;
+}
+function removeReferenceFromThrough(reference, baseScope) {
+  const variable = reference.resolved;
+  const name2 = 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 === name2) {
+        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 name2 = reference.identifier.name;
+      if (reference.resolved === baseScope.set.get(name2)) {
+        baseScope.set.delete(name2);
+      }
+    } 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 name2 = node.name;
+      if (variable === scope.set.get(name2)) {
+        scope.set.delete(name2);
+      }
+    } 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/script.ts
 function parseScript(code, ctx, parserOptionsCtx) {
   const result = parseScriptInternal(code, ctx, parserOptionsCtx);
   const parserOptions = parserOptionsCtx.parserOptions;
   if (!result.scopeManager && parserOptions.eslintScopeManager) {
-    result.scopeManager = analyze(result.ast, {
-      ecmaVersion: 1e8,
+    result.scopeManager = analyzeScope(result, parserOptions);
+  }
+  return result;
+}
+function analyzeScope(result, parserOptions) {
+  try {
+    return analyzeForTypeScript(result.ast, {
       globalReturn: parserOptions.ecmaFeatures?.globalReturn,
       jsxPragma: parserOptions.jsxPragma,
       jsxFragmentName: parserOptions.jsxFragmentName,
       lib: parserOptions.lib,
       sourceType: parserOptions.sourceType
     });
+  } catch {
   }
-  return result;
+  const ecmaFeatures = parserOptions.ecmaFeatures || {};
+  return analyzeForEcmaScript(result.ast, {
+    ignoreEval: true,
+    nodejsScope: ecmaFeatures.globalReturn,
+    impliedStrict: ecmaFeatures.impliedStrict,
+    ecmaVersion: 1e8,
+    sourceType: parserOptions.sourceType === "commonjs" ? "script" : parserOptions.sourceType || "script",
+    // @ts-expect-error -- Type bug?
+    childVisitorKeys: result.visitorKeys || KEYS,
+    fallback: getKeys
+  });
 }
 function parseScriptInternal(code, _ctx, parserOptionsCtx) {
   const parser = parserOptionsCtx.getParser();
@@ -526,6 +889,73 @@ ${code}`
     patchResult?.terminate();
   }
 }
+var Referencer = class extends BaseReferencer {
+  JSXAttribute(node) {
+    this.visit(node.value);
+  }
+  JSXClosingElement() {
+  }
+  JSXFragment(node) {
+    this.visitChildren(node);
+  }
+  JSXIdentifier(node) {
+    const scope = this.currentScope();
+    const ref = new Reference(
+      node,
+      scope,
+      READ_FLAG,
+      void 0,
+      void 0,
+      false,
+      REFERENCE_TYPE_VALUE_FLAG
+    );
+    scope.references.push(ref);
+    scope.__left.push(ref);
+  }
+  JSXMemberExpression(node) {
+    if (node.object.type !== AST_NODE_TYPES.JSXIdentifier) {
+      this.visit(node.object);
+    } else {
+      if (node.object.name !== "this") {
+        this.visit(node.object);
+      }
+    }
+  }
+  JSXOpeningElement(node) {
+    if (node.name.type === AST_NODE_TYPES.JSXIdentifier) {
+      if (node.name.name[0].toUpperCase() === node.name.name[0] || node.name.name === "this") {
+        this.visit(node.name);
+      }
+    } else {
+      this.visit(node.name);
+    }
+    for (const attr of node.attributes) {
+      this.visit(attr);
+    }
+  }
+};
+function analyzeForEcmaScript(tree, providedOptions) {
+  const options = Object.assign(
+    {
+      optimistic: false,
+      nodejsScope: false,
+      impliedStrict: false,
+      sourceType: "script",
+      // one of ['script', 'module', 'commonjs']
+      ecmaVersion: 5,
+      childVisitorKeys: null,
+      fallback: "iteration"
+    },
+    providedOptions
+  );
+  const scopeManager = new ScopeManager(
+    // @ts-expect-error -- No typings
+    options
+  );
+  const referencer = new Referencer(options, scopeManager);
+  referencer.visit(tree);
+  return scopeManager;
+}
 
 // src/parser/sort.ts
 function sort(tokens) {
@@ -538,7 +968,7 @@ function sort(tokens) {
 }
 
 // src/parser/process-template.ts
-import { AST_TOKEN_TYPES, AST_NODE_TYPES } from "@typescript-eslint/types";
+import { AST_TOKEN_TYPES, AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
 
 // src/astro/index.ts
 import {
@@ -960,47 +1390,6 @@ function getSortedChildren(parent, code) {
   return parent.children;
 }
 
-// src/traverse.ts
-function fallbackKeysFilter(key) {
-  let value = null;
-  return key !== "comments" && key !== "leadingComments" && key !== "loc" && key !== "parent" && key !== "range" && key !== "tokens" && key !== "trailingComments" && (value = this[key]) !== null && typeof value === "object" && (typeof value.type === "string" || Array.isArray(value));
-}
-function getFallbackKeys(node) {
-  return Object.keys(node).filter(fallbackKeysFilter, node);
-}
-function getKeys(node, visitorKeys) {
-  const keys = (visitorKeys || KEYS)[node.type] || getFallbackKeys(node);
-  return keys.filter((key) => !getNodes(node, key).next().done);
-}
-function* getNodes(node, key) {
-  const child = node[key];
-  if (Array.isArray(child)) {
-    for (const c of child) {
-      if (isNode(c)) {
-        yield c;
-      }
-    }
-  } else if (isNode(child)) {
-    yield child;
-  }
-}
-function isNode(x) {
-  return x !== null && typeof x === "object" && typeof x.type === "string";
-}
-function traverse(node, parent, visitor) {
-  visitor.enterNode(node, parent);
-  const keys = getKeys(node, visitor.visitorKeys);
-  for (const key of keys) {
-    for (const child of getNodes(node, key)) {
-      traverse(child, node, visitor);
-    }
-  }
-  visitor.leaveNode(node, parent);
-}
-function traverseNodes(node, visitor) {
-  traverse(node, null, visitor);
-}
-
 // src/context/restore.ts
 var RestoreNodeProcessContext = class {
   constructor(result, nodeMap) {
@@ -1227,7 +1616,7 @@ function processTemplate(ctx, resultTemplate) {
     script.appendVirtualScript("<>");
     fragmentOpened = true;
     script.restoreContext.addRestoreNodeProcess((scriptNode, { result }) => {
-      if (scriptNode.type === AST_NODE_TYPES.ExpressionStatement && scriptNode.expression.type === AST_NODE_TYPES.JSXFragment && scriptNode.range[0] === startOffset && result.ast.body.includes(scriptNode)) {
+      if (scriptNode.type === AST_NODE_TYPES2.ExpressionStatement && scriptNode.expression.type === AST_NODE_TYPES2.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;
         delete rootFragment.closingFragment;
@@ -1265,7 +1654,7 @@ function processTemplate(ctx, resultTemplate) {
           (_scriptNode, { result }) => {
             for (let index = 0; index < result.ast.body.length; index++) {
               const st = result.ast.body[index];
-              if (st.type === AST_NODE_TYPES.EmptyStatement) {
+              if (st.type === AST_NODE_TYPES2.EmptyStatement) {
                 if (st.range[0] === scriptEnd && st.range[1] === scriptEnd) {
                   result.ast.body.splice(index, 1);
                   break;
@@ -1297,7 +1686,7 @@ function processTemplate(ctx, resultTemplate) {
               script.appendOriginal(start2);
               script.appendVirtualScript("<>");
               script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-                if (scriptNode.range[0] === start2 && scriptNode.type === AST_NODE_TYPES.JSXFragment) {
+                if (scriptNode.range[0] === start2 && scriptNode.type === AST_NODE_TYPES2.JSXFragment) {
                   delete scriptNode.openingFragment;
                   delete scriptNode.closingFragment;
                   const fragmentNode = scriptNode;
@@ -1339,7 +1728,7 @@ function processTemplate(ctx, resultTemplate) {
               script.appendVirtualScript('"');
               script.restoreContext.addRestoreNodeProcess(
                 (scriptNode, context) => {
-                  if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
+                  if (scriptNode.type === AST_NODE_TYPES2.JSXAttribute && scriptNode.range[0] === attrStart) {
                     const attrNode = scriptNode;
                     if (attrNode.value?.type === "Literal" && typeof attrNode.value.value === "string") {
                       const raw = ctx.code.slice(start2, end);
@@ -1358,7 +1747,7 @@ function processTemplate(ctx, resultTemplate) {
             const jsxName = /[\s"'[\]{}]/u.test(attr.name) ? generateUniqueId(attr.name) : attr.name;
             script.appendVirtualScript(`${jsxName}=`);
             script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
+              if (scriptNode.type === AST_NODE_TYPES2.JSXAttribute && scriptNode.range[0] === start2) {
                 const attrNode = scriptNode;
                 attrNode.type = "AstroShorthandAttribute";
                 const locs = ctx.getLocations(
@@ -1382,7 +1771,7 @@ function processTemplate(ctx, resultTemplate) {
             script.appendOriginal(end);
             script.appendVirtualScript("}");
             script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
+              if (scriptNode.type === AST_NODE_TYPES2.JSXAttribute && scriptNode.range[0] === attrStart) {
                 const attrNode = scriptNode;
                 attrNode.type = "AstroTemplateLiteralAttribute";
                 return true;
@@ -1404,7 +1793,7 @@ function processTemplate(ctx, resultTemplate) {
             script.appendOriginal(start2);
             script.skipOriginalOffset(text.value.length);
             script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
+              if (scriptNode.type === AST_NODE_TYPES2.JSXElement && scriptNode.range[0] === styleNodeStart) {
                 const textNode = {
                   type: "AstroRawText",
                   value: text.value,
@@ -1436,7 +1825,7 @@ function processTemplate(ctx, resultTemplate) {
         script.skipOriginalOffset(length - 2);
         script.appendOriginal(end);
         script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-          if (scriptNode.range[0] === start && scriptNode.type === AST_NODE_TYPES.JSXFragment) {
+          if (scriptNode.range[0] === start && scriptNode.type === AST_NODE_TYPES2.JSXFragment) {
             delete scriptNode.children;
             delete scriptNode.openingFragment;
             delete scriptNode.closingFragment;
@@ -1471,7 +1860,7 @@ function processTemplate(ctx, resultTemplate) {
         script.skipOriginalOffset(length - 2);
         script.appendOriginal(end);
         script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-          if (scriptNode.range[0] === start && scriptNode.type === AST_NODE_TYPES.JSXFragment) {
+          if (scriptNode.range[0] === start && scriptNode.type === AST_NODE_TYPES2.JSXFragment) {
             delete scriptNode.children;
             delete scriptNode.openingFragment;
             delete scriptNode.closingFragment;
@@ -1512,7 +1901,7 @@ function processTemplate(ctx, resultTemplate) {
             script.restoreContext.addRestoreNodeProcess(
               (scriptNode, context) => {
                 const parent2 = context.getParent(scriptNode);
-                if (scriptNode.range[0] === offset && scriptNode.type === AST_NODE_TYPES.JSXClosingElement && parent2.type === AST_NODE_TYPES.JSXElement) {
+                if (scriptNode.range[0] === offset && scriptNode.type === AST_NODE_TYPES2.JSXClosingElement && parent2.type === AST_NODE_TYPES2.JSXElement) {
                   parent2.closingElement = null;
                   return true;
                 }
@@ -1588,13 +1977,13 @@ function processTemplate(ctx, resultTemplate) {
       ]);
     }
     script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-      if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === targetIndex) {
+      if (scriptNode.type === AST_NODE_TYPES2.JSXAttribute && scriptNode.range[0] === targetIndex) {
         const baseNameNode = scriptNode.name;
         if (colonOffset != null) {
           const nameNode = baseNameNode;
-          nameNode.type = AST_NODE_TYPES.JSXNamespacedName;
+          nameNode.type = AST_NODE_TYPES2.JSXNamespacedName;
           nameNode.namespace = {
-            type: AST_NODE_TYPES.JSXIdentifier,
+            type: AST_NODE_TYPES2.JSXIdentifier,
             name: attr.name.slice(0, colonOffset),
             ...ctx.getLocations(
               baseNameNode.range[0],
@@ -1602,7 +1991,7 @@ function processTemplate(ctx, resultTemplate) {
             )
           };
           nameNode.name = {
-            type: AST_NODE_TYPES.JSXIdentifier,
+            type: AST_NODE_TYPES2.JSXIdentifier,
             name: attr.name.slice(colonOffset + 1),
             ...ctx.getLocations(
               baseNameNode.range[0] + colonOffset + 1,
@@ -1613,7 +2002,7 @@ function processTemplate(ctx, resultTemplate) {
           nameNode.namespace.parent = nameNode;
           nameNode.name.parent = nameNode;
         } else {
-          if (baseNameNode.type === AST_NODE_TYPES.JSXIdentifier) {
+          if (baseNameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
             const nameNode = baseNameNode;
             nameNode.name = attr.name;
             scriptNode.name = nameNode;
@@ -1645,48 +2034,8 @@ function processTemplate(ctx, resultTemplate) {
     while (usedUniqueIds.has(candidate) || ctx.code.includes(candidate)) {
       candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
     }
-    usedUniqueIds.add(candidate);
-    return candidate;
-  }
-}
-
-// 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;
+    usedUniqueIds.add(candidate);
+    return candidate;
   }
 }
 
@@ -2318,260 +2667,6 @@ var ParserOptionsContext = class {
   }
 };
 
-// src/parser/scope/index.ts
-import {
-  Reference as ReferenceClass,
-  Variable as VariableClass
-} from "@typescript-eslint/scope-manager";
-var READ_FLAG = 1;
-var WRITE_FLAG = 2;
-var READ_WRITE_FLAG = 3;
-var REFERENCE_TYPE_VALUE_FLAG = 1;
-var REFERENCE_TYPE_TYPE_FLAG = 2;
-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, status) {
-  const reference = new ReferenceClass(
-    node,
-    scope,
-    status.write && status.read ? READ_WRITE_FLAG : status.write ? WRITE_FLAG : READ_FLAG,
-    void 0,
-    // writeExpr
-    void 0,
-    // maybeImplicitGlobal
-    void 0,
-    // init
-    status.typeRef ? REFERENCE_TYPE_TYPE_FLAG : REFERENCE_TYPE_VALUE_FLAG
-  );
-  reference.astroVirtualReference = true;
-  addReference(variable.references, reference);
-  reference.resolved = variable;
-  if (status.forceUsed) {
-    variable.eslintUsed = true;
-  }
-  return reference;
-}
-function addGlobalVariable(reference, scopeManager) {
-  const globalScope = scopeManager.globalScope;
-  const name2 = reference.identifier.name;
-  let variable = globalScope.set.get(name2);
-  if (!variable) {
-    variable = new VariableClass(name2, globalScope);
-    globalScope.variables.push(variable);
-    globalScope.set.set(name2, variable);
-  }
-  reference.resolved = variable;
-  variable.references.push(reference);
-  return variable;
-}
-function removeReferenceFromThrough(reference, baseScope) {
-  const variable = reference.resolved;
-  const name2 = 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 === name2) {
-        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 name2 = reference.identifier.name;
-      if (reference.resolved === baseScope.set.get(name2)) {
-        baseScope.set.delete(name2);
-      }
-    } 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 name2 = node.name;
-      if (variable === scope.set.get(name2)) {
-        scope.set.delete(name2);
-      }
-    } 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(
@@ -2706,7 +2801,7 @@ __export(meta_exports, {
 
 // package.json
 var name = "astro-eslint-parser";
-var version = "1.0.0";
+var version = "1.0.2";
 
 // src/index.ts
 function parseForESLint2(code, options) {