astro-eslint-parser 1.3.2 → 2.0.0

package/lib/index.js

@@ -1,2960 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AST: () => ast_exports,
-  ParseError: () => ParseError,
-  VisitorKeys: () => VisitorKeys,
-  meta: () => meta_exports,
-  name: () => name,
-  parseForESLint: () => parseForESLint2,
-  parseTemplate: () => parseTemplate2,
-  traverseNodes: () => traverseNodes
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/visitor-keys.ts
-var import_eslint_visitor_keys = require("eslint-visitor-keys");
-var astroKeys = {
-  Program: ["body"],
-  AstroFragment: ["children"],
-  AstroHTMLComment: [],
-  AstroDoctype: [],
-  AstroShorthandAttribute: ["name", "value"],
-  AstroTemplateLiteralAttribute: ["name", "value"],
-  AstroRawText: []
-};
-var KEYS = (0, import_eslint_visitor_keys.unionWith)(
-  astroKeys
-);
-
-// src/parser/index.ts
-var import_types3 = require("@typescript-eslint/types");
-
-// src/debug.ts
-var import_debug = __toESM(require("debug"));
-var debug = (0, import_debug.default)("astro-eslint-parser");
-
-// src/parser/ts-patch.ts
-var import_module2 = require("module");
-var import_path2 = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
-var import_semver = require("semver");
-
-// src/parser/ts-for-v5/get-project-config-files.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-function getProjectConfigFiles(parseSettings, project) {
-  if (project !== true) {
-    return project === void 0 || Array.isArray(project) ? project : [project];
-  }
-  let directory = path.dirname(parseSettings.filePath);
-  const checkedDirectories = [directory];
-  do {
-    const tsconfigPath = path.join(directory, "tsconfig.json");
-    const cached = fs.existsSync(tsconfigPath) && tsconfigPath;
-    if (cached) {
-      return [cached];
-    }
-    directory = path.dirname(directory);
-    checkedDirectories.push(directory);
-  } while (directory.length > 1 && directory.length >= parseSettings.tsconfigRootDir.length);
-  throw new Error(
-    `project was set to \`true\` but couldn't find any tsconfig.json relative to '${parseSettings.filePath}' within '${parseSettings.tsconfigRootDir}'.`
-  );
-}
-
-// src/parser/ts-for-v5/programs.ts
-var import_path = __toESM(require("path"));
-var tsServices = /* @__PURE__ */ new Map();
-function getTSProgram(code, options, ts) {
-  const tsconfigPath = options.project;
-  let service2 = tsServices.get(tsconfigPath);
-  if (!service2) {
-    service2 = new TSService(tsconfigPath, ts);
-    tsServices.set(tsconfigPath, service2);
-  }
-  return service2.getProgram(code, options.filePath);
-}
-var TSService = class {
-  constructor(tsconfigPath, ts) {
-    this.patchedHostSet = /* @__PURE__ */ new WeakSet();
-    this.currTarget = {
-      code: "",
-      filePath: ""
-    };
-    this.fileWatchCallbacks = /* @__PURE__ */ new Map();
-    this.ts = ts;
-    this.watch = this.createWatch(tsconfigPath);
-  }
-  getProgram(code, filePath) {
-    const normalized = normalizeFileName(this.ts, filePath);
-    const lastTarget = this.currTarget;
-    this.currTarget = {
-      code,
-      filePath: normalized
-    };
-    for (const { filePath: targetPath } of [this.currTarget, lastTarget]) {
-      if (!targetPath) continue;
-      this.fileWatchCallbacks.get(targetPath)?.update();
-    }
-    const program = this.watch.getProgram().getProgram();
-    program.getTypeChecker();
-    return program;
-  }
-  createWatch(tsconfigPath) {
-    const { ts } = this;
-    const createAbstractBuilder = (...buildArgs) => {
-      const [
-        rootNames,
-        options,
-        argHost,
-        oldProgram,
-        configFileParsingDiagnostics,
-        projectReferences
-      ] = buildArgs;
-      const host = argHost;
-      if (!this.patchedHostSet.has(host)) {
-        this.patchedHostSet.add(host);
-        const getTargetSourceFile = (fileName, languageVersionOrOptions) => {
-          var _a;
-          if (this.currTarget.filePath === normalizeFileName(ts, fileName)) {
-            return (_a = this.currTarget).sourceFile ?? (_a.sourceFile = ts.createSourceFile(
-              this.currTarget.filePath,
-              this.currTarget.code,
-              languageVersionOrOptions,
-              true,
-              ts.ScriptKind.TSX
-            ));
-          }
-          return null;
-        };
-        const original2 = {
-          getSourceFile: host.getSourceFile,
-          getSourceFileByPath: host.getSourceFileByPath
-        };
-        host.getSourceFile = (fileName, languageVersionOrOptions, ...args) => {
-          const originalSourceFile = original2.getSourceFile.call(
-            host,
-            fileName,
-            languageVersionOrOptions,
-            ...args
-          );
-          return getTargetSourceFile(fileName, languageVersionOrOptions) ?? originalSourceFile;
-        };
-        host.getSourceFileByPath = (fileName, filePath, languageVersionOrOptions, ...args) => {
-          const originalSourceFile = original2.getSourceFileByPath.call(
-            host,
-            fileName,
-            filePath,
-            languageVersionOrOptions,
-            ...args
-          );
-          return getTargetSourceFile(fileName, languageVersionOrOptions) ?? originalSourceFile;
-        };
-      }
-      return ts.createAbstractBuilder(
-        rootNames,
-        options,
-        host,
-        oldProgram,
-        configFileParsingDiagnostics,
-        projectReferences
-      );
-    };
-    const watchCompilerHost = ts.createWatchCompilerHost(
-      tsconfigPath,
-      {
-        noEmit: true,
-        jsx: ts.JsxEmit.Preserve,
-        // This option is required if `includes` only includes `*.astro` files.
-        // However, the option is not in the documentation.
-        // https://github.com/microsoft/TypeScript/issues/28447
-        allowNonTsExtensions: true
-      },
-      ts.sys,
-      createAbstractBuilder,
-      (diagnostic) => {
-        throw new Error(formatDiagnostics(ts, [diagnostic]));
-      },
-      () => {
-      },
-      void 0,
-      [
-        {
-          extension: ".astro",
-          isMixedContent: true,
-          scriptKind: ts.ScriptKind.Deferred
-        }
-      ]
-    );
-    const original = {
-      readFile: watchCompilerHost.readFile
-    };
-    watchCompilerHost.readFile = (fileName, ...args) => {
-      const normalized = normalizeFileName(ts, fileName);
-      if (this.currTarget.filePath === normalized) {
-        return this.currTarget.code;
-      }
-      return original.readFile.call(watchCompilerHost, fileName, ...args);
-    };
-    watchCompilerHost.watchFile = (fileName, callback) => {
-      const normalized = normalizeFileName(ts, fileName);
-      this.fileWatchCallbacks.set(normalized, {
-        update: () => callback(fileName, ts.FileWatcherEventKind.Changed)
-      });
-      return {
-        close: () => {
-          this.fileWatchCallbacks.delete(normalized);
-        }
-      };
-    };
-    watchCompilerHost.watchDirectory = () => {
-      return {
-        close: () => {
-        }
-      };
-    };
-    watchCompilerHost.afterProgramCreate = (program) => {
-      const originalDiagnostics = program.getConfigFileParsingDiagnostics();
-      const configFileDiagnostics = originalDiagnostics.filter(
-        (diag) => diag.category === ts.DiagnosticCategory.Error && diag.code !== 18003
-      );
-      if (configFileDiagnostics.length > 0) {
-        throw new Error(formatDiagnostics(ts, configFileDiagnostics));
-      }
-    };
-    const watch = ts.createWatchProgram(watchCompilerHost);
-    return watch;
-  }
-};
-function formatDiagnostics(ts, diagnostics) {
-  return ts.formatDiagnostics(diagnostics, {
-    getCanonicalFileName: (f) => f,
-    getCurrentDirectory: () => process.cwd(),
-    getNewLine: () => "\n"
-  });
-}
-function normalizeFileName(ts, fileName) {
-  let normalized = import_path.default.normalize(fileName);
-  if (normalized.endsWith(import_path.default.sep)) {
-    normalized = normalized.slice(0, -1);
-  }
-  if (ts.sys.useCaseSensitiveFileNames) {
-    return toAbsolutePath(normalized, null);
-  }
-  return toAbsolutePath(normalized.toLowerCase(), null);
-}
-function toAbsolutePath(filePath, baseDir) {
-  return import_path.default.isAbsolute(filePath) ? filePath : import_path.default.join(baseDir || process.cwd(), filePath);
-}
-
-// src/parser/ts-for-v5/resolve-project-list.ts
-var import_fast_glob = require("fast-glob");
-var import_is_glob = __toESM(require("is-glob"));
-var path3 = __toESM(require("path"));
-var import_module = require("module");
-function resolveProjectList(options) {
-  const sanitizedProjects = [];
-  if (typeof options.project === "string") {
-    sanitizedProjects.push(options.project);
-  } else if (Array.isArray(options.project)) {
-    for (const project of options.project) {
-      if (typeof project === "string") {
-        sanitizedProjects.push(project);
-      }
-    }
-  }
-  if (sanitizedProjects.length === 0) {
-    return [];
-  }
-  const projectFolderIgnoreList = (options.projectFolderIgnoreList ?? ["**/node_modules/**"]).reduce((acc, folder) => {
-    if (typeof folder === "string") {
-      acc.push(folder);
-    }
-    return acc;
-  }, []).map((folder) => folder.startsWith("!") ? folder : `!${folder}`);
-  const nonGlobProjects = sanitizedProjects.filter(
-    (project) => !(0, import_is_glob.default)(project)
-  );
-  const globProjects = sanitizedProjects.filter((project) => (0, import_is_glob.default)(project));
-  const uniqueCanonicalProjectPaths = new Set(
-    nonGlobProjects.concat(
-      globProjects.length === 0 ? [] : (0, import_fast_glob.sync)([...globProjects, ...projectFolderIgnoreList], {
-        cwd: options.tsconfigRootDir
-      })
-    ).map(
-      (project) => getCanonicalFileName(
-        ensureAbsolutePath(project, options.tsconfigRootDir)
-      )
-    )
-  );
-  const returnValue = Array.from(uniqueCanonicalProjectPaths);
-  return returnValue;
-}
-var _correctPathCasing;
-function correctPathCasing(filePath) {
-  if (_correctPathCasing === void 0) {
-    const ts = (0, import_module.createRequire)(
-      path3.join(process.cwd(), "__placeholder__.js")
-    )("typescript");
-    const useCaseSensitiveFileNames = ts.sys !== void 0 ? ts.sys.useCaseSensitiveFileNames : true;
-    _correctPathCasing = useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase();
-  }
-  return _correctPathCasing(filePath);
-}
-function getCanonicalFileName(filePath) {
-  let normalized = path3.normalize(filePath);
-  if (normalized.endsWith(path3.sep)) {
-    normalized = normalized.slice(0, -1);
-  }
-  return correctPathCasing(normalized);
-}
-function ensureAbsolutePath(p, tsconfigRootDir) {
-  return path3.isAbsolute(p) ? p : path3.join(tsconfigRootDir || process.cwd(), p);
-}
-
-// src/parser/ts-for-v5/parse-tsx-for-typescript.ts
-var DEFAULT_EXTRA_FILE_EXTENSIONS = [".vue", ".svelte", ".astro"];
-function parseTsxForTypeScript(code, options, tsEslintParser, ts) {
-  const programs = [];
-  for (const option of iterateOptions(options)) {
-    programs.push(getTSProgram(code, option, ts));
-  }
-  const parserOptions = {
-    ...options,
-    programs
-  };
-  return tsEslintParser.parseForESLint(code, parserOptions);
-}
-function* iterateOptions(options) {
-  if (!options) {
-    throw new Error("`parserOptions` is required.");
-  }
-  if (!options.filePath) {
-    throw new Error("`filePath` is required.");
-  }
-  if (!options.project) {
-    throw new Error(
-      "Specify `parserOptions.project`. Otherwise there is no point in using this parser."
-    );
-  }
-  const tsconfigRootDir = typeof options.tsconfigRootDir === "string" ? options.tsconfigRootDir : process.cwd();
-  const projects = resolveProjectList({
-    project: getProjectConfigFiles(
-      { tsconfigRootDir, filePath: options.filePath },
-      options.project
-    ),
-    projectFolderIgnoreList: options.projectFolderIgnoreList,
-    tsconfigRootDir
-  });
-  for (const project of projects) {
-    yield {
-      project,
-      filePath: options.filePath,
-      extraFileExtensions: options.extraFileExtensions || DEFAULT_EXTRA_FILE_EXTENSIONS
-    };
-  }
-}
-
-// src/parser/ts-patch.ts
-function tsPatch(scriptParserOptions, tsParserName) {
-  if (tsParserName === "typescript-eslint-parser-for-extra-files") {
-    return {
-      terminate() {
-      }
-    };
-  }
-  let targetExt = ".astro";
-  if (scriptParserOptions.filePath) {
-    const ext = import_path2.default.extname(scriptParserOptions.filePath);
-    if (ext) {
-      targetExt = ext;
-    }
-  }
-  try {
-    const cwd = process.cwd();
-    const relativeTo = import_path2.default.join(cwd, "__placeholder__.js");
-    const ts = (0, import_module2.createRequire)(relativeTo)("typescript");
-    if ((0, import_semver.satisfies)(ts.version, ">=5")) {
-      const result = tsPatchForV5(ts, scriptParserOptions);
-      if (result) {
-        return result;
-      }
-    } else {
-      const result = tsPatchForV4(ts, targetExt);
-      if (result) {
-        return result;
-      }
-    }
-  } catch {
-  }
-  const tsxFilePath = `${scriptParserOptions.filePath}.tsx`;
-  scriptParserOptions.filePath = tsxFilePath;
-  if (!import_fs.default.existsSync(tsxFilePath)) {
-    import_fs.default.writeFileSync(tsxFilePath, "/* temp for astro-eslint-parser */");
-    return {
-      terminate() {
-        import_fs.default.unlinkSync(tsxFilePath);
-      }
-    };
-  }
-  return null;
-}
-function tsPatchForV5(ts, scriptParserOptions) {
-  return {
-    terminate() {
-    },
-    parse(code, parser) {
-      return parseTsxForTypeScript(
-        code,
-        scriptParserOptions,
-        parser,
-        ts
-      );
-    }
-  };
-}
-function tsPatchForV4(ts, targetExt) {
-  const { ensureScriptKind, getScriptKindFromFileName } = ts;
-  if (typeof ensureScriptKind !== "function" || typeof getScriptKindFromFileName !== "function") {
-    return null;
-  }
-  ts.ensureScriptKind = function(fileName, ...args) {
-    if (fileName.endsWith(targetExt)) {
-      return ts.ScriptKind.TSX;
-    }
-    return ensureScriptKind.call(this, fileName, ...args);
-  };
-  ts.getScriptKindFromFileName = function(fileName, ...args) {
-    if (fileName.endsWith(targetExt)) {
-      return ts.ScriptKind.TSX;
-    }
-    return getScriptKindFromFileName.call(this, fileName, ...args);
-  };
-  if (ts.ensureScriptKind === ensureScriptKind || ts.getScriptKindFromFileName === getScriptKindFromFileName) {
-    return null;
-  }
-  return {
-    terminate() {
-      ts.ensureScriptKind = ensureScriptKind;
-      ts.getScriptKindFromFileName = getScriptKindFromFileName;
-    }
-  };
-}
-
-// src/context/resolve-parser/parser-object.ts
-function isParserObject(value) {
-  return isEnhancedParserObject(value) || isBasicParserObject(value);
-}
-function isEnhancedParserObject(value) {
-  return Boolean(value && typeof value.parseForESLint === "function");
-}
-function isBasicParserObject(value) {
-  return Boolean(value && typeof value.parse === "function");
-}
-function maybeTSESLintParserObject(value) {
-  return isEnhancedParserObject(value) && isBasicParserObject(value) && typeof value.createProgram === "function" && typeof value.clearCaches === "function" && typeof value.version === "string";
-}
-function getTSParserNameFromObject(value) {
-  if (!isEnhancedParserObject(value)) {
-    return null;
-  }
-  if (value.name === "typescript-eslint-parser-for-extra-files")
-    return "typescript-eslint-parser-for-extra-files";
-  if (value.meta?.name === "typescript-eslint/parser")
-    return "@typescript-eslint/parser";
-  return null;
-}
-function isTSESLintParserObject(value) {
-  if (!isEnhancedParserObject(value)) return false;
-  if (value.name === "typescript-eslint-parser-for-extra-files")
-    return true;
-  if (value.meta?.name === "typescript-eslint/parser") return true;
-  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
-var import_types = require("@typescript-eslint/types");
-var import_scope_manager2 = require("@typescript-eslint/scope-manager");
-
-// 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
-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 removeTargetScopes = /* @__PURE__ */ new Set();
-  traverseNodes(target, {
-    visitorKeys: info.visitorKeys,
-    enterNode(node) {
-      const scope = info.scopeManager.acquire(node);
-      if (scope) {
-        removeTargetScopes.add(scope);
-        return;
-      }
-      if (node.type === "Identifier" || node.type === "JSXIdentifier") {
-        let targetScope = getInnermostScopeFromNode(info.scopeManager, node);
-        while (targetScope && targetScope.block.type !== "Program" && target.range[0] <= targetScope.block.range[0] && targetScope.block.range[1] <= target.range[1]) {
-          targetScope = targetScope.upper;
-        }
-        if (removeTargetScopes.has(targetScope)) {
-          return;
-        }
-        removeIdentifierVariable(node, targetScope);
-        removeIdentifierReference(node, targetScope);
-      }
-    },
-    leaveNode() {
-    }
-  });
-  for (const scope of removeTargetScopes) {
-    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/eslint-scope.ts
-var eslintScope = __toESM(require("eslint-scope"));
-var import_semver2 = __toESM(require("semver"));
-var import_path3 = __toESM(require("path"));
-var import_module3 = require("module");
-var eslintScopeCache = null;
-function getEslintScope() {
-  return eslintScopeCache ?? (eslintScopeCache = getNewest());
-}
-function getNewest() {
-  let newest = eslintScope;
-  const userEslintScope = getEslintScopeFromUser();
-  if (userEslintScope && userEslintScope.version != null && import_semver2.default.lte(newest.version, userEslintScope.version)) {
-    newest = userEslintScope;
-  }
-  const eslintEslintScope = getEslintScopeFromEslint();
-  if (eslintEslintScope && eslintEslintScope.version != null && import_semver2.default.lte(newest.version, eslintEslintScope.version)) {
-    newest = eslintEslintScope;
-  }
-  return newest;
-}
-function getEslintScopeFromUser() {
-  try {
-    const cwd = process.cwd();
-    const relativeTo = import_path3.default.join(cwd, "__placeholder__.js");
-    return (0, import_module3.createRequire)(relativeTo)("eslint-scope");
-  } catch {
-    return null;
-  }
-}
-function getEslintScopeFromEslint() {
-  try {
-    const cwd = process.cwd();
-    const requireFromUser = (0, import_module3.createRequire)(import_path3.default.join(cwd, "__placeholder__.js"));
-    const eslintPackagePath = requireFromUser.resolve("eslint/package.json");
-    const requireFromEslint = (0, import_module3.createRequire)(
-      eslintPackagePath.replace(/package\.json$/, "__placeholder__.js")
-    );
-    return requireFromEslint("eslint-scope");
-  } catch {
-    return null;
-  }
-}
-
-// src/parser/script.ts
-var eslintScope2 = getEslintScope();
-function parseScript(code, ctx, parserOptionsCtx) {
-  const result = parseScriptInternal(code, ctx, parserOptionsCtx);
-  const parserOptions = parserOptionsCtx.parserOptions;
-  if (!result.scopeManager && parserOptions.eslintScopeManager) {
-    result.scopeManager = analyzeScope(result, parserOptions);
-  }
-  return result;
-}
-function analyzeScope(result, parserOptions) {
-  try {
-    return (0, import_scope_manager2.analyze)(result.ast, {
-      globalReturn: parserOptions.ecmaFeatures?.globalReturn,
-      jsxPragma: parserOptions.jsxPragma,
-      jsxFragmentName: parserOptions.jsxFragmentName,
-      lib: parserOptions.lib,
-      sourceType: parserOptions.sourceType
-    });
-  } catch {
-  }
-  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();
-  let patchResult;
-  try {
-    const parserOptions = parserOptionsCtx.parserOptions;
-    if (parserOptionsCtx.isTypeScript() && parserOptions.filePath && parserOptions.project) {
-      patchResult = tsPatch(parserOptions, parserOptionsCtx.getTSParserName());
-    } else if (parserOptionsCtx.isTypeScript() && parserOptions.filePath && parserOptions.projectService) {
-      console.warn(
-        "`astro-eslint-parser` does not support the `projectService` option, it will parse it as `project: true` instead."
-      );
-      patchResult = tsPatch(
-        { ...parserOptions, project: true, projectService: void 0 },
-        parserOptionsCtx.getTSParserName()
-      );
-    }
-    const result = isEnhancedParserObject(parser) ? patchResult?.parse ? patchResult.parse(code, parser) : parser.parseForESLint(code, parserOptions) : parser.parse(code, parserOptions);
-    if ("ast" in result && result.ast != null) {
-      return result;
-    }
-    return { ast: result };
-  } catch (e) {
-    debug(
-      "[script] parsing error:",
-      e.message,
-      `@ ${JSON.stringify(code)}
-
-${code}`
-    );
-    throw e;
-  } finally {
-    patchResult?.terminate();
-  }
-}
-var Referencer = class extends eslintScope2.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 eslintScope2.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) {
-  return tokens.sort((a, b) => {
-    if (a.range[0] !== b.range[0]) {
-      return a.range[0] - b.range[0];
-    }
-    return a.range[1] - b.range[1];
-  });
-}
-
-// src/parser/process-template.ts
-var import_types2 = require("@typescript-eslint/types");
-
-// src/astro/index.ts
-var import_decode = require("entities/decode");
-
-// src/errors.ts
-var ParseError = class extends SyntaxError {
-  /**
-   * Initialize this ParseError instance.
-   */
-  constructor(message, offset, ctx) {
-    super(message);
-    if (typeof offset === "number") {
-      this.index = offset;
-      const loc = ctx.getLocFromIndex(offset);
-      this.lineNumber = loc.line;
-      this.column = loc.column;
-    } else {
-      this.index = ctx.getIndexFromLoc(offset);
-      this.lineNumber = offset.line;
-      this.column = offset.column;
-    }
-    this.originalAST = ctx.originalAST;
-  }
-};
-
-// src/astro/index.ts
-function isTag(node) {
-  return node.type === "element" || node.type === "custom-element" || node.type === "component" || node.type === "fragment";
-}
-function isParent(node) {
-  return Array.isArray(node.children);
-}
-function walkElements(parent, code, enter, leave, parents = []) {
-  const children = getSortedChildren(parent, code);
-  const currParents = [parent, ...parents];
-  for (const node of children) {
-    enter(node, currParents);
-    if (isParent(node)) {
-      walkElements(node, code, enter, leave, currParents);
-    }
-    leave(node, currParents);
-  }
-}
-function walk(parent, code, enter, leave) {
-  walkElements(
-    parent,
-    code,
-    (node, parents) => {
-      enter(node, parents);
-      if (isTag(node)) {
-        const attrParents = [node, ...parents];
-        for (const attr of node.attributes) {
-          enter(attr, attrParents);
-          leave(attr, attrParents);
-        }
-      }
-    },
-    leave
-  );
-}
-function calcStartTagEndOffset(node, ctx) {
-  const lastAttr = node.attributes[node.attributes.length - 1];
-  let beforeCloseIndex;
-  if (lastAttr) {
-    beforeCloseIndex = calcAttributeEndOffset(lastAttr, ctx);
-  } else {
-    const info2 = getTokenInfo(
-      ctx,
-      [`<${node.name}`],
-      node.position.start.offset
-    );
-    beforeCloseIndex = info2.index + info2.match.length;
-  }
-  const info = getTokenInfo(ctx, [[">", "/>"]], beforeCloseIndex);
-  return info.index + info.match.length;
-}
-function calcAttributeEndOffset(node, ctx) {
-  let info;
-  if (node.kind === "empty") {
-    info = getTokenInfo(ctx, [node.name], node.position.start.offset);
-  } else if (node.kind === "quoted") {
-    info = getTokenInfo(
-      ctx,
-      [
-        [
-          {
-            token: `"${node.value}"`,
-            htmlEntityDecode: true
-          },
-          {
-            token: `'${node.value}'`,
-            htmlEntityDecode: true
-          },
-          {
-            token: node.value,
-            htmlEntityDecode: true
-          }
-        ]
-      ],
-      calcAttributeValueStartOffset(node, ctx)
-    );
-  } else if (node.kind === "expression") {
-    info = getTokenInfo(
-      ctx,
-      ["{", node.value, "}"],
-      calcAttributeValueStartOffset(node, ctx)
-    );
-  } else if (node.kind === "shorthand") {
-    info = getTokenInfo(
-      ctx,
-      ["{", node.name, "}"],
-      node.position.start.offset
-    );
-  } else if (node.kind === "spread") {
-    info = getTokenInfo(
-      ctx,
-      ["{", "...", node.name, "}"],
-      node.position.start.offset
-    );
-  } else if (node.kind === "template-literal") {
-    info = getTokenInfo(
-      ctx,
-      [`\`${node.value}\``],
-      calcAttributeValueStartOffset(node, ctx)
-    );
-  } else {
-    throw new ParseError(
-      `Unknown attr kind: ${node.kind}`,
-      node.position.start.offset,
-      ctx
-    );
-  }
-  return info.index + info.match.length;
-}
-function calcAttributeValueStartOffset(node, ctx) {
-  let info;
-  if (node.kind === "quoted") {
-    info = getTokenInfo(
-      ctx,
-      [
-        node.name,
-        "=",
-        [`"`, `'`, { token: node.value, htmlEntityDecode: true }]
-      ],
-      node.position.start.offset
-    );
-  } else if (node.kind === "expression") {
-    info = getTokenInfo(
-      ctx,
-      [node.name, "=", "{"],
-      node.position.start.offset
-    );
-  } else if (node.kind === "template-literal") {
-    info = getTokenInfo(
-      ctx,
-      [node.name, "=", "`"],
-      node.position.start.offset
-    );
-  } else {
-    throw new ParseError(
-      `Unknown attr kind: ${node.kind}`,
-      node.position.start.offset,
-      ctx
-    );
-  }
-  return info.index;
-}
-function getEndOffset(node, ctx) {
-  if (node.position.end?.offset != null) {
-    return node.position.end.offset;
-  }
-  if (isTag(node)) return calcTagEndOffset(node, ctx);
-  if (node.type === "expression") return calcExpressionEndOffset(node, ctx);
-  if (node.type === "comment") return calcCommentEndOffset(node, ctx);
-  if (node.type === "frontmatter") {
-    const start = node.position.start.offset;
-    return ctx.code.indexOf("---", start + 3) + 3;
-  }
-  if (node.type === "doctype") {
-    const start = node.position.start.offset;
-    return ctx.code.indexOf(">", start) + 1;
-  }
-  if (node.type === "text") {
-    const start = node.position.start.offset;
-    return start + node.value.length;
-  }
-  if (node.type === "root") {
-    return ctx.code.length;
-  }
-  throw new Error(`unknown type: ${node.type}`);
-}
-function calcContentEndOffset(parent, ctx) {
-  const code = ctx.code;
-  if (isTag(parent)) {
-    const end = getEndOffset(parent, ctx);
-    if (code[end - 1] !== ">") {
-      return end;
-    }
-    const index = code.lastIndexOf("</", end - 1);
-    if (index >= 0 && code.slice(index + 2, end - 1).trim() === parent.name) {
-      return index;
-    }
-    return end;
-  } else if (parent.type === "expression") {
-    const end = getEndOffset(parent, ctx);
-    return code.lastIndexOf("}", end);
-  } else if (parent.type === "root") {
-    return code.length;
-  }
-  throw new Error(`unknown type: ${parent.type}`);
-}
-function getSelfClosingTag(node, ctx) {
-  if (node.children.length > 0) {
-    return null;
-  }
-  const code = ctx.code;
-  const startTagEndOffset = calcStartTagEndOffset(node, ctx);
-  if (code.startsWith("/>", startTagEndOffset - 2)) {
-    return {
-      offset: startTagEndOffset,
-      end: "/>"
-    };
-  }
-  if (code.startsWith(`</${node.name}`, startTagEndOffset)) {
-    return null;
-  }
-  return {
-    offset: startTagEndOffset,
-    end: ">"
-  };
-}
-function getEndTag(node, ctx) {
-  let beforeIndex;
-  if (node.children.length) {
-    const lastChild = node.children[node.children.length - 1];
-    beforeIndex = getEndOffset(lastChild, ctx);
-  } else {
-    beforeIndex = calcStartTagEndOffset(node, ctx);
-  }
-  beforeIndex = skipSpaces(ctx.code, beforeIndex);
-  if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-    const offset = beforeIndex;
-    beforeIndex = beforeIndex + 2 + node.name.length;
-    const info = getTokenInfo(ctx, [">"], beforeIndex);
-    const end = info.index + info.match.length;
-    return {
-      offset,
-      tag: ctx.code.slice(offset, end)
-    };
-  }
-  return null;
-}
-function calcCommentEndOffset(node, ctx) {
-  const info = getTokenInfo(
-    ctx,
-    ["<!--", node.value, "-->"],
-    node.position.start.offset
-  );
-  return info.index + info.match.length;
-}
-function calcTagEndOffset(node, ctx) {
-  let beforeIndex;
-  if (node.children.length) {
-    const lastChild = node.children[node.children.length - 1];
-    beforeIndex = getEndOffset(lastChild, ctx);
-  } else {
-    beforeIndex = calcStartTagEndOffset(node, ctx);
-  }
-  beforeIndex = skipSpaces(ctx.code, beforeIndex);
-  if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-    beforeIndex = beforeIndex + 2 + node.name.length;
-    const info = getTokenInfo(ctx, [">"], beforeIndex);
-    return info.index + info.match.length;
-  }
-  return beforeIndex;
-}
-function calcExpressionEndOffset(node, ctx) {
-  if (node.children.length) {
-    const lastChild = node.children[node.children.length - 1];
-    const beforeIndex = getEndOffset(lastChild, ctx);
-    const info2 = getTokenInfo(ctx, ["}"], beforeIndex);
-    return info2.index + info2.match.length;
-  }
-  const info = getTokenInfo(ctx, ["{", "}"], node.position.start.offset);
-  return info.index + info.match.length;
-}
-function getTokenInfo(ctx, tokens, position) {
-  let lastMatch;
-  for (const t of tokens) {
-    const index = lastMatch ? lastMatch.index + lastMatch.match.length : position;
-    const m = Array.isArray(t) ? matchOfForMulti(t, index) : match(t, index);
-    if (m == null) {
-      throw new ParseError(
-        `Unknown token at ${index}, expected: ${JSON.stringify(
-          t
-        )}, actual: ${JSON.stringify(ctx.code.slice(index, index + 10))}`,
-        index,
-        ctx
-      );
-    }
-    lastMatch = m;
-  }
-  return lastMatch;
-  function match(token, position2) {
-    const search = typeof token === "string" ? token : token.token;
-    const index = search.trim() === search ? skipSpaces(ctx.code, position2) : position2;
-    if (ctx.code.startsWith(search, index)) {
-      return {
-        match: search,
-        index
-      };
-    }
-    if (typeof token !== "string") {
-      return matchWithHTMLEntity(token, index);
-    }
-    return null;
-  }
-  function matchOfForMulti(search, position2) {
-    for (const s of search) {
-      const m = match(s, position2);
-      if (m) {
-        return m;
-      }
-    }
-    return null;
-  }
-  function matchWithHTMLEntity(token, position2) {
-    const search = token.token;
-    let codeOffset = position2;
-    let searchOffset = 0;
-    while (searchOffset < search.length) {
-      const searchChar = search[searchOffset];
-      if (ctx.code[codeOffset] === searchChar) {
-        if (searchChar === "&") {
-          const entityCandidate = ctx.code.slice(codeOffset, codeOffset + 5);
-          if (entityCandidate === "&amp;" || entityCandidate === "&AMP;") {
-            codeOffset += 5;
-            searchOffset++;
-            continue;
-          }
-        }
-        codeOffset++;
-        searchOffset++;
-        continue;
-      }
-      const entity = getHTMLEntity(codeOffset);
-      if (entity?.entity === searchChar) {
-        codeOffset += entity.length;
-        searchOffset++;
-        continue;
-      }
-      return null;
-    }
-    return {
-      match: ctx.code.slice(position2, codeOffset),
-      index: position2
-    };
-    function getHTMLEntity(position3) {
-      let codeOffset2 = position3;
-      if (ctx.code[codeOffset2++] !== "&") return null;
-      let entity = "";
-      const entityDecoder = new import_decode.EntityDecoder(
-        import_decode.htmlDecodeTree,
-        (cp) => entity += String.fromCodePoint(cp)
-      );
-      entityDecoder.startEntity(import_decode.DecodingMode.Attribute);
-      const length = entityDecoder.write(ctx.code, codeOffset2);
-      if (length < 0) {
-        return null;
-      }
-      if (length === 0) {
-        return null;
-      }
-      return {
-        entity,
-        length
-      };
-    }
-  }
-}
-function skipSpaces(string, position) {
-  const re = /\s*/g;
-  re.lastIndex = position;
-  const match = re.exec(string);
-  if (match) {
-    return match.index + match[0].length;
-  }
-  return position;
-}
-function getSortedChildren(parent, code) {
-  if (parent.type === "root" && parent.children[0]?.type === "frontmatter") {
-    const children = [...parent.children];
-    if (children.every((n) => n.position)) {
-      return children.sort(
-        (a, b) => a.position.start.offset - b.position.start.offset
-      );
-    }
-    let start = skipSpaces(code, 0);
-    if (code.startsWith("<!", start)) {
-      const frontmatter = children.shift();
-      const before = [];
-      let first;
-      while (first = children.shift()) {
-        start = skipSpaces(code, start);
-        if (first.type === "comment" && code.startsWith("<!--", start)) {
-          start = code.indexOf("-->", start + 4) + 3;
-          before.push(first);
-        } else if (first.type === "doctype" && code.startsWith("<!", start)) {
-          start = code.indexOf(">", start + 2) + 1;
-          before.push(first);
-        } else {
-          children.unshift(first);
-          break;
-        }
-      }
-      return [...before, frontmatter, ...children];
-    }
-  }
-  return parent.children;
-}
-
-// src/context/restore.ts
-var RestoreNodeProcessContext = class {
-  constructor(result, nodeMap) {
-    this.removeTokens = /* @__PURE__ */ new Set();
-    this.result = result;
-    this.nodeMap = nodeMap;
-  }
-  addRemoveToken(test) {
-    this.removeTokens.add(test);
-  }
-  getParent(node) {
-    return this.nodeMap.get(node) || null;
-  }
-  findToken(startIndex) {
-    const tokens = this.result.ast.tokens || [];
-    return tokens.find((t) => t.range[0] === startIndex) || null;
-  }
-};
-var RestoreContext = class {
-  constructor(ctx) {
-    this.offsets = [];
-    this.virtualFragments = [];
-    this.restoreNodeProcesses = [];
-    this.tokens = [];
-    this.ctx = ctx;
-  }
-  addRestoreNodeProcess(process2) {
-    this.restoreNodeProcesses.push(process2);
-  }
-  addOffset(offset) {
-    this.offsets.push(offset);
-  }
-  addVirtualFragmentRange(start, end) {
-    const peek = this.virtualFragments[this.virtualFragments.length - 1];
-    if (peek && peek.end === start) {
-      peek.end = end;
-      return;
-    }
-    this.virtualFragments.push({ start, end });
-  }
-  addToken(type, range) {
-    if (range[0] >= range[1]) {
-      return;
-    }
-    this.tokens.push(this.ctx.buildToken(type, range));
-  }
-  /**
-   * Restore AST nodes
-   */
-  restore(result) {
-    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
-      )
-    });
-    restoreNodes(result, nodeMap, this.restoreNodeProcesses);
-    const firstOffset = Math.min(
-      ...[result.ast.body[0], result.ast.tokens?.[0], result.ast.comments?.[0]].filter((t) => Boolean(t)).map((t) => t.range[0])
-    );
-    if (firstOffset < result.ast.range[0]) {
-      result.ast.range[0] = firstOffset;
-      result.ast.loc.start = this.ctx.getLocFromIndex(firstOffset);
-    }
-  }
-  remapLocation(node) {
-    let [start, end] = node.range;
-    const startFragment = this.virtualFragments.find(
-      (f) => f.start <= start && start < f.end
-    );
-    if (startFragment) {
-      start = startFragment.end;
-    }
-    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;
-      start = end;
-      end = w;
-    }
-    const locs = this.ctx.getLocations(...this.getRemapRange(start, end));
-    node.loc = locs.loc;
-    node.range = locs.range;
-    if (node.start != null) {
-      delete node.start;
-    }
-    if (node.end != null) {
-      delete node.end;
-    }
-  }
-  getRemapRange(start, end) {
-    if (!this.offsets.length) {
-      return [start, end];
-    }
-    let lastStart = this.offsets[0];
-    let lastEnd = this.offsets[0];
-    for (const offset of this.offsets) {
-      if (offset.dist <= start) {
-        lastStart = offset;
-      }
-      if (offset.dist < end) {
-        lastEnd = offset;
-      } else {
-        if (offset.dist === end && start === end) {
-          lastEnd = offset;
-        }
-        break;
-      }
-    }
-    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 VirtualScriptContext(ctx);
-  let fragmentOpened = false;
-  function openRootFragment(startOffset) {
-    script.appendVirtualScript("<>");
-    fragmentOpened = true;
-    script.restoreContext.addRestoreNodeProcess((scriptNode, { result }) => {
-      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;
-        delete rootFragment.openingFragment;
-        rootFragment.type = "AstroFragment";
-        return true;
-      }
-      return false;
-    });
-  }
-  walkElements(
-    resultTemplate.ast,
-    ctx.code,
-    // eslint-disable-next-line complexity -- X(
-    (node, [parent]) => {
-      if (node.type === "frontmatter") {
-        const start = node.position.start.offset;
-        if (fragmentOpened) {
-          script.appendVirtualScript("</>;");
-          fragmentOpened = false;
-        }
-        script.appendOriginal(start);
-        script.skipOriginalOffset(3);
-        const end = getEndOffset(node, ctx);
-        const scriptStart = start + 3;
-        let scriptEnd = end - 3;
-        let endChar;
-        while (scriptStart < scriptEnd - 1 && (endChar = ctx.code[scriptEnd - 1]) && !endChar.trim()) {
-          scriptEnd--;
-        }
-        script.appendOriginal(scriptEnd);
-        script.appendVirtualScript("\n;");
-        script.skipOriginalOffset(end - scriptEnd);
-        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_types2.AST_NODE_TYPES.EmptyStatement) {
-                if (st.range[0] === scriptEnd && st.range[1] === scriptEnd) {
-                  result.ast.body.splice(index, 1);
-                  break;
-                }
-              }
-            }
-            return true;
-          }
-        );
-        script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.Punctuator, [
-          node.position.start.offset,
-          node.position.start.offset + 3
-        ]);
-        script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.Punctuator, [
-          end - 3,
-          end
-        ]);
-      } else if (isTag(node)) {
-        if (parent.type === "expression") {
-          const siblings = parent.children.filter(
-            (n) => n.type !== "text" || n.value.trim()
-          );
-          const index = siblings.indexOf(node);
-          const before = siblings[index - 1];
-          if (!before || !isTag(before)) {
-            const after = siblings[index + 1];
-            if (after && (isTag(after) || after.type === "comment")) {
-              const start2 = node.position.start.offset;
-              script.appendOriginal(start2);
-              script.appendVirtualScript("<>");
-              script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-                if (scriptNode.range[0] === start2 && scriptNode.type === import_types2.AST_NODE_TYPES.JSXFragment) {
-                  delete scriptNode.openingFragment;
-                  delete scriptNode.closingFragment;
-                  const fragmentNode = scriptNode;
-                  fragmentNode.type = "AstroFragment";
-                  const last = fragmentNode.children[fragmentNode.children.length - 1];
-                  if (fragmentNode.range[1] < last.range[1]) {
-                    fragmentNode.range[1] = last.range[1];
-                    fragmentNode.loc.end = ctx.getLocFromIndex(
-                      fragmentNode.range[1]
-                    );
-                  }
-                  return true;
-                }
-                return false;
-              });
-            }
-          }
-        }
-        const start = node.position.start.offset;
-        script.appendOriginal(start);
-        if (!fragmentOpened) {
-          openRootFragment(start);
-        }
-        for (const attr of node.attributes) {
-          if (attr.kind === "quoted" || attr.kind === "empty" || attr.kind === "expression" || attr.kind === "template-literal") {
-            const needPunctuatorsProcess = node.type === "component" || node.type === "fragment" ? /[.:@]/u.test(attr.name) : /[.@]/u.test(attr.name) || attr.name.startsWith(":");
-            if (needPunctuatorsProcess) {
-              processAttributePunctuators(attr);
-            }
-          }
-          if (attr.kind === "quoted") {
-            if (attr.raw && !attr.raw.startsWith('"') && !attr.raw.startsWith("'")) {
-              const attrStart = attr.position.start.offset;
-              const start2 = calcAttributeValueStartOffset(attr, ctx);
-              const end = calcAttributeEndOffset(attr, ctx);
-              script.appendOriginal(start2);
-              script.appendVirtualScript('"');
-              script.appendOriginal(end);
-              script.appendVirtualScript('"');
-              script.restoreContext.addRestoreNodeProcess(
-                (scriptNode, context) => {
-                  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);
-                      attrNode.value.raw = raw;
-                      context.findToken(start2).value = raw;
-                      return true;
-                    }
-                  }
-                  return false;
-                }
-              );
-            }
-          } else 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.appendVirtualScript(`${jsxName}=`);
-            script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start2) {
-                const attrNode = scriptNode;
-                attrNode.type = "AstroShorthandAttribute";
-                const locs = ctx.getLocations(
-                  ...attrNode.value.expression.range
-                );
-                if (jsxName !== attr.name) {
-                  attrNode.name.name = attr.name;
-                }
-                attrNode.name.range = locs.range;
-                attrNode.name.loc = locs.loc;
-                return true;
-              }
-              return false;
-            });
-          } else if (attr.kind === "template-literal") {
-            const attrStart = attr.position.start.offset;
-            const start2 = calcAttributeValueStartOffset(attr, ctx);
-            const end = calcAttributeEndOffset(attr, ctx);
-            script.appendOriginal(start2);
-            script.appendVirtualScript("{");
-            script.appendOriginal(end);
-            script.appendVirtualScript("}");
-            script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
-                const attrNode = scriptNode;
-                attrNode.type = "AstroTemplateLiteralAttribute";
-                return true;
-              }
-              return false;
-            });
-          }
-        }
-        const closing = getSelfClosingTag(node, ctx);
-        if (closing && closing.end === ">") {
-          script.appendOriginal(closing.offset - 1);
-          script.appendVirtualScript("/");
-        }
-        if (node.name === "script" || node.name === "style" || node.attributes.some((attr) => attr.name === "is:raw")) {
-          const text = node.children[0];
-          if (text && text.type === "text") {
-            const styleNodeStart = node.position.start.offset;
-            const start2 = text.position.start.offset;
-            script.appendOriginal(start2);
-            script.skipOriginalOffset(text.value.length);
-            script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-              if (scriptNode.type === import_types2.AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
-                const textNode = {
-                  type: "AstroRawText",
-                  value: text.value,
-                  raw: text.value,
-                  parent: scriptNode,
-                  ...ctx.getLocations(start2, start2 + text.value.length)
-                };
-                scriptNode.children = [textNode];
-                return true;
-              }
-              return false;
-            });
-            script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXText, [
-              start2,
-              start2 + text.value.length
-            ]);
-          }
-        }
-      } else if (node.type === "comment") {
-        const start = node.position.start.offset;
-        const end = getEndOffset(node, ctx);
-        const length = end - start;
-        script.appendOriginal(start);
-        if (!fragmentOpened) {
-          openRootFragment(start);
-        }
-        script.appendOriginal(start + 1);
-        script.appendVirtualScript(`></`);
-        script.skipOriginalOffset(length - 2);
-        script.appendOriginal(end);
-        script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-          if (scriptNode.range[0] === start && scriptNode.type === import_types2.AST_NODE_TYPES.JSXFragment) {
-            delete scriptNode.children;
-            delete scriptNode.openingFragment;
-            delete scriptNode.closingFragment;
-            delete scriptNode.expression;
-            const commentNode = scriptNode;
-            commentNode.type = "AstroHTMLComment";
-            commentNode.value = node.value;
-            context.addRemoveToken(
-              (token) => token.value === "<" && token.range[0] === scriptNode.range[0]
-            );
-            context.addRemoveToken(
-              (token) => token.value === ">" && token.range[1] === scriptNode.range[1]
-            );
-            return true;
-          }
-          return false;
-        });
-        script.restoreContext.addToken("HTMLComment", [
-          start,
-          start + length
-        ]);
-      } else if (node.type === "doctype") {
-        const start = node.position.start.offset;
-        const end = getEndOffset(node, ctx);
-        const length = end - start;
-        script.appendOriginal(start);
-        if (!fragmentOpened) {
-          openRootFragment(start);
-        }
-        script.appendOriginal(start + 1);
-        script.appendVirtualScript(`></`);
-        script.skipOriginalOffset(length - 2);
-        script.appendOriginal(end);
-        script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-          if (scriptNode.range[0] === start && scriptNode.type === import_types2.AST_NODE_TYPES.JSXFragment) {
-            delete scriptNode.children;
-            delete scriptNode.openingFragment;
-            delete scriptNode.closingFragment;
-            delete scriptNode.expression;
-            const doctypeNode = scriptNode;
-            doctypeNode.type = "AstroDoctype";
-            context.addRemoveToken(
-              (token) => token.value === "<" && token.range[0] === scriptNode.range[0]
-            );
-            context.addRemoveToken(
-              (token) => token.value === ">" && token.range[1] === scriptNode.range[1]
-            );
-            return true;
-          }
-          return false;
-        });
-        script.restoreContext.addToken("HTMLDocType", [
-          start,
-          end
-        ]);
-      } else {
-        const start = node.position.start.offset;
-        script.appendOriginal(start);
-        if (!fragmentOpened) {
-          openRootFragment(start);
-        }
-      }
-    },
-    (node, [parent]) => {
-      if (isTag(node)) {
-        const closing = getSelfClosingTag(node, ctx);
-        if (!closing) {
-          const end = getEndTag(node, ctx);
-          if (!end) {
-            const offset = calcContentEndOffset(node, ctx);
-            script.appendOriginal(offset);
-            script.appendVirtualScript(`</${node.name}>`);
-            script.restoreContext.addRestoreNodeProcess(
-              (scriptNode, context) => {
-                const parent2 = context.getParent(scriptNode);
-                if (scriptNode.range[0] === offset && scriptNode.type === import_types2.AST_NODE_TYPES.JSXClosingElement && parent2.type === import_types2.AST_NODE_TYPES.JSXElement) {
-                  removeAllScopeAndVariableAndReference(scriptNode, {
-                    visitorKeys: context.result.visitorKeys,
-                    scopeManager: context.result.scopeManager
-                  });
-                  parent2.closingElement = null;
-                  return true;
-                }
-                return false;
-              }
-            );
-          }
-        }
-      }
-      if ((isTag(node) || node.type === "comment") && parent.type === "expression") {
-        const siblings = parent.children.filter(
-          (n) => n.type !== "text" || n.value.trim()
-        );
-        const index = siblings.indexOf(node);
-        const after = siblings[index + 1];
-        if (!after || !isTag(after) && after.type !== "comment") {
-          const before = siblings[index - 1];
-          if (before && (isTag(before) || before.type === "comment")) {
-            const end = getEndOffset(node, ctx);
-            script.appendOriginal(end);
-            script.appendVirtualScript("</>");
-          }
-        }
-      }
-    }
-  );
-  if (fragmentOpened) {
-    const last = resultTemplate.ast.children[resultTemplate.ast.children.length - 1];
-    const end = getEndOffset(last, ctx);
-    script.appendOriginal(end);
-    script.appendVirtualScript("</>;");
-  }
-  script.appendOriginal(ctx.code.length);
-  return script;
-  function processAttributePunctuators(attr) {
-    const start = attr.position.start.offset;
-    let targetIndex = start;
-    let colonOffset;
-    for (let index = 0; index < attr.name.length; index++) {
-      const char = attr.name[index];
-      if (char !== ":" && char !== "." && char !== "@") {
-        continue;
-      }
-      if (index === 0) {
-        targetIndex++;
-      }
-      const punctuatorIndex = start + index;
-      script.appendOriginal(punctuatorIndex);
-      script.skipOriginalOffset(1);
-      script.appendVirtualScript(`_`);
-      if (char === ":" && index !== 0 && colonOffset == null) {
-        colonOffset = index;
-      }
-    }
-    if (colonOffset != null) {
-      const punctuatorIndex = start + colonOffset;
-      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXIdentifier, [
-        start,
-        punctuatorIndex
-      ]);
-      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.Punctuator, [
-        punctuatorIndex,
-        punctuatorIndex + 1
-      ]);
-      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXIdentifier, [
-        punctuatorIndex + 1,
-        start + attr.name.length
-      ]);
-    } else {
-      script.restoreContext.addToken(import_types2.AST_TOKEN_TYPES.JSXIdentifier, [
-        start,
-        start + attr.name.length
-      ]);
-    }
-    script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-      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_types2.AST_NODE_TYPES.JSXNamespacedName;
-          nameNode.namespace = {
-            type: import_types2.AST_NODE_TYPES.JSXIdentifier,
-            name: attr.name.slice(0, colonOffset),
-            ...ctx.getLocations(
-              baseNameNode.range[0],
-              baseNameNode.range[0] + colonOffset
-            )
-          };
-          nameNode.name = {
-            type: import_types2.AST_NODE_TYPES.JSXIdentifier,
-            name: attr.name.slice(colonOffset + 1),
-            ...ctx.getLocations(
-              baseNameNode.range[0] + colonOffset + 1,
-              baseNameNode.range[1]
-            )
-          };
-          scriptNode.name = nameNode;
-          nameNode.namespace.parent = nameNode;
-          nameNode.name.parent = nameNode;
-        } else {
-          if (baseNameNode.type === import_types2.AST_NODE_TYPES.JSXIdentifier) {
-            const nameNode = baseNameNode;
-            nameNode.name = attr.name;
-            scriptNode.name = nameNode;
-          } else {
-            const nameNode = baseNameNode;
-            nameNode.namespace.name = attr.name.slice(
-              baseNameNode.namespace.range[0] - start,
-              baseNameNode.namespace.range[1] - start
-            );
-            nameNode.name.name = attr.name.slice(
-              baseNameNode.name.range[0] - start,
-              baseNameNode.name.range[1] - start
-            );
-            scriptNode.name = nameNode;
-            nameNode.namespace.parent = nameNode;
-            nameNode.name.parent = nameNode;
-          }
-        }
-        context.addRemoveToken(
-          (token) => token.range[0] === baseNameNode.range[0] && token.range[1] === baseNameNode.range[1]
-        );
-        return true;
-      }
-      return false;
-    });
-  }
-  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/context/index.ts
-var Context = class {
-  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);
-    if (!loc) {
-      loc = this.locs.getLocFromIndex(index);
-      this.locsMap.set(index, loc);
-    }
-    return {
-      line: loc.line,
-      column: loc.column
-    };
-  }
-  getIndexFromLoc(loc) {
-    return this.locs.getIndexFromLoc(loc);
-  }
-  /**
-   * Get the location information of the given indexes.
-   */
-  getLocations(start, end) {
-    return {
-      range: [start, end],
-      loc: {
-        start: this.getLocFromIndex(start),
-        end: this.getLocFromIndex(end)
-      }
-    };
-  }
-  /**
-   * Build token
-   */
-  buildToken(type, range) {
-    return {
-      type,
-      value: this.getText(range),
-      ...this.getLocations(...range)
-    };
-  }
-  /**
-   * get text
-   */
-  getText(range) {
-    return this.code.slice(range[0], range[1]);
-  }
-  get originalAST() {
-    return this.state.originalAST;
-  }
-  set originalAST(originalAST) {
-    this.state.originalAST = originalAST;
-  }
-};
-var LinesAndColumns = class {
-  constructor(origCode) {
-    const len = origCode.length;
-    const lineStartIndices = [0];
-    const crs = [];
-    let normalizedCode = "";
-    for (let index = 0; index < len; ) {
-      const c = origCode[index++];
-      if (c === "\r") {
-        const next = origCode[index++] || "";
-        if (next === "\n") {
-          normalizedCode += next;
-          crs.push(index - 2);
-          lineStartIndices.push(index);
-        } else {
-          normalizedCode += `
-${next}`;
-          lineStartIndices.push(index - 1);
-        }
-      } else {
-        normalizedCode += c;
-        if (c === "\n") {
-          lineStartIndices.push(index);
-        }
-      }
-    }
-    this.lineStartIndices = lineStartIndices;
-    this.code = origCode;
-    this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
-  }
-  getLocFromIndex(index) {
-    const lineNumber = sortedLastIndex(
-      this.lineStartIndices,
-      (target) => target - index
-    );
-    return {
-      line: lineNumber,
-      column: index - this.lineStartIndices[lineNumber - 1]
-    };
-  }
-  getIndexFromLoc(loc) {
-    const lineIndex = loc.line - 1;
-    if (this.lineStartIndices.length > lineIndex) {
-      const lineStartIndex = this.lineStartIndices[lineIndex];
-      const positionIndex = lineStartIndex + loc.column;
-      return positionIndex;
-    } else if (this.lineStartIndices.length === lineIndex) {
-      return this.code.length + loc.column;
-    }
-    return this.code.length + loc.column;
-  }
-  getNormalizedLineFeed() {
-    return this.normalizedLineFeed;
-  }
-};
-var NormalizedLineFeed = class {
-  get needRemap() {
-    return this.offsets.length > 0;
-  }
-  constructor(code, offsets) {
-    this.code = code;
-    this.offsets = offsets;
-    if (offsets.length) {
-      const cache = {};
-      this.remapIndex = (index) => {
-        let result = cache[index];
-        if (result != null) {
-          return result;
-        }
-        result = index;
-        for (const offset of offsets) {
-          if (offset < result) {
-            result++;
-          } else {
-            break;
-          }
-        }
-        return cache[index] = result;
-      };
-    } else {
-      this.remapIndex = (i) => i;
-    }
-  }
-};
-
-// src/parser/astro-parser/parse.ts
-var service = __toESM(require("astrojs-compiler-sync"));
-function parse2(code, ctx) {
-  const result = service.parse(code, { position: true });
-  for (const { code: code2, text, location, severity } of result.diagnostics || []) {
-    if (severity === 1) {
-      ctx.originalAST = result.ast;
-      throw new ParseError(`${text} [${code2}]`, location, ctx);
-    }
-  }
-  if (!result.ast.children) {
-    result.ast.children = [];
-  }
-  const htmlElement = result.ast.children.find(
-    (n) => n.type === "element" && n.name === "html"
-  );
-  if (!result._adjusted) {
-    if (htmlElement) {
-      adjustHTML(result.ast, htmlElement, ctx);
-    }
-    fixLocations(result.ast, ctx);
-    result._adjusted = true;
-  }
-  return result;
-}
-function adjustHTML(ast, htmlElement, ctx) {
-  const htmlEnd = ctx.code.indexOf("</html");
-  if (htmlEnd < 0) {
-    return;
-  }
-  const isOffsetAfter = buildComparableOffsetComparator(ctx.code);
-  const hasTokenAfter = Boolean(ctx.code.slice(htmlEnd + 7).trim());
-  const children = [...htmlElement.children];
-  for (const child of children) {
-    const offset = child.position?.start.offset;
-    if (hasTokenAfter && offset != null) {
-      if (isOffsetAfter(offset, htmlEnd)) {
-        htmlElement.children.splice(htmlElement.children.indexOf(child), 1);
-        ast.children.push(child);
-      }
-    }
-    if (child.type === "element" && child.name === "body") {
-      adjustHTMLBody(
-        ast,
-        htmlElement,
-        htmlEnd,
-        hasTokenAfter,
-        child,
-        ctx,
-        isOffsetAfter
-      );
-    }
-  }
-  function buildComparableOffsetComparator(code) {
-    let remapOffset;
-    const comparableOffsetCache = /* @__PURE__ */ new Map();
-    return (offset, threshold) => {
-      if (threshold > offset) {
-        return false;
-      }
-      let comparableOffset = comparableOffsetCache.get(offset);
-      if (comparableOffset == null) {
-        remapOffset || (remapOffset = buildComparableOffsetRemapper(code));
-        comparableOffset = remapOffset(offset);
-        comparableOffsetCache.set(offset, comparableOffset);
-      }
-      return threshold <= comparableOffset;
-    };
-  }
-  function buildComparableOffsetRemapper(code) {
-    let byteOffsets, codeUnitOffsets;
-    for (let index = 0, byteOffset = 0; index < code.length; ) {
-      const codePoint = code.codePointAt(index);
-      const codeUnitLength = codePoint > 65535 ? 2 : 1;
-      const nextIndex = index + codeUnitLength;
-      const nextByteOffset = byteOffset + getUTF8ByteLength(codePoint);
-      if (byteOffsets) {
-        byteOffsets.push(nextByteOffset);
-        codeUnitOffsets.push(nextIndex);
-      } else if (codePoint > 127) {
-        byteOffsets = [0];
-        codeUnitOffsets = [0];
-        for (let asciiOffset = 1; asciiOffset <= index; asciiOffset++) {
-          byteOffsets.push(asciiOffset);
-          codeUnitOffsets.push(asciiOffset);
-        }
-        byteOffsets.push(nextByteOffset);
-        codeUnitOffsets.push(nextIndex);
-      }
-      index = nextIndex;
-      byteOffset = nextByteOffset;
-    }
-    if (!byteOffsets || !codeUnitOffsets) {
-      return (offset) => offset;
-    }
-    return (offset) => {
-      const index = sortedLastIndex(byteOffsets, (target) => target - offset) - 1;
-      return codeUnitOffsets[Math.max(index, 0)];
-    };
-  }
-  function getUTF8ByteLength(codePoint) {
-    if (codePoint <= 127) {
-      return 1;
-    }
-    if (codePoint <= 2047) {
-      return 2;
-    }
-    if (codePoint <= 65535) {
-      return 3;
-    }
-    return 4;
-  }
-}
-function adjustHTMLBody(ast, htmlElement, htmlEnd, hasTokenAfterHtmlEnd, bodyElement, ctx, isOffsetAfter) {
-  const bodyEnd = ctx.code.indexOf("</body");
-  if (bodyEnd == null) {
-    return;
-  }
-  const hasTokenAfter = Boolean(ctx.code.slice(bodyEnd + 7, htmlEnd).trim());
-  if (!hasTokenAfter && !hasTokenAfterHtmlEnd) {
-    return;
-  }
-  const children = [...bodyElement.children];
-  for (const child of children) {
-    const offset = child.position?.start.offset;
-    if (offset != null && isOffsetAfter(offset, bodyEnd)) {
-      if (hasTokenAfterHtmlEnd && isOffsetAfter(offset, htmlEnd)) {
-        bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
-        ast.children.push(child);
-      } else if (hasTokenAfter) {
-        bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
-        htmlElement.children.push(child);
-      }
-    }
-  }
-}
-function fixLocations(node, ctx) {
-  let start = 0;
-  walk(
-    node,
-    ctx.code,
-    // eslint-disable-next-line complexity -- X(
-    (node2, [parent]) => {
-      if (node2.type === "frontmatter") {
-        start = node2.position.start.offset = tokenIndex(ctx, "---", start);
-        if (!node2.position.end) {
-          node2.position.end = {};
-        }
-        start = node2.position.end.offset = tokenIndex(ctx, "---", start + 3 + node2.value.length) + 3;
-      } else if (node2.type === "fragment" || node2.type === "element" || node2.type === "component" || node2.type === "custom-element") {
-        if (!node2.position) {
-          node2.position = { start: {}, end: {} };
-        }
-        start = node2.position.start.offset = tokenIndex(ctx, "<", start);
-        start += 1;
-        start += node2.name.length;
-        if (!node2.attributes.length) {
-          start = calcStartTagEndOffset(node2, ctx);
-        }
-      } else if (node2.type === "attribute") {
-        fixLocationForAttr(node2, ctx, start);
-        start = calcAttributeEndOffset(node2, ctx);
-        if (node2.position.end) {
-          node2.position.end.offset = start;
-        }
-      } else if (node2.type === "comment") {
-        node2.position.start.offset = tokenIndex(ctx, "<!--", start);
-        start = calcCommentEndOffset(node2, ctx);
-        if (node2.position.end) {
-          node2.position.end.offset = start;
-        }
-      } else if (node2.type === "text") {
-        if (parent.type === "element" && (parent.name === "script" || parent.name === "style")) {
-          node2.position.start.offset = start;
-          start = ctx.code.indexOf(`</${parent.name}`, start);
-          if (start < 0) {
-            start = ctx.code.length;
-          }
-        } else {
-          const index = tokenIndexSafe(ctx.code, node2.value, start);
-          if (index != null) {
-            start = node2.position.start.offset = index;
-            start += node2.value.length;
-          } else {
-            node2.position.start.offset = start;
-            const value = node2.value.replace(/\s+/gu, "");
-            for (const char of value) {
-              const index2 = tokenIndex(ctx, char, start);
-              start = index2 + 1;
-            }
-            start = skipSpaces(ctx.code, start);
-            node2.value = ctx.code.slice(node2.position.start.offset, start);
-          }
-        }
-        if (node2.position.end) {
-          node2.position.end.offset = start;
-        }
-      } else if (node2.type === "expression") {
-        start = node2.position.start.offset = tokenIndex(ctx, "{", start);
-        start += 1;
-      } else if (node2.type === "doctype") {
-        if (!node2.position) {
-          node2.position = { start: {}, end: {} };
-        }
-        if (!node2.position.end) {
-          node2.position.end = {};
-        }
-        start = node2.position.start.offset = tokenIndex(ctx, "<!", start);
-        start += 2;
-        start = node2.position.end.offset = ctx.code.indexOf(">", start) + 1;
-      } else if (node2.type === "root") {
-      }
-    },
-    (node2, [parent]) => {
-      if (node2.type === "attribute") {
-        const attributes = parent.attributes;
-        if (attributes[attributes.length - 1] === node2) {
-          start = calcStartTagEndOffset(parent, ctx);
-        }
-      } else if (node2.type === "expression") {
-        start = tokenIndex(ctx, "}", start) + 1;
-      } else if (node2.type === "fragment" || node2.type === "element" || node2.type === "component" || node2.type === "custom-element") {
-        if (!getSelfClosingTag(node2, ctx)) {
-          const closeTagStart = tokenIndexSafe(
-            ctx.code,
-            `</${node2.name}`,
-            start
-          );
-          if (closeTagStart != null) {
-            start = closeTagStart + 2 + node2.name.length;
-            start = tokenIndex(ctx, ">", start) + 1;
-          }
-        }
-      } else {
-        return;
-      }
-      if (node2.position.end) {
-        node2.position.end.offset = start;
-      }
-    }
-  );
-}
-function fixLocationForAttr(node, ctx, start) {
-  if (node.kind === "empty") {
-    node.position.start.offset = tokenIndex(ctx, node.name, start);
-  } else if (node.kind === "quoted") {
-    node.position.start.offset = tokenIndex(ctx, node.name, start);
-  } else if (node.kind === "expression") {
-    node.position.start.offset = tokenIndex(ctx, node.name, start);
-  } else if (node.kind === "shorthand") {
-    node.position.start.offset = tokenIndex(ctx, "{", start);
-  } else if (node.kind === "spread") {
-    node.position.start.offset = tokenIndex(ctx, "{", start);
-  } else if (node.kind === "template-literal") {
-    node.position.start.offset = tokenIndex(ctx, node.name, start);
-  } else {
-    throw new ParseError(
-      `Unknown attr kind: ${node.kind}`,
-      node.position.start.offset,
-      ctx
-    );
-  }
-}
-function tokenIndex(ctx, token, position) {
-  const index = tokenIndexSafe(ctx.code, token, position);
-  if (index == null) {
-    const start = token.trim() === token ? skipSpaces(ctx.code, position) : position;
-    throw new ParseError(
-      `Unknown token at ${start}, expected: ${JSON.stringify(
-        token
-      )}, actual: ${JSON.stringify(ctx.code.slice(start, start + 10))}`,
-      start,
-      ctx
-    );
-  }
-  return index;
-}
-function tokenIndexSafe(string, token, position) {
-  const index = token.trim() === token ? skipSpaces(string, position) : position;
-  if (string.startsWith(token, index)) {
-    return index;
-  }
-  return null;
-}
-
-// src/parser/lru-cache.ts
-var LruCache = class extends Map {
-  constructor(capacity) {
-    super();
-    this.capacity = capacity;
-  }
-  get(key) {
-    if (!this.has(key)) {
-      return void 0;
-    }
-    const value = super.get(key);
-    this.set(key, value);
-    return value;
-  }
-  set(key, value) {
-    this.delete(key);
-    super.set(key, value);
-    if (this.size > this.capacity) {
-      this.deleteOldestEntry();
-    }
-    return this;
-  }
-  deleteOldestEntry() {
-    for (const entry of this) {
-      this.delete(entry[0]);
-      return;
-    }
-  }
-};
-
-// src/parser/template.ts
-var lruCache = new LruCache(5);
-function parseTemplate(code, filePath) {
-  const cache = lruCache.get(code);
-  if (cache) {
-    return cache;
-  }
-  const ctx = new Context(code, filePath);
-  const normalized = ctx.locs.getNormalizedLineFeed();
-  const ctxForAstro = normalized.needRemap ? new Context(normalized.code, filePath) : ctx;
-  try {
-    const result = parse2(normalized?.code ?? code, ctxForAstro);
-    if (normalized.needRemap) {
-      remap(result, normalized, code, ctxForAstro);
-      ctx.originalAST = ctxForAstro.originalAST;
-    }
-    const templateResult = {
-      result,
-      context: ctx
-    };
-    lruCache.set(code, templateResult);
-    return templateResult;
-  } catch (e) {
-    if (typeof e.pos === "number") {
-      const err = new ParseError(e.message, normalized?.remapIndex(e.pos), ctx);
-      err.astroCompilerError = e;
-      throw err;
-    }
-    throw e;
-  }
-}
-function remap(result, normalized, originalCode, ctxForAstro) {
-  const remapDataMap = /* @__PURE__ */ new Map();
-  walk(
-    result.ast,
-    normalized.code,
-    (node) => {
-      const start = normalized.remapIndex(node.position.start.offset);
-      let end, value;
-      if (node.position.end) {
-        end = normalized.remapIndex(node.position.end.offset);
-        if (node.position.start.offset === start && node.position.end.offset === end) {
-          return;
-        }
-      }
-      if (node.type === "text") {
-        value = originalCode.slice(
-          start,
-          normalized.remapIndex(getEndOffset(node, ctxForAstro))
-        );
-      } else if (node.type === "comment") {
-        value = originalCode.slice(
-          start + 4,
-          normalized.remapIndex(getEndOffset(node, ctxForAstro)) - 3
-        );
-      } else if (node.type === "attribute") {
-        if (node.kind !== "empty" && node.kind !== "shorthand" && node.kind !== "spread") {
-          let valueStart = normalized.remapIndex(
-            calcAttributeValueStartOffset(node, ctxForAstro)
-          );
-          let valueEnd = normalized.remapIndex(
-            calcAttributeEndOffset(node, ctxForAstro)
-          );
-          if (node.kind !== "quoted" || originalCode[valueStart] === '"' || originalCode[valueStart] === "'") {
-            valueStart++;
-            valueEnd--;
-          }
-          value = originalCode.slice(valueStart, valueEnd);
-        }
-      }
-      remapDataMap.set(node, {
-        start,
-        end,
-        value
-      });
-    },
-    (_node) => {
-    }
-  );
-  for (const [node, remapData] of remapDataMap) {
-    node.position.start.offset = remapData.start;
-    if (node.position.end) {
-      node.position.end.offset = remapData.end;
-    }
-    if (node.type === "text" || node.type === "comment" || node.type === "attribute" && node.kind !== "empty" && node.kind !== "shorthand" && node.kind !== "spread") {
-      node.value = remapData.value;
-    }
-  }
-}
-
-// src/context/parser-options.ts
-var import_path5 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
-
-// src/context/resolve-parser/espree.ts
-var import_module4 = require("module");
-var import_path4 = __toESM(require("path"));
-var espreeCache = null;
-function isLinterPath(p) {
-  return (
-    // ESLint 6 and above
-    p.includes(`eslint${import_path4.default.sep}lib${import_path4.default.sep}linter${import_path4.default.sep}linter.js`) || // ESLint 5
-    p.includes(`eslint${import_path4.default.sep}lib${import_path4.default.sep}linter.js`)
-  );
-}
-function getEspree() {
-  if (!espreeCache) {
-    const linterPath = Object.keys(require.cache || {}).find(isLinterPath);
-    if (linterPath) {
-      try {
-        espreeCache = (0, import_module4.createRequire)(linterPath)("espree");
-      } catch {
-      }
-    }
-    if (!espreeCache) {
-      espreeCache = require("espree");
-    }
-  }
-  return espreeCache;
-}
-
-// src/context/resolve-parser/index.ts
-function getParserForLang(attrs, parser) {
-  if (parser) {
-    if (typeof parser === "string" || isParserObject(parser)) {
-      return parser;
-    }
-    if (typeof parser === "object") {
-      const value = parser[attrs.lang || "js"];
-      if (typeof value === "string" || isParserObject(value)) {
-        return value;
-      }
-    }
-  }
-  return "espree";
-}
-function getParser(attrs, parser) {
-  const parserValue = getParserForLang(attrs, parser);
-  if (isParserObject(parserValue)) {
-    return parserValue;
-  }
-  if (parserValue !== "espree") {
-    return require(parserValue);
-  }
-  return getEspree();
-}
-
-// 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 = {};
-    const parserOptions = {
-      ecmaVersion: 2020,
-      sourceType: "module",
-      loc: true,
-      range: true,
-      raw: true,
-      tokens: true,
-      comment: true,
-      eslintVisitorKeys: true,
-      // eslintScopeManager: true,
-      ...options || {}
-    };
-    parserOptions.ecmaFeatures = {
-      ...parserOptions.ecmaFeatures || {},
-      jsx: true
-    };
-    parserOptions.sourceType = "module";
-    if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
-      parserOptions.ecmaVersion = 2015;
-    }
-    this.parserOptions = parserOptions;
-  }
-  getParser() {
-    return getParser({}, this.parserOptions.parser);
-  }
-  getTSParserName() {
-    if (this.state.ts != null) {
-      return this.state.ts === false ? null : this.state.ts.parserName;
-    }
-    const parserValue = getParserForLang({}, this.parserOptions?.parser);
-    if (typeof parserValue !== "string") {
-      const name2 = getTSParserNameFromObject(parserValue);
-      if (name2) {
-        this.state.ts = { parserName: name2 };
-        return this.state.ts.parserName;
-      }
-      if (maybeTSESLintParserObject(parserValue) || isTSESLintParserObject(parserValue)) {
-        this.state.ts = { parserName: "$unknown$" };
-        return this.state.ts.parserName;
-      }
-      this.state.ts = false;
-      return null;
-    }
-    const parserName = parserValue;
-    if (TS_PARSER_NAMES.includes(parserName)) {
-      this.state.ts = { parserName };
-      return this.state.ts.parserName;
-    }
-    if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
-      let targetPath = parserName;
-      while (targetPath) {
-        const pkgPath = import_path5.default.join(targetPath, "package.json");
-        if (import_fs2.default.existsSync(pkgPath)) {
-          try {
-            const pkgName = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf-8"))?.name;
-            if (TS_PARSER_NAMES.includes(pkgName)) {
-              this.state.ts = { parserName: pkgName };
-              return this.state.ts.parserName;
-            }
-            this.state.ts = false;
-            return null;
-          } catch {
-            this.state.ts = false;
-            return null;
-          }
-        }
-        const parent = import_path5.default.dirname(targetPath);
-        if (targetPath === parent) {
-          break;
-        }
-        targetPath = parent;
-      }
-    }
-    this.state.ts = false;
-    return null;
-  }
-  isTypeScript() {
-    return Boolean(this.getTSParserName());
-  }
-};
-
-// src/parser/index.ts
-function parseForESLint(code, options) {
-  const { result: resultTemplate, context: ctx } = parseTemplate(
-    code,
-    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,
-              {
-                read: true,
-                typeRef: true,
-                forceUsed: true
-              }
-            );
-          }
-          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.restoreContext.restore(resultScript);
-  sort(resultScript.ast.comments);
-  sort(resultScript.ast.tokens);
-  extractTokens(resultScript, ctx);
-  resultScript.services = Object.assign(resultScript.services || {}, {
-    isAstro: true,
-    getAstroAst() {
-      return resultTemplate.ast;
-    },
-    getAstroResult() {
-      return resultTemplate;
-    }
-  });
-  resultScript.visitorKeys = Object.assign({}, KEYS, resultScript.visitorKeys);
-  return resultScript;
-}
-function extractTokens(ast, ctx) {
-  if (!ast.ast.tokens) {
-    return;
-  }
-  const useRanges = sort([...ast.ast.tokens, ...ast.ast.comments || []]).map(
-    (t) => t.range
-  );
-  let range = useRanges.shift();
-  for (let index = 0; index < ctx.code.length; index++) {
-    while (range && range[1] <= index) {
-      range = useRanges.shift();
-    }
-    if (range && range[0] <= index) {
-      index = range[1] - 1;
-      continue;
-    }
-    const c = ctx.code[index];
-    if (!c.trim()) {
-      continue;
-    }
-    if (isPunctuator(c)) {
-      ast.ast.tokens.push(
-        ctx.buildToken(import_types3.AST_TOKEN_TYPES.Punctuator, [index, index + 1])
-      );
-    } else {
-      ast.ast.tokens.push(
-        ctx.buildToken(import_types3.AST_TOKEN_TYPES.Identifier, [index, index + 1])
-      );
-    }
-  }
-  sort(ast.ast.tokens);
-  function isPunctuator(c) {
-    return /^[^\w$]$/iu.test(c);
-  }
-}
-
-// src/astro-tools/index.ts
-function parseTemplate2(code) {
-  const parsed = parseTemplate(code);
-  return {
-    result: parsed.result,
-    getEndOffset: (node) => getEndOffset(node, parsed.context),
-    calcAttributeValueStartOffset: (node) => calcAttributeValueStartOffset(node, parsed.context),
-    calcAttributeEndOffset: (node) => calcAttributeEndOffset(node, parsed.context),
-    walk(parent, enter, leave) {
-      walk(
-        parent,
-        code,
-        enter,
-        leave || (() => {
-        })
-      );
-    },
-    getLocFromIndex: (index) => parsed.context.getLocFromIndex(index),
-    getIndexFromLoc: (loc) => parsed.context.locs.getIndexFromLoc(loc)
-  };
-}
-
-// src/ast/index.ts
-var ast_exports = {};
-
-// src/meta.ts
-var meta_exports = {};
-__export(meta_exports, {
-  name: () => name,
-  version: () => version
-});
-
-// package.json
-var name = "astro-eslint-parser";
-var version = "1.3.2";
-
-// src/index.ts
-function parseForESLint2(code, options) {
-  return parseForESLint(code, options);
-}
-var VisitorKeys = KEYS;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AST,
-  ParseError,
-  VisitorKeys,
-  meta,
-  name,
-  parseForESLint,
-  parseTemplate,
-  traverseNodes
-});