astro-eslint-parser 1.0.1 → 1.0.2

package/lib/index.js

@@ -57,7 +57,7 @@ var KEYS = (0, import_eslint_visitor_keys.unionWith)(
 );
 
 // src/parser/index.ts
-var import_types2 = require("@typescript-eslint/types");
+var import_types3 = require("@typescript-eslint/types");
 
 // src/debug.ts
 var import_debug = __toESM(require("debug"));
@@ -514,7 +514,8 @@ function isTSESLintParserObject(value) {
 }
 
 // src/parser/script.ts
-var import_scope_manager = require("@typescript-eslint/scope-manager");
+var import_types = require("@typescript-eslint/types");
+var import_scope_manager2 = require("@typescript-eslint/scope-manager");
 var import_eslint_scope = require("eslint-scope");
 
 // src/traverse.ts
@@ -558,6 +559,299 @@ function traverseNodes(node, visitor) {
   traverse(node, null, visitor);
 }
 
+// src/parser/scope/index.ts
+var import_scope_manager = require("@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 import_scope_manager.Reference(
+    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 import_scope_manager.Variable(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);
@@ -569,7 +863,7 @@ function parseScript(code, ctx, parserOptionsCtx) {
 }
 function analyzeScope(result, parserOptions) {
   try {
-    return (0, import_scope_manager.analyze)(result.ast, {
+    return (0, import_scope_manager2.analyze)(result.ast, {
       globalReturn: parserOptions.ecmaFeatures?.globalReturn,
       jsxPragma: parserOptions.jsxPragma,
       jsxFragmentName: parserOptions.jsxFragmentName,
@@ -579,7 +873,7 @@ function analyzeScope(result, parserOptions) {
   } catch {
   }
   const ecmaFeatures = parserOptions.ecmaFeatures || {};
-  return (0, import_eslint_scope.analyze)(result.ast, {
+  return analyzeForEcmaScript(result.ast, {
     ignoreEval: true,
     nodejsScope: ecmaFeatures.globalReturn,
     impliedStrict: ecmaFeatures.impliedStrict,
@@ -616,6 +910,73 @@ ${code}`
     patchResult?.terminate();
   }
 }
+var Referencer = class extends import_eslint_scope.Referencer {
+  JSXAttribute(node) {
+    this.visit(node.value);
+  }
+  JSXClosingElement() {
+  }
+  JSXFragment(node) {
+    this.visitChildren(node);
+  }
+  JSXIdentifier(node) {
+    const scope = this.currentScope();
+    const ref = new import_scope_manager2.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 !== import_types.AST_NODE_TYPES.JSXIdentifier) {
+      this.visit(node.object);
+    } else {
+      if (node.object.name !== "this") {
+        this.visit(node.object);
+      }
+    }
+  }
+  JSXOpeningElement(node) {
+    if (node.name.type === import_types.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 import_eslint_scope.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) {
@@ -628,7 +989,7 @@ function sort(tokens) {
 }
 
 // src/parser/process-template.ts
-var import_types = require("@typescript-eslint/types");
+var import_types2 = require("@typescript-eslint/types");
 
 // src/astro/index.ts
 var import_decode = require("entities/lib/decode.js");
@@ -1272,7 +1633,7 @@ function processTemplate(ctx, resultTemplate) {
     script.appendVirtualScript("<>");
     fragmentOpened = true;
     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)) {
+      if (scriptNode.type === import_types2.AST_NODE_TYPES.ExpressionStatement && scriptNode.expression.type === import_types2.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;
         delete rootFragment.closingFragment;
@@ -1310,7 +1671,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 === import_types.AST_NODE_TYPES.EmptyStatement) {
+              if (st.type === import_types2.AST_NODE_TYPES.EmptyStatement) {
                 if (st.range[0] === scriptEnd && st.range[1] === scriptEnd) {
                   result.ast.body.splice(index, 1);
                   break;
@@ -1320,11 +1681,11 @@ function processTemplate(ctx, resultTemplate) {
             return true;
           }
         );
-        script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
+        script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.Punctuator, [
           node.position.start.offset,
           node.position.start.offset + 3
         ]);
-        script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
+        script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.Punctuator, [
           end - 3,
           end
         ]);
@@ -1342,7 +1703,7 @@ function processTemplate(ctx, resultTemplate) {
               script.appendOriginal(start2);
               script.appendVirtualScript("<>");
               script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-                if (scriptNode.range[0] === start2 && scriptNode.type === import_types.AST_NODE_TYPES.JSXFragment) {
+                if (scriptNode.range[0] === start2 && scriptNode.type === import_types2.AST_NODE_TYPES.JSXFragment) {
                   delete scriptNode.openingFragment;
                   delete scriptNode.closingFragment;
                   const fragmentNode = scriptNode;
@@ -1384,7 +1745,7 @@ function processTemplate(ctx, resultTemplate) {
               script.appendVirtualScript('"');
               script.restoreContext.addRestoreNodeProcess(
                 (scriptNode, context) => {
-                  if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
+                  if (scriptNode.type === import_types2.AST_NODE_TYPES.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);
@@ -1403,7 +1764,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 === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
+              if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
                 const attrNode = scriptNode;
                 attrNode.type = "AstroShorthandAttribute";
                 const locs = ctx.getLocations(
@@ -1427,7 +1788,7 @@ function processTemplate(ctx, resultTemplate) {
             script.appendOriginal(end);
             script.appendVirtualScript("}");
             script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
+              if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
                 const attrNode = scriptNode;
                 attrNode.type = "AstroTemplateLiteralAttribute";
                 return true;
@@ -1449,7 +1810,7 @@ function processTemplate(ctx, resultTemplate) {
             script.appendOriginal(start2);
             script.skipOriginalOffset(text.value.length);
             script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === import_types.AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
+              if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
                 const textNode = {
                   type: "AstroRawText",
                   value: text.value,
@@ -1462,7 +1823,7 @@ function processTemplate(ctx, resultTemplate) {
               }
               return false;
             });
-            script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXText, [
+            script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXText, [
               start2,
               start2 + text.value.length
             ]);
@@ -1481,7 +1842,7 @@ function processTemplate(ctx, resultTemplate) {
         script.skipOriginalOffset(length - 2);
         script.appendOriginal(end);
         script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-          if (scriptNode.range[0] === start && scriptNode.type === import_types.AST_NODE_TYPES.JSXFragment) {
+          if (scriptNode.range[0] === start && scriptNode.type === import_types2.AST_NODE_TYPES.JSXFragment) {
             delete scriptNode.children;
             delete scriptNode.openingFragment;
             delete scriptNode.closingFragment;
@@ -1516,7 +1877,7 @@ function processTemplate(ctx, resultTemplate) {
         script.skipOriginalOffset(length - 2);
         script.appendOriginal(end);
         script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-          if (scriptNode.range[0] === start && scriptNode.type === import_types.AST_NODE_TYPES.JSXFragment) {
+          if (scriptNode.range[0] === start && scriptNode.type === import_types2.AST_NODE_TYPES.JSXFragment) {
             delete scriptNode.children;
             delete scriptNode.openingFragment;
             delete scriptNode.closingFragment;
@@ -1557,7 +1918,7 @@ function processTemplate(ctx, resultTemplate) {
             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) {
+                if (scriptNode.range[0] === offset && scriptNode.type === import_types2.AST_NODE_TYPES.JSXClosingElement && parent2.type === import_types2.AST_NODE_TYPES.JSXElement) {
                   parent2.closingElement = null;
                   return true;
                 }
@@ -1614,32 +1975,32 @@ function processTemplate(ctx, resultTemplate) {
     }
     if (colonOffset != null) {
       const punctuatorIndex = start + colonOffset;
-      script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
+      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXIdentifier, [
         start,
         punctuatorIndex
       ]);
-      script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.Punctuator, [
+      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.Punctuator, [
         punctuatorIndex,
         punctuatorIndex + 1
       ]);
-      script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
+      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXIdentifier, [
         punctuatorIndex + 1,
         start + attr.name.length
       ]);
     } else {
-      script.restoreContext.addToken(import_types.AST_TOKEN_TYPES.JSXIdentifier, [
+      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXIdentifier, [
         start,
         start + attr.name.length
       ]);
     }
     script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-      if (scriptNode.type === import_types.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === targetIndex) {
+      if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === targetIndex) {
         const baseNameNode = scriptNode.name;
         if (colonOffset != null) {
           const nameNode = baseNameNode;
-          nameNode.type = import_types.AST_NODE_TYPES.JSXNamespacedName;
+          nameNode.type = import_types2.AST_NODE_TYPES.JSXNamespacedName;
           nameNode.namespace = {
-            type: import_types.AST_NODE_TYPES.JSXIdentifier,
+            type: import_types2.AST_NODE_TYPES.JSXIdentifier,
             name: attr.name.slice(0, colonOffset),
             ...ctx.getLocations(
               baseNameNode.range[0],
@@ -1647,7 +2008,7 @@ function processTemplate(ctx, resultTemplate) {
             )
           };
           nameNode.name = {
-            type: import_types.AST_NODE_TYPES.JSXIdentifier,
+            type: import_types2.AST_NODE_TYPES.JSXIdentifier,
             name: attr.name.slice(colonOffset + 1),
             ...ctx.getLocations(
               baseNameNode.range[0] + colonOffset + 1,
@@ -1658,7 +2019,7 @@ function processTemplate(ctx, resultTemplate) {
           nameNode.namespace.parent = nameNode;
           nameNode.name.parent = nameNode;
         } else {
-          if (baseNameNode.type === import_types.AST_NODE_TYPES.JSXIdentifier) {
+          if (baseNameNode.type === import_types2.AST_NODE_TYPES.JSXIdentifier) {
             const nameNode = baseNameNode;
             nameNode.name = attr.name;
             scriptNode.name = nameNode;
@@ -1686,52 +2047,12 @@ function processTemplate(ctx, resultTemplate) {
     });
   }
   function generateUniqueId(base) {
-    let candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
-    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];
+    let candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
+    while (usedUniqueIds.has(candidate) || ctx.code.includes(candidate)) {
+      candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
     }
-    array.splice(index, 0, element);
-    last = element;
+    usedUniqueIds.add(candidate);
+    return candidate;
   }
 }
 
@@ -2363,257 +2684,6 @@ var ParserOptionsContext = class {
   }
 };
 
-// src/parser/scope/index.ts
-var import_scope_manager2 = require("@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 import_scope_manager2.Reference(
-    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 import_scope_manager2.Variable(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(
@@ -2700,11 +2770,11 @@ function extractTokens(ast, ctx) {
     }
     if (isPunctuator(c)) {
       ast.ast.tokens.push(
-        ctx.buildToken(import_types2.AST_TOKEN_TYPES.Punctuator, [index, index + 1])
+        ctx.buildToken(import_types3.AST_TOKEN_TYPES.Punctuator, [index, index + 1])
       );
     } else {
       ast.ast.tokens.push(
-        ctx.buildToken(import_types2.AST_TOKEN_TYPES.Identifier, [index, index + 1])
+        ctx.buildToken(import_types3.AST_TOKEN_TYPES.Identifier, [index, index + 1])
       );
     }
   }
@@ -2748,7 +2818,7 @@ __export(meta_exports, {
 
 // package.json
 var name = "astro-eslint-parser";
-var version = "1.0.1";
+var version = "1.0.2";
 
 // src/index.ts
 function parseForESLint2(code, options) {