@stainless-api/playgrounds 0.0.1-beta.0

package/src/codemirror/typescript/prettier-plugin-external-typescript.vendor.js

@@ -0,0 +1,4968 @@
+/* eslint-disable */
+/* @ts-nocheck */
+import ts from './cdn-typescript';
+
+/**
+ * `prettier/plugins/typescript` uses a bundled version of typescript.
+ * this is a build patched to externalize it so our bundles are smaller.
+ */
+
+// scripts/build/shims/debug.js
+var debug = () => () => {};
+var debug_default = debug;
+
+// scripts/build/shims/shared.js
+var OPTIONAL_OBJECT = 1;
+var createMethodShim =
+  (methodName, getImplementation) =>
+  (flags, object, ...arguments_) => {
+    if (flags | OPTIONAL_OBJECT && (object === void 0 || object === null)) {
+      return;
+    }
+    const implementation = getImplementation.call(object) ?? object[methodName];
+    return implementation.apply(object, arguments_);
+  };
+
+// scripts/build/shims/method-replace-all.js
+var stringReplaceAll =
+  String.prototype.replaceAll ??
+  function (pattern, replacement) {
+    if (pattern.global) {
+      return this.replace(pattern, replacement);
+    }
+    return this.split(pattern).join(replacement);
+  };
+var replaceAll = createMethodShim('replaceAll', function () {
+  if (typeof this === 'string') {
+    return stringReplaceAll;
+  }
+});
+var method_replace_all_default = replaceAll;
+
+// node_modules/@typescript-eslint/typescript-estree/dist/convert.js
+
+// node_modules/@typescript-eslint/typescript-estree/dist/check-modifiers.js
+
+// node_modules/@typescript-eslint/typescript-estree/dist/getModifiers.js
+
+// node_modules/@typescript-eslint/typescript-estree/dist/version-check.js
+var typescriptVersionIsAtLeast = new Proxy({}, { get: () => true });
+
+// node_modules/@typescript-eslint/typescript-estree/dist/getModifiers.js
+var isAtLeast48 = typescriptVersionIsAtLeast['4.8'];
+function getModifiers2(node, includeIllegalModifiers = false) {
+  if (node == null) {
+    return void 0;
+  }
+  if (isAtLeast48) {
+    if (includeIllegalModifiers || ts.canHaveModifiers(node)) {
+      const modifiers = ts.getModifiers(node);
+      return modifiers ? [...modifiers] : void 0;
+    }
+    return void 0;
+  }
+  return (
+    // @ts-expect-error intentional fallback for older TS versions
+    node.modifiers?.filter((m) => !ts.isDecorator(m))
+  );
+}
+function getDecorators2(node, includeIllegalDecorators = false) {
+  if (node == null) {
+    return void 0;
+  }
+  if (isAtLeast48) {
+    if (includeIllegalDecorators || ts.canHaveDecorators(node)) {
+      const decorators = ts.getDecorators(node);
+      return decorators ? [...decorators] : void 0;
+    }
+    return void 0;
+  }
+  return (
+    // @ts-expect-error intentional fallback for older TS versions
+    node.decorators?.filter(ts.isDecorator)
+  );
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/node-utils.js
+
+// node_modules/@typescript-eslint/typescript-estree/dist/jsx/xhtml-entities.js
+var xhtmlEntities = {};
+
+// node_modules/@typescript-eslint/types/dist/generated/ast-spec.js
+var TYPE_STORE = new Proxy({}, { get: (_, type) => type });
+
+// node_modules/@typescript-eslint/types/dist/index.js
+var AST_NODE_TYPES = TYPE_STORE;
+var AST_TOKEN_TYPES = TYPE_STORE;
+
+// node_modules/@typescript-eslint/typescript-estree/dist/ts-estree/index.js
+var AST_NODE_TYPES2 = AST_NODE_TYPES;
+var AST_TOKEN_TYPES2 = AST_TOKEN_TYPES;
+
+// node_modules/@typescript-eslint/typescript-estree/dist/node-utils.js
+var isAtLeast50 = typescriptVersionIsAtLeast['5.0'];
+var SyntaxKind2 = ts.SyntaxKind;
+var LOGICAL_OPERATORS = /* @__PURE__ */ new Set([
+  SyntaxKind2.AmpersandAmpersandToken,
+  SyntaxKind2.BarBarToken,
+  SyntaxKind2.QuestionQuestionToken,
+]);
+var ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
+  ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+  ts.SyntaxKind.AmpersandEqualsToken,
+  ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+  ts.SyntaxKind.AsteriskEqualsToken,
+  ts.SyntaxKind.BarBarEqualsToken,
+  ts.SyntaxKind.BarEqualsToken,
+  ts.SyntaxKind.CaretEqualsToken,
+  ts.SyntaxKind.EqualsToken,
+  ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+  ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+  ts.SyntaxKind.LessThanLessThanEqualsToken,
+  ts.SyntaxKind.MinusEqualsToken,
+  ts.SyntaxKind.PercentEqualsToken,
+  ts.SyntaxKind.PlusEqualsToken,
+  ts.SyntaxKind.QuestionQuestionEqualsToken,
+  ts.SyntaxKind.SlashEqualsToken,
+]);
+var BINARY_OPERATORS = /* @__PURE__ */ new Set([
+  SyntaxKind2.AmpersandAmpersandToken,
+  SyntaxKind2.AmpersandToken,
+  SyntaxKind2.AsteriskAsteriskToken,
+  SyntaxKind2.AsteriskToken,
+  SyntaxKind2.BarBarToken,
+  SyntaxKind2.BarToken,
+  SyntaxKind2.CaretToken,
+  SyntaxKind2.EqualsEqualsEqualsToken,
+  SyntaxKind2.EqualsEqualsToken,
+  SyntaxKind2.ExclamationEqualsEqualsToken,
+  SyntaxKind2.ExclamationEqualsToken,
+  SyntaxKind2.GreaterThanEqualsToken,
+  SyntaxKind2.GreaterThanGreaterThanGreaterThanToken,
+  SyntaxKind2.GreaterThanGreaterThanToken,
+  SyntaxKind2.GreaterThanToken,
+  SyntaxKind2.InKeyword,
+  SyntaxKind2.InstanceOfKeyword,
+  SyntaxKind2.LessThanEqualsToken,
+  SyntaxKind2.LessThanLessThanToken,
+  SyntaxKind2.LessThanToken,
+  SyntaxKind2.MinusToken,
+  SyntaxKind2.PercentToken,
+  SyntaxKind2.PlusToken,
+  SyntaxKind2.SlashToken,
+]);
+function isAssignmentOperator(operator) {
+  return ASSIGNMENT_OPERATORS.has(operator.kind);
+}
+function isLogicalOperator(operator) {
+  return LOGICAL_OPERATORS.has(operator.kind);
+}
+function isESTreeBinaryOperator(operator) {
+  return BINARY_OPERATORS.has(operator.kind);
+}
+function getTextForTokenKind(kind) {
+  return ts.tokenToString(kind);
+}
+function isESTreeClassMember(node) {
+  return node.kind !== SyntaxKind2.SemicolonClassElement;
+}
+function hasModifier(modifierKind, node) {
+  const modifiers = (0, getModifiers2)(node);
+  return modifiers?.some((modifier) => modifier.kind === modifierKind) === true;
+}
+function getLastModifier(node) {
+  const modifiers = (0, getModifiers2)(node);
+  if (modifiers == null) {
+    return null;
+  }
+  return modifiers[modifiers.length - 1] ?? null;
+}
+function isComma(token) {
+  return token.kind === SyntaxKind2.CommaToken;
+}
+function isComment(node) {
+  return (
+    node.kind === SyntaxKind2.SingleLineCommentTrivia || node.kind === SyntaxKind2.MultiLineCommentTrivia
+  );
+}
+function isJSDocComment(node) {
+  return node.kind === SyntaxKind2.JSDocComment;
+}
+function getBinaryExpressionType(operator) {
+  if (isAssignmentOperator(operator)) {
+    return {
+      type: AST_NODE_TYPES2.AssignmentExpression,
+      operator: getTextForTokenKind(operator.kind),
+    };
+  }
+  if (isLogicalOperator(operator)) {
+    return {
+      type: AST_NODE_TYPES2.LogicalExpression,
+      operator: getTextForTokenKind(operator.kind),
+    };
+  }
+  if (isESTreeBinaryOperator(operator)) {
+    return {
+      type: AST_NODE_TYPES2.BinaryExpression,
+      operator: getTextForTokenKind(operator.kind),
+    };
+  }
+  throw new Error(`Unexpected binary operator ${ts.tokenToString(operator.kind)}`);
+}
+function getLineAndCharacterFor(pos, ast) {
+  const loc = ast.getLineAndCharacterOfPosition(pos);
+  return {
+    column: loc.character,
+    line: loc.line + 1,
+  };
+}
+function getLocFor(range, ast) {
+  const [start, end] = range.map((pos) => getLineAndCharacterFor(pos, ast));
+  return {
+    end,
+    start,
+  };
+}
+function canContainDirective(node) {
+  if (node.kind === ts.SyntaxKind.Block) {
+    switch (node.parent.kind) {
+      case ts.SyntaxKind.Constructor:
+      case ts.SyntaxKind.GetAccessor:
+      case ts.SyntaxKind.SetAccessor:
+      case ts.SyntaxKind.ArrowFunction:
+      case ts.SyntaxKind.FunctionExpression:
+      case ts.SyntaxKind.FunctionDeclaration:
+      case ts.SyntaxKind.MethodDeclaration:
+        return true;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+function getRange(node, ast) {
+  return [node.getStart(ast), node.getEnd()];
+}
+function isToken2(node) {
+  return node.kind >= SyntaxKind2.FirstToken && node.kind <= SyntaxKind2.LastToken;
+}
+function isJSXToken(node) {
+  return node.kind >= SyntaxKind2.JsxElement && node.kind <= SyntaxKind2.JsxAttribute;
+}
+function getDeclarationKind(node) {
+  if (node.flags & ts.NodeFlags.Let) {
+    return 'let';
+  }
+  if ((node.flags & ts.NodeFlags.AwaitUsing) === ts.NodeFlags.AwaitUsing) {
+    return 'await using';
+  }
+  if (node.flags & ts.NodeFlags.Const) {
+    return 'const';
+  }
+  if (node.flags & ts.NodeFlags.Using) {
+    return 'using';
+  }
+  return 'var';
+}
+function getTSNodeAccessibility(node) {
+  const modifiers = (0, getModifiers2)(node);
+  if (modifiers == null) {
+    return void 0;
+  }
+  for (const modifier of modifiers) {
+    switch (modifier.kind) {
+      case SyntaxKind2.PublicKeyword:
+        return 'public';
+      case SyntaxKind2.ProtectedKeyword:
+        return 'protected';
+      case SyntaxKind2.PrivateKeyword:
+        return 'private';
+      default:
+        break;
+    }
+  }
+  return void 0;
+}
+function findNextToken(previousToken, parent, ast) {
+  return find(parent);
+  function find(n) {
+    if (ts.isToken(n) && n.pos === previousToken.end) {
+      return n;
+    }
+    return firstDefined(n.getChildren(ast), (child) => {
+      const shouldDiveInChildNode =
+        // previous token is enclosed somewhere in the child
+        (child.pos <= previousToken.pos && child.end > previousToken.end) || // previous token ends exactly at the beginning of child
+        child.pos === previousToken.end;
+      return shouldDiveInChildNode && nodeHasTokens(child, ast) ? find(child) : void 0;
+    });
+  }
+}
+function findFirstMatchingAncestor(node, predicate) {
+  let current = node;
+  while (current) {
+    if (predicate(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function hasJSXAncestor(node) {
+  return !!findFirstMatchingAncestor(node, isJSXToken);
+}
+function unescapeStringLiteralText(text) {
+  return method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
+    text,
+    /&(?:#\d+|#x[\da-fA-F]+|[0-9a-zA-Z]+);/g,
+    (entity) => {
+      const item = entity.slice(1, -1);
+      if (item[0] === '#') {
+        const codePoint = item[1] === 'x' ? parseInt(item.slice(2), 16) : parseInt(item.slice(1), 10);
+        return codePoint > 1114111 ? entity : String.fromCodePoint(codePoint);
+      }
+      return xhtmlEntities[item] || entity;
+    },
+  );
+}
+function isComputedProperty(node) {
+  return node.kind === SyntaxKind2.ComputedPropertyName;
+}
+function isOptional(node) {
+  return !!node.questionToken;
+}
+function isChainExpression(node) {
+  return node.type === AST_NODE_TYPES2.ChainExpression;
+}
+function isChildUnwrappableOptionalChain(node, child) {
+  return (
+    isChainExpression(child) && // (x?.y).z is semantically different, and as such .z is no longer optional
+    node.expression.kind !== ts.SyntaxKind.ParenthesizedExpression
+  );
+}
+function getTokenType(token) {
+  if (token.kind === SyntaxKind2.NullKeyword) {
+    return AST_TOKEN_TYPES2.Null;
+  }
+  if (token.kind >= SyntaxKind2.FirstKeyword && token.kind <= SyntaxKind2.LastFutureReservedWord) {
+    if (token.kind === SyntaxKind2.FalseKeyword || token.kind === SyntaxKind2.TrueKeyword) {
+      return AST_TOKEN_TYPES2.Boolean;
+    }
+    return AST_TOKEN_TYPES2.Keyword;
+  }
+  if (token.kind >= SyntaxKind2.FirstPunctuation && token.kind <= SyntaxKind2.LastPunctuation) {
+    return AST_TOKEN_TYPES2.Punctuator;
+  }
+  if (token.kind >= SyntaxKind2.NoSubstitutionTemplateLiteral && token.kind <= SyntaxKind2.TemplateTail) {
+    return AST_TOKEN_TYPES2.Template;
+  }
+  switch (token.kind) {
+    case SyntaxKind2.NumericLiteral:
+    case SyntaxKind2.BigIntLiteral:
+      return AST_TOKEN_TYPES2.Numeric;
+    case SyntaxKind2.PrivateIdentifier:
+      return AST_TOKEN_TYPES2.PrivateIdentifier;
+    case SyntaxKind2.JsxText:
+      return AST_TOKEN_TYPES2.JSXText;
+    case SyntaxKind2.StringLiteral:
+      if (token.parent.kind === SyntaxKind2.JsxAttribute || token.parent.kind === SyntaxKind2.JsxElement) {
+        return AST_TOKEN_TYPES2.JSXText;
+      }
+      return AST_TOKEN_TYPES2.String;
+    case SyntaxKind2.RegularExpressionLiteral:
+      return AST_TOKEN_TYPES2.RegularExpression;
+    case SyntaxKind2.Identifier:
+    case SyntaxKind2.ConstructorKeyword:
+    case SyntaxKind2.GetKeyword:
+    case SyntaxKind2.SetKeyword:
+    // intentional fallthrough
+    default:
+  }
+  if (token.kind === SyntaxKind2.Identifier) {
+    if (isJSXToken(token.parent)) {
+      return AST_TOKEN_TYPES2.JSXIdentifier;
+    }
+    if (token.parent.kind === SyntaxKind2.PropertyAccessExpression && hasJSXAncestor(token)) {
+      return AST_TOKEN_TYPES2.JSXIdentifier;
+    }
+  }
+  return AST_TOKEN_TYPES2.Identifier;
+}
+function convertToken(token, ast) {
+  const start = token.kind === SyntaxKind2.JsxText ? token.getFullStart() : token.getStart(ast);
+  const end = token.getEnd();
+  const value = ast.text.slice(start, end);
+  const tokenType = getTokenType(token);
+  const range = [start, end];
+  const loc = getLocFor(range, ast);
+  if (tokenType === AST_TOKEN_TYPES2.RegularExpression) {
+    return {
+      type: tokenType,
+      loc,
+      range,
+      regex: {
+        flags: value.slice(value.lastIndexOf('/') + 1),
+        pattern: value.slice(1, value.lastIndexOf('/')),
+      },
+      value,
+    };
+  }
+  if (tokenType === AST_TOKEN_TYPES2.PrivateIdentifier) {
+    return {
+      type: tokenType,
+      loc,
+      range,
+      value: value.slice(1),
+    };
+  }
+  return {
+    type: tokenType,
+    loc,
+    range,
+    value,
+  };
+}
+function convertTokens(ast) {
+  const result = [];
+  function walk(node) {
+    if (isComment(node) || isJSDocComment(node)) {
+      return;
+    }
+    if (isToken2(node) && node.kind !== SyntaxKind2.EndOfFileToken) {
+      result.push(convertToken(node, ast));
+    } else {
+      node.getChildren(ast).forEach(walk);
+    }
+  }
+  walk(ast);
+  return result;
+}
+var TSError = class extends Error {
+  fileName;
+  location;
+  constructor(message, fileName, location) {
+    super(message);
+    this.fileName = fileName;
+    this.location = location;
+    Object.defineProperty(this, 'name', {
+      configurable: true,
+      enumerable: false,
+      value: new.target.name,
+    });
+  }
+  // For old version of ESLint https://github.com/typescript-eslint/typescript-eslint/pull/6556#discussion_r1123237311
+  get index() {
+    return this.location.start.offset;
+  }
+  // https://github.com/eslint/eslint/blob/b09a512107249a4eb19ef5a37b0bd672266eafdb/lib/linter/linter.js#L853
+  get lineNumber() {
+    return this.location.start.line;
+  }
+  // https://github.com/eslint/eslint/blob/b09a512107249a4eb19ef5a37b0bd672266eafdb/lib/linter/linter.js#L854
+  get column() {
+    return this.location.start.column;
+  }
+};
+function createError(message, ast, startIndex, endIndex = startIndex) {
+  const [start, end] = [startIndex, endIndex].map((offset) => {
+    const { character: column, line } = ast.getLineAndCharacterOfPosition(offset);
+    return {
+      column,
+      line: line + 1,
+      offset,
+    };
+  });
+  return new TSError(message, ast.fileName, {
+    end,
+    start,
+  });
+}
+function nodeHasTokens(n, ast) {
+  return n.kind === SyntaxKind2.EndOfFileToken ? !!n.jsDoc : n.getWidth(ast) !== 0;
+}
+function firstDefined(array, callback) {
+  if (array === void 0) {
+    return void 0;
+  }
+  for (let i = 0; i < array.length; i++) {
+    const result = callback(array[i], i);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  return void 0;
+}
+function identifierIsThisKeyword(id) {
+  return (
+    (isAtLeast50
+      ? ts.identifierToKeywordKind(id)
+      : // @ts-expect-error -- intentional fallback for older TS versions <=4.9
+        id.originalKeywordKind) === SyntaxKind2.ThisKeyword
+  );
+}
+function isThisIdentifier(node) {
+  return !!node && node.kind === SyntaxKind2.Identifier && identifierIsThisKeyword(node);
+}
+function isThisInTypeQuery(node) {
+  if (!isThisIdentifier(node)) {
+    return false;
+  }
+  while (ts.isQualifiedName(node.parent) && node.parent.left === node) {
+    node = node.parent;
+  }
+  return node.parent.kind === SyntaxKind2.TypeQuery;
+}
+function isValidAssignmentTarget(node) {
+  switch (node.kind) {
+    case SyntaxKind2.Identifier:
+      return true;
+    case SyntaxKind2.PropertyAccessExpression:
+    case SyntaxKind2.ElementAccessExpression:
+      if (node.flags & ts.NodeFlags.OptionalChain) {
+        return false;
+      }
+      return true;
+    case SyntaxKind2.ParenthesizedExpression:
+    case SyntaxKind2.TypeAssertionExpression:
+    case SyntaxKind2.AsExpression:
+    case SyntaxKind2.SatisfiesExpression:
+    case SyntaxKind2.ExpressionWithTypeArguments:
+    case SyntaxKind2.NonNullExpression:
+      return isValidAssignmentTarget(node.expression);
+    default:
+      return false;
+  }
+}
+function getNamespaceModifiers(node) {
+  let modifiers = (0, getModifiers2)(node);
+  let moduleDeclaration = node;
+  while ((!modifiers || modifiers.length === 0) && ts.isModuleDeclaration(moduleDeclaration.parent)) {
+    const parentModifiers = (0, getModifiers2)(moduleDeclaration.parent);
+    if (parentModifiers?.length) {
+      modifiers = parentModifiers;
+    }
+    moduleDeclaration = moduleDeclaration.parent;
+  }
+  return modifiers;
+}
+function declarationNameToString(name, ast) {
+  const text = ast.text.slice(name.pos, name.end).trimStart();
+  return text || '(Missing)';
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/check-modifiers.js
+var SyntaxKind4 = ts.SyntaxKind;
+function nodeIsMissing(node) {
+  if (node == null) {
+    return true;
+  }
+  return node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind4.EndOfFileToken;
+}
+function nodeIsPresent(node) {
+  return !nodeIsMissing(node);
+}
+function hasAbstractModifier(node) {
+  return (0, hasModifier)(SyntaxKind4.AbstractKeyword, node);
+}
+function getThisParameter(signature) {
+  if (signature.parameters.length && !ts.isJSDocSignature(signature)) {
+    const thisParameter = signature.parameters[0];
+    if (parameterIsThisKeyword(thisParameter)) {
+      return thisParameter;
+    }
+  }
+  return null;
+}
+function parameterIsThisKeyword(parameter) {
+  return (0, isThisIdentifier)(parameter.name);
+}
+function getContainingFunction(node) {
+  return ts.findAncestor(node.parent, ts.isFunctionLike);
+}
+function nodeCanBeDecorated(node) {
+  switch (node.kind) {
+    case SyntaxKind4.ClassDeclaration:
+      return true;
+    case SyntaxKind4.ClassExpression:
+      return true;
+    case SyntaxKind4.PropertyDeclaration: {
+      const { parent } = node;
+      if (ts.isClassDeclaration(parent)) {
+        return true;
+      }
+      if (ts.isClassLike(parent) && !hasAbstractModifier(node)) {
+        return true;
+      }
+      return false;
+    }
+    case SyntaxKind4.GetAccessor:
+    case SyntaxKind4.SetAccessor:
+    case SyntaxKind4.MethodDeclaration: {
+      const { parent } = node;
+      return Boolean(node.body) && (ts.isClassDeclaration(parent) || ts.isClassLike(parent));
+    }
+    case SyntaxKind4.Parameter: {
+      const { parent } = node;
+      const grandparent = parent.parent;
+      return (
+        Boolean(parent) &&
+        'body' in parent &&
+        Boolean(parent.body) &&
+        (parent.kind === SyntaxKind4.Constructor ||
+          parent.kind === SyntaxKind4.MethodDeclaration ||
+          parent.kind === SyntaxKind4.SetAccessor) &&
+        getThisParameter(parent) !== node &&
+        Boolean(grandparent) &&
+        grandparent.kind === SyntaxKind4.ClassDeclaration
+      );
+    }
+  }
+  return false;
+}
+function nodeHasIllegalDecorators(node) {
+  return !!('illegalDecorators' in node && node.illegalDecorators?.length);
+}
+function throwError(node, message) {
+  const ast = node.getSourceFile();
+  const start = node.getStart(ast);
+  const end = node.getEnd();
+  throw (0, createError)(message, ast, start, end);
+}
+function checkModifiers(node) {
+  if (nodeHasIllegalDecorators(node)) {
+    throwError(node.illegalDecorators[0], 'Decorators are not valid here.');
+  }
+  for (const decorator of (0, getDecorators2)(
+    node,
+    /* includeIllegalDecorators */
+    true,
+  ) ?? []) {
+    if (!nodeCanBeDecorated(node)) {
+      if (ts.isMethodDeclaration(node) && !nodeIsPresent(node.body)) {
+        throwError(decorator, 'A decorator can only decorate a method implementation, not an overload.');
+      } else {
+        throwError(decorator, 'Decorators are not valid here.');
+      }
+    }
+  }
+  for (const modifier of (0, getModifiers2)(
+    node,
+    /* includeIllegalModifiers */
+    true,
+  ) ?? []) {
+    if (modifier.kind !== SyntaxKind4.ReadonlyKeyword) {
+      if (node.kind === SyntaxKind4.PropertySignature || node.kind === SyntaxKind4.MethodSignature) {
+        throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type member`);
+      }
+      if (
+        node.kind === SyntaxKind4.IndexSignature &&
+        (modifier.kind !== SyntaxKind4.StaticKeyword || !ts.isClassLike(node.parent))
+      ) {
+        throwError(
+          modifier,
+          `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on an index signature`,
+        );
+      }
+    }
+    if (
+      modifier.kind !== SyntaxKind4.InKeyword &&
+      modifier.kind !== SyntaxKind4.OutKeyword &&
+      modifier.kind !== SyntaxKind4.ConstKeyword &&
+      node.kind === SyntaxKind4.TypeParameter
+    ) {
+      throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type parameter`);
+    }
+    if (
+      (modifier.kind === SyntaxKind4.InKeyword || modifier.kind === SyntaxKind4.OutKeyword) &&
+      (node.kind !== SyntaxKind4.TypeParameter ||
+        !(
+          ts.isInterfaceDeclaration(node.parent) ||
+          ts.isClassLike(node.parent) ||
+          ts.isTypeAliasDeclaration(node.parent)
+        ))
+    ) {
+      throwError(
+        modifier,
+        `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a type parameter of a class, interface or type alias`,
+      );
+    }
+    if (
+      modifier.kind === SyntaxKind4.ReadonlyKeyword &&
+      node.kind !== SyntaxKind4.PropertyDeclaration &&
+      node.kind !== SyntaxKind4.PropertySignature &&
+      node.kind !== SyntaxKind4.IndexSignature &&
+      node.kind !== SyntaxKind4.Parameter
+    ) {
+      throwError(
+        modifier,
+        "'readonly' modifier can only appear on a property declaration or index signature.",
+      );
+    }
+    if (
+      modifier.kind === SyntaxKind4.DeclareKeyword &&
+      ts.isClassLike(node.parent) &&
+      !ts.isPropertyDeclaration(node)
+    ) {
+      throwError(
+        modifier,
+        `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on class elements of this kind.`,
+      );
+    }
+    if (modifier.kind === SyntaxKind4.DeclareKeyword && ts.isVariableStatement(node)) {
+      const declarationKind = (0, getDeclarationKind)(node.declarationList);
+      if (declarationKind === 'using' || declarationKind === 'await using') {
+        throwError(modifier, `'declare' modifier cannot appear on a '${declarationKind}' declaration.`);
+      }
+    }
+    if (
+      modifier.kind === SyntaxKind4.AbstractKeyword &&
+      node.kind !== SyntaxKind4.ClassDeclaration &&
+      node.kind !== SyntaxKind4.ConstructorType &&
+      node.kind !== SyntaxKind4.MethodDeclaration &&
+      node.kind !== SyntaxKind4.PropertyDeclaration &&
+      node.kind !== SyntaxKind4.GetAccessor &&
+      node.kind !== SyntaxKind4.SetAccessor
+    ) {
+      throwError(
+        modifier,
+        `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a class, method, or property declaration.`,
+      );
+    }
+    if (
+      (modifier.kind === SyntaxKind4.StaticKeyword ||
+        modifier.kind === SyntaxKind4.PublicKeyword ||
+        modifier.kind === SyntaxKind4.ProtectedKeyword ||
+        modifier.kind === SyntaxKind4.PrivateKeyword) &&
+      (node.parent.kind === SyntaxKind4.ModuleBlock || node.parent.kind === SyntaxKind4.SourceFile)
+    ) {
+      throwError(
+        modifier,
+        `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a module or namespace element.`,
+      );
+    }
+    if (modifier.kind === SyntaxKind4.AccessorKeyword && node.kind !== SyntaxKind4.PropertyDeclaration) {
+      throwError(modifier, "'accessor' modifier can only appear on a property declaration.");
+    }
+    if (
+      modifier.kind === SyntaxKind4.AsyncKeyword &&
+      node.kind !== SyntaxKind4.MethodDeclaration &&
+      node.kind !== SyntaxKind4.FunctionDeclaration &&
+      node.kind !== SyntaxKind4.FunctionExpression &&
+      node.kind !== SyntaxKind4.ArrowFunction
+    ) {
+      throwError(modifier, "'async' modifier cannot be used here.");
+    }
+    if (
+      node.kind === SyntaxKind4.Parameter &&
+      (modifier.kind === SyntaxKind4.StaticKeyword ||
+        modifier.kind === SyntaxKind4.ExportKeyword ||
+        modifier.kind === SyntaxKind4.DeclareKeyword ||
+        modifier.kind === SyntaxKind4.AsyncKeyword)
+    ) {
+      throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
+    }
+    if (
+      modifier.kind === SyntaxKind4.PublicKeyword ||
+      modifier.kind === SyntaxKind4.ProtectedKeyword ||
+      modifier.kind === SyntaxKind4.PrivateKeyword
+    ) {
+      for (const anotherModifier of (0, getModifiers2)(node) ?? []) {
+        if (
+          anotherModifier !== modifier &&
+          (anotherModifier.kind === SyntaxKind4.PublicKeyword ||
+            anotherModifier.kind === SyntaxKind4.ProtectedKeyword ||
+            anotherModifier.kind === SyntaxKind4.PrivateKeyword)
+        ) {
+          throwError(anotherModifier, `Accessibility modifier already seen.`);
+        }
+      }
+    }
+    if (
+      node.kind === SyntaxKind4.Parameter && // In `typescript` package, it's `ts.hasSyntacticModifier(node, ts.ModifierFlags.ParameterPropertyModifier)`
+      // https://github.com/typescript-eslint/typescript-eslint/pull/6615#discussion_r1136489935
+      (modifier.kind === SyntaxKind4.PublicKeyword ||
+        modifier.kind === SyntaxKind4.PrivateKeyword ||
+        modifier.kind === SyntaxKind4.ProtectedKeyword ||
+        modifier.kind === SyntaxKind4.ReadonlyKeyword ||
+        modifier.kind === SyntaxKind4.OverrideKeyword)
+    ) {
+      const func = getContainingFunction(node);
+      if (!(func?.kind === SyntaxKind4.Constructor && nodeIsPresent(func.body))) {
+        throwError(modifier, 'A parameter property is only allowed in a constructor implementation.');
+      }
+    }
+    if (
+      modifier.kind !== SyntaxKind4.AsyncKeyword &&
+      node.kind === SyntaxKind4.MethodDeclaration &&
+      node.parent.kind === SyntaxKind4.ObjectLiteralExpression
+    ) {
+      throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot be used here.`);
+    }
+  }
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/convert.js
+var SyntaxKind6 = ts.SyntaxKind;
+function convertError(error) {
+  return (0, createError)(
+    ('message' in error && error.message) || error.messageText,
+    error.file,
+    error.start,
+  );
+}
+function isPropertyAccessEntityNameExpression(node) {
+  return (
+    ts.isPropertyAccessExpression(node) &&
+    ts.isIdentifier(node.name) &&
+    isEntityNameExpression(node.expression)
+  );
+}
+function isEntityNameExpression(node) {
+  return node.kind === SyntaxKind6.Identifier || isPropertyAccessEntityNameExpression(node);
+}
+var Converter = class {
+  allowPattern = false;
+  ast;
+  esTreeNodeToTSNodeMap = /* @__PURE__ */ new WeakMap();
+  options;
+  tsNodeToESTreeNodeMap = /* @__PURE__ */ new WeakMap();
+  /**
+   * Converts a TypeScript node into an ESTree node
+   * @param ast the full TypeScript AST
+   * @param options additional options for the conversion
+   * @returns the converted ESTreeNode
+   */
+  constructor(ast, options) {
+    this.ast = ast;
+    this.options = {
+      ...options,
+    };
+  }
+  #checkForStatementDeclaration(initializer, kind) {
+    const loop = kind === ts.SyntaxKind.ForInStatement ? 'for...in' : 'for...of';
+    if (ts.isVariableDeclarationList(initializer)) {
+      if (initializer.declarations.length !== 1) {
+        this.#throwError(
+          initializer,
+          `Only a single variable declaration is allowed in a '${loop}' statement.`,
+        );
+      }
+      const declaration = initializer.declarations[0];
+      if (declaration.initializer) {
+        this.#throwError(
+          declaration,
+          `The variable declaration of a '${loop}' statement cannot have an initializer.`,
+        );
+      } else if (declaration.type) {
+        this.#throwError(
+          declaration,
+          `The variable declaration of a '${loop}' statement cannot have a type annotation.`,
+        );
+      }
+      if (kind === ts.SyntaxKind.ForInStatement && initializer.flags & ts.NodeFlags.Using) {
+        this.#throwError(
+          initializer,
+          "The left-hand side of a 'for...in' statement cannot be a 'using' declaration.",
+        );
+      }
+    } else if (
+      !(0, isValidAssignmentTarget)(initializer) &&
+      initializer.kind !== ts.SyntaxKind.ObjectLiteralExpression &&
+      initializer.kind !== ts.SyntaxKind.ArrayLiteralExpression
+    ) {
+      this.#throwError(
+        initializer,
+        `The left-hand side of a '${loop}' statement must be a variable or a property access.`,
+      );
+    }
+  }
+  #checkModifiers(node) {
+    if (this.options.allowInvalidAST) {
+      return;
+    }
+    (0, checkModifiers)(node);
+  }
+  #throwError(node, message) {
+    let start;
+    let end;
+    if (Array.isArray(node)) {
+      [start, end] = node;
+    } else if (typeof node === 'number') {
+      start = end = node;
+    } else {
+      start = node.getStart(this.ast);
+      end = node.getEnd();
+    }
+    throw (0, createError)(message, this.ast, start, end);
+  }
+  #throwUnlessAllowInvalidAST(node, message) {
+    if (!this.options.allowInvalidAST) {
+      this.#throwError(node, message);
+    }
+  }
+  /**
+   * Creates a getter for a property under aliasKey that returns the value under
+   * valueKey. If suppressDeprecatedPropertyWarnings is not enabled, the
+   * getter also console warns about the deprecation.
+   *
+   * @see https://github.com/typescript-eslint/typescript-eslint/issues/6469
+   */
+  #withDeprecatedAliasGetter(node, aliasKey, valueKey, suppressWarnings = false) {
+    let warned = suppressWarnings;
+    Object.defineProperty(node, aliasKey, {
+      configurable: true,
+      get: this.options.suppressDeprecatedPropertyWarnings
+        ? () => node[valueKey]
+        : () => {
+            if (!warned) {
+              (void 0)(
+                `The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://typescript-eslint.io/troubleshooting/faqs/general#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`,
+                'DeprecationWarning',
+              );
+              warned = true;
+            }
+            return node[valueKey];
+          },
+      set(value) {
+        Object.defineProperty(node, aliasKey, {
+          enumerable: true,
+          value,
+          writable: true,
+        });
+      },
+    });
+    return node;
+  }
+  #withDeprecatedGetter(node, deprecatedKey, preferredKey, value) {
+    let warned = false;
+    Object.defineProperty(node, deprecatedKey, {
+      configurable: true,
+      get: this.options.suppressDeprecatedPropertyWarnings
+        ? () => value
+        : () => {
+            if (!warned) {
+              let message = `The '${deprecatedKey}' property is deprecated on ${node.type} nodes.`;
+              if (preferredKey) {
+                message += ` Use ${preferredKey} instead.`;
+              }
+              message +=
+                ' See https://typescript-eslint.io/troubleshooting/faqs/general#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.';
+              (void 0)(message, 'DeprecationWarning');
+              warned = true;
+            }
+            return value;
+          },
+      set(value2) {
+        Object.defineProperty(node, deprecatedKey, {
+          enumerable: true,
+          value: value2,
+          writable: true,
+        });
+      },
+    });
+    return node;
+  }
+  assertModuleSpecifier(node, allowNull) {
+    if (!allowNull && node.moduleSpecifier == null) {
+      this.#throwUnlessAllowInvalidAST(node, 'Module specifier must be a string literal.');
+    }
+    if (node.moduleSpecifier && node.moduleSpecifier?.kind !== SyntaxKind6.StringLiteral) {
+      this.#throwUnlessAllowInvalidAST(node.moduleSpecifier, 'Module specifier must be a string literal.');
+    }
+  }
+  convertBindingNameWithTypeAnnotation(name, tsType, parent) {
+    const id = this.convertPattern(name);
+    if (tsType) {
+      id.typeAnnotation = this.convertTypeAnnotation(tsType, parent);
+      this.fixParentLocation(id, id.typeAnnotation.range);
+    }
+    return id;
+  }
+  /**
+   * Coverts body Nodes and add a directive field to StringLiterals
+   * @param nodes of ts.Node
+   * @param parent parentNode
+   * @returns Array of body statements
+   */
+  convertBodyExpressions(nodes, parent) {
+    let allowDirectives = (0, canContainDirective)(parent);
+    return nodes
+      .map((statement) => {
+        const child = this.convertChild(statement);
+        if (allowDirectives) {
+          if (
+            child?.expression &&
+            ts.isExpressionStatement(statement) &&
+            ts.isStringLiteral(statement.expression)
+          ) {
+            const raw = child.expression.raw;
+            child.directive = raw.slice(1, -1);
+            return child;
+          }
+          allowDirectives = false;
+        }
+        return child;
+      })
+      .filter((statement) => statement);
+  }
+  convertChainExpression(node, tsNode) {
+    const { child, isOptional: isOptional2 } = (() => {
+      if (node.type === AST_NODE_TYPES2.MemberExpression) {
+        return {
+          child: node.object,
+          isOptional: node.optional,
+        };
+      }
+      if (node.type === AST_NODE_TYPES2.CallExpression) {
+        return {
+          child: node.callee,
+          isOptional: node.optional,
+        };
+      }
+      return {
+        child: node.expression,
+        isOptional: false,
+      };
+    })();
+    const isChildUnwrappable = (0, isChildUnwrappableOptionalChain)(tsNode, child);
+    if (!isChildUnwrappable && !isOptional2) {
+      return node;
+    }
+    if (isChildUnwrappable && (0, isChainExpression)(child)) {
+      const newChild = child.expression;
+      if (node.type === AST_NODE_TYPES2.MemberExpression) {
+        node.object = newChild;
+      } else if (node.type === AST_NODE_TYPES2.CallExpression) {
+        node.callee = newChild;
+      } else {
+        node.expression = newChild;
+      }
+    }
+    return this.createNode(tsNode, {
+      type: AST_NODE_TYPES2.ChainExpression,
+      expression: node,
+    });
+  }
+  /**
+   * Converts a TypeScript node into an ESTree node.
+   * @param child the child ts.Node
+   * @param parent parentNode
+   * @returns the converted ESTree node
+   */
+  convertChild(child, parent) {
+    return this.converter(child, parent, false);
+  }
+  /**
+   * Converts TypeScript node array into an ESTree node list.
+   * @param children the child `ts.NodeArray` or `ts.Node[]`
+   * @param parent parentNode
+   * @returns the converted ESTree node list
+   */
+  convertChildren(children, parent) {
+    return children.map((child) => this.converter(child, parent, false));
+  }
+  /**
+   * Converts a TypeScript node into an ESTree node.
+   * @param child the child ts.Node
+   * @param parent parentNode
+   * @returns the converted ESTree node
+   */
+  convertPattern(child, parent) {
+    return this.converter(child, parent, true);
+  }
+  /**
+   * Converts a child into a type annotation. This creates an intermediary
+   * TypeAnnotation node to match what Flow does.
+   * @param child The TypeScript AST node to convert.
+   * @param parent parentNode
+   * @returns The type annotation node.
+   */
+  convertTypeAnnotation(child, parent) {
+    const offset =
+      parent?.kind === SyntaxKind6.FunctionType || parent?.kind === SyntaxKind6.ConstructorType ? 2 : 1;
+    const annotationStartCol = child.getFullStart() - offset;
+    const range = [annotationStartCol, child.end];
+    const loc = (0, getLocFor)(range, this.ast);
+    return {
+      type: AST_NODE_TYPES2.TSTypeAnnotation,
+      loc,
+      range,
+      typeAnnotation: this.convertChild(child),
+    };
+  }
+  /**
+   * Converts a ts.Node's typeArguments to TSTypeParameterInstantiation node
+   * @param typeArguments ts.NodeArray typeArguments
+   * @param node parent used to create this node
+   * @returns TypeParameterInstantiation node
+   */
+  convertTypeArgumentsToTypeParameterInstantiation(typeArguments, node) {
+    const greaterThanToken = (0, findNextToken)(typeArguments, this.ast, this.ast);
+    const range = [typeArguments.pos - 1, greaterThanToken.end];
+    if (typeArguments.length === 0) {
+      this.#throwError(range, 'Type argument list cannot be empty.');
+    }
+    return this.createNode(node, {
+      type: AST_NODE_TYPES2.TSTypeParameterInstantiation,
+      range,
+      params: this.convertChildren(typeArguments),
+    });
+  }
+  /**
+   * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node
+   * @param typeParameters ts.Node typeParameters
+   * @returns TypeParameterDeclaration node
+   */
+  convertTSTypeParametersToTypeParametersDeclaration(typeParameters) {
+    const greaterThanToken = (0, findNextToken)(typeParameters, this.ast, this.ast);
+    const range = [typeParameters.pos - 1, greaterThanToken.end];
+    if (typeParameters.length === 0) {
+      this.#throwError(range, 'Type parameter list cannot be empty.');
+    }
+    return {
+      type: AST_NODE_TYPES2.TSTypeParameterDeclaration,
+      loc: (0, getLocFor)(range, this.ast),
+      range,
+      params: this.convertChildren(typeParameters),
+    };
+  }
+  /**
+   * Converts an array of ts.Node parameters into an array of ESTreeNode params
+   * @param parameters An array of ts.Node params to be converted
+   * @returns an array of converted ESTreeNode params
+   */
+  convertParameters(parameters) {
+    if (!parameters?.length) {
+      return [];
+    }
+    return parameters.map((param) => {
+      const convertedParam = this.convertChild(param);
+      convertedParam.decorators = this.convertChildren((0, getDecorators2)(param) ?? []);
+      return convertedParam;
+    });
+  }
+  /**
+   * Converts a TypeScript node into an ESTree node.
+   * @param node the child ts.Node
+   * @param parent parentNode
+   * @param allowPattern flag to determine if patterns are allowed
+   * @returns the converted ESTree node
+   */
+  converter(node, parent, allowPattern) {
+    if (!node) {
+      return null;
+    }
+    this.#checkModifiers(node);
+    const pattern = this.allowPattern;
+    if (allowPattern != null) {
+      this.allowPattern = allowPattern;
+    }
+    const result = this.convertNode(node, parent ?? node.parent);
+    this.registerTSNodeInNodeMap(node, result);
+    this.allowPattern = pattern;
+    return result;
+  }
+  convertImportAttributes(node) {
+    const attributes = node.attributes ?? node.assertClause;
+    return this.convertChildren(attributes?.elements ?? []);
+  }
+  convertJSXIdentifier(node) {
+    const result = this.createNode(node, {
+      type: AST_NODE_TYPES2.JSXIdentifier,
+      name: node.getText(),
+    });
+    this.registerTSNodeInNodeMap(node, result);
+    return result;
+  }
+  convertJSXNamespaceOrIdentifier(node) {
+    if (node.kind === ts.SyntaxKind.JsxNamespacedName) {
+      const result = this.createNode(node, {
+        type: AST_NODE_TYPES2.JSXNamespacedName,
+        name: this.createNode(node.name, {
+          type: AST_NODE_TYPES2.JSXIdentifier,
+          name: node.name.text,
+        }),
+        namespace: this.createNode(node.namespace, {
+          type: AST_NODE_TYPES2.JSXIdentifier,
+          name: node.namespace.text,
+        }),
+      });
+      this.registerTSNodeInNodeMap(node, result);
+      return result;
+    }
+    const text = node.getText();
+    const colonIndex = text.indexOf(':');
+    if (colonIndex > 0) {
+      const range = (0, getRange)(node, this.ast);
+      const result = this.createNode(node, {
+        type: AST_NODE_TYPES2.JSXNamespacedName,
+        range,
+        name: this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXIdentifier,
+          range: [range[0] + colonIndex + 1, range[1]],
+          name: text.slice(colonIndex + 1),
+        }),
+        namespace: this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXIdentifier,
+          range: [range[0], range[0] + colonIndex],
+          name: text.slice(0, colonIndex),
+        }),
+      });
+      this.registerTSNodeInNodeMap(node, result);
+      return result;
+    }
+    return this.convertJSXIdentifier(node);
+  }
+  /**
+   * Converts a TypeScript JSX node.tagName into an ESTree node.name
+   * @param node the tagName object from a JSX ts.Node
+   * @returns the converted ESTree name object
+   */
+  convertJSXTagName(node, parent) {
+    let result;
+    switch (node.kind) {
+      case SyntaxKind6.PropertyAccessExpression:
+        if (node.name.kind === SyntaxKind6.PrivateIdentifier) {
+          this.#throwError(node.name, 'Non-private identifier expected.');
+        }
+        result = this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXMemberExpression,
+          object: this.convertJSXTagName(node.expression, parent),
+          property: this.convertJSXIdentifier(node.name),
+        });
+        break;
+      case SyntaxKind6.ThisKeyword:
+      case SyntaxKind6.Identifier:
+      default:
+        return this.convertJSXNamespaceOrIdentifier(node);
+    }
+    this.registerTSNodeInNodeMap(node, result);
+    return result;
+  }
+  convertMethodSignature(node) {
+    return this.createNode(node, {
+      type: AST_NODE_TYPES2.TSMethodSignature,
+      accessibility: (0, getTSNodeAccessibility)(node),
+      computed: (0, isComputedProperty)(node.name),
+      key: this.convertChild(node.name),
+      kind: (() => {
+        switch (node.kind) {
+          case SyntaxKind6.GetAccessor:
+            return 'get';
+          case SyntaxKind6.SetAccessor:
+            return 'set';
+          case SyntaxKind6.MethodSignature:
+            return 'method';
+        }
+      })(),
+      optional: (0, isOptional)(node),
+      params: this.convertParameters(node.parameters),
+      readonly: (0, hasModifier)(SyntaxKind6.ReadonlyKeyword, node),
+      returnType: node.type && this.convertTypeAnnotation(node.type, node),
+      static: (0, hasModifier)(SyntaxKind6.StaticKeyword, node),
+      typeParameters:
+        node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+    });
+  }
+  /**
+   * Uses the provided range location to adjust the location data of the given Node
+   * @param result The node that will have its location data mutated
+   * @param childRange The child node range used to expand location
+   */
+  fixParentLocation(result, childRange) {
+    if (childRange[0] < result.range[0]) {
+      result.range[0] = childRange[0];
+      result.loc.start = (0, getLineAndCharacterFor)(result.range[0], this.ast);
+    }
+    if (childRange[1] > result.range[1]) {
+      result.range[1] = childRange[1];
+      result.loc.end = (0, getLineAndCharacterFor)(result.range[1], this.ast);
+    }
+  }
+  /**
+   * Converts a TypeScript node into an ESTree node.
+   * The core of the conversion logic:
+   * Identify and convert each relevant TypeScript SyntaxKind
+   * @returns the converted ESTree node
+   */
+  convertNode(node, parent) {
+    switch (node.kind) {
+      case SyntaxKind6.SourceFile: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Program,
+          range: [node.getStart(this.ast), node.endOfFileToken.end],
+          body: this.convertBodyExpressions(node.statements, node),
+          comments: void 0,
+          sourceType: node.externalModuleIndicator ? 'module' : 'script',
+          tokens: void 0,
+        });
+      }
+      case SyntaxKind6.Block: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.BlockStatement,
+          body: this.convertBodyExpressions(node.statements, node),
+        });
+      }
+      case SyntaxKind6.Identifier: {
+        if ((0, isThisInTypeQuery)(node)) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.ThisExpression,
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Identifier,
+          decorators: [],
+          name: node.text,
+          optional: false,
+          typeAnnotation: void 0,
+        });
+      }
+      case SyntaxKind6.PrivateIdentifier: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.PrivateIdentifier,
+          // typescript includes the `#` in the text
+          name: node.text.slice(1),
+        });
+      }
+      case SyntaxKind6.WithStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.WithStatement,
+          body: this.convertChild(node.statement),
+          object: this.convertChild(node.expression),
+        });
+      // Control Flow
+      case SyntaxKind6.ReturnStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ReturnStatement,
+          argument: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.LabeledStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.LabeledStatement,
+          body: this.convertChild(node.statement),
+          label: this.convertChild(node.label),
+        });
+      case SyntaxKind6.ContinueStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ContinueStatement,
+          label: this.convertChild(node.label),
+        });
+      case SyntaxKind6.BreakStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.BreakStatement,
+          label: this.convertChild(node.label),
+        });
+      // Choice
+      case SyntaxKind6.IfStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.IfStatement,
+          alternate: this.convertChild(node.elseStatement),
+          consequent: this.convertChild(node.thenStatement),
+          test: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.SwitchStatement:
+        if (
+          node.caseBlock.clauses.filter((switchCase) => switchCase.kind === SyntaxKind6.DefaultClause)
+            .length > 1
+        ) {
+          this.#throwError(node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.SwitchStatement,
+          cases: this.convertChildren(node.caseBlock.clauses),
+          discriminant: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.CaseClause:
+      case SyntaxKind6.DefaultClause:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.SwitchCase,
+          // expression is present in case only
+          consequent: this.convertChildren(node.statements),
+          test: node.kind === SyntaxKind6.CaseClause ? this.convertChild(node.expression) : null,
+        });
+      // Exceptions
+      case SyntaxKind6.ThrowStatement:
+        if (node.expression.end === node.expression.pos) {
+          this.#throwUnlessAllowInvalidAST(node, 'A throw statement must throw an expression.');
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ThrowStatement,
+          argument: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.TryStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TryStatement,
+          block: this.convertChild(node.tryBlock),
+          finalizer: this.convertChild(node.finallyBlock),
+          handler: this.convertChild(node.catchClause),
+        });
+      case SyntaxKind6.CatchClause:
+        if (node.variableDeclaration?.initializer) {
+          this.#throwError(
+            node.variableDeclaration.initializer,
+            'Catch clause variable cannot have an initializer.',
+          );
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.CatchClause,
+          body: this.convertChild(node.block),
+          param: node.variableDeclaration
+            ? this.convertBindingNameWithTypeAnnotation(
+                node.variableDeclaration.name,
+                node.variableDeclaration.type,
+              )
+            : null,
+        });
+      // Loops
+      case SyntaxKind6.WhileStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.WhileStatement,
+          body: this.convertChild(node.statement),
+          test: this.convertChild(node.expression),
+        });
+      /**
+       * Unlike other parsers, TypeScript calls a "DoWhileStatement"
+       * a "DoStatement"
+       */
+      case SyntaxKind6.DoStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.DoWhileStatement,
+          body: this.convertChild(node.statement),
+          test: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.ForStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ForStatement,
+          body: this.convertChild(node.statement),
+          init: this.convertChild(node.initializer),
+          test: this.convertChild(node.condition),
+          update: this.convertChild(node.incrementor),
+        });
+      case SyntaxKind6.ForInStatement:
+        this.#checkForStatementDeclaration(node.initializer, node.kind);
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ForInStatement,
+          body: this.convertChild(node.statement),
+          left: this.convertPattern(node.initializer),
+          right: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.ForOfStatement: {
+        this.#checkForStatementDeclaration(node.initializer, node.kind);
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ForOfStatement,
+          await: Boolean(node.awaitModifier && node.awaitModifier.kind === SyntaxKind6.AwaitKeyword),
+          body: this.convertChild(node.statement),
+          left: this.convertPattern(node.initializer),
+          right: this.convertChild(node.expression),
+        });
+      }
+      // Declarations
+      case SyntaxKind6.FunctionDeclaration: {
+        const isDeclare = (0, hasModifier)(SyntaxKind6.DeclareKeyword, node);
+        const isAsync = (0, hasModifier)(SyntaxKind6.AsyncKeyword, node);
+        const isGenerator = !!node.asteriskToken;
+        if (isDeclare) {
+          if (node.body) {
+            this.#throwError(node, 'An implementation cannot be declared in ambient contexts.');
+          } else if (isAsync) {
+            this.#throwError(node, "'async' modifier cannot be used in an ambient context.");
+          } else if (isGenerator) {
+            this.#throwError(node, 'Generators are not allowed in an ambient context.');
+          }
+        } else if (!node.body && isGenerator) {
+          this.#throwError(node, 'A function signature cannot be declared as a generator.');
+        }
+        const result = this.createNode(node, {
+          // declare implies no body due to the invariant above
+          type: !node.body ? AST_NODE_TYPES2.TSDeclareFunction : AST_NODE_TYPES2.FunctionDeclaration,
+          async: isAsync,
+          body: this.convertChild(node.body) || void 0,
+          declare: isDeclare,
+          expression: false,
+          generator: isGenerator,
+          id: this.convertChild(node.name),
+          params: this.convertParameters(node.parameters),
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+        return this.fixExports(node, result);
+      }
+      case SyntaxKind6.VariableDeclaration: {
+        const definite = !!node.exclamationToken;
+        const init = this.convertChild(node.initializer);
+        const id = this.convertBindingNameWithTypeAnnotation(node.name, node.type, node);
+        if (definite) {
+          if (init) {
+            this.#throwError(
+              node,
+              'Declarations with initializers cannot also have definite assignment assertions.',
+            );
+          } else if (id.type !== AST_NODE_TYPES2.Identifier || !id.typeAnnotation) {
+            this.#throwError(
+              node,
+              'Declarations with definite assignment assertions must also have type annotations.',
+            );
+          }
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.VariableDeclarator,
+          definite,
+          id,
+          init,
+        });
+      }
+      case SyntaxKind6.VariableStatement: {
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.VariableDeclaration,
+          declarations: this.convertChildren(node.declarationList.declarations),
+          declare: (0, hasModifier)(SyntaxKind6.DeclareKeyword, node),
+          kind: (0, getDeclarationKind)(node.declarationList),
+        });
+        if (!result.declarations.length) {
+          this.#throwUnlessAllowInvalidAST(
+            node,
+            'A variable declaration list must have at least one variable declarator.',
+          );
+        }
+        if (result.kind === 'using' || result.kind === 'await using') {
+          node.declarationList.declarations.forEach((declaration, i) => {
+            if (result.declarations[i].init == null) {
+              this.#throwError(declaration, `'${result.kind}' declarations must be initialized.`);
+            }
+            if (result.declarations[i].id.type !== AST_NODE_TYPES2.Identifier) {
+              this.#throwError(
+                declaration.name,
+                `'${result.kind}' declarations may not have binding patterns.`,
+              );
+            }
+          });
+        }
+        if (result.declare || ['await using', 'const', 'using'].includes(result.kind)) {
+          node.declarationList.declarations.forEach((declaration, i) => {
+            if (result.declarations[i].definite) {
+              this.#throwError(
+                declaration,
+                `A definite assignment assertion '!' is not permitted in this context.`,
+              );
+            }
+          });
+        }
+        if (result.declare) {
+          node.declarationList.declarations.forEach((declaration, i) => {
+            if (
+              result.declarations[i].init &&
+              (['let', 'var'].includes(result.kind) || result.declarations[i].id.typeAnnotation)
+            ) {
+              this.#throwError(declaration, `Initializers are not permitted in ambient contexts.`);
+            }
+          });
+        }
+        return this.fixExports(node, result);
+      }
+      // mostly for for-of, for-in
+      case SyntaxKind6.VariableDeclarationList: {
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.VariableDeclaration,
+          declarations: this.convertChildren(node.declarations),
+          declare: false,
+          kind: (0, getDeclarationKind)(node),
+        });
+        if (result.kind === 'using' || result.kind === 'await using') {
+          node.declarations.forEach((declaration, i) => {
+            if (result.declarations[i].init != null) {
+              this.#throwError(
+                declaration,
+                `'${result.kind}' declarations may not be initialized in for statement.`,
+              );
+            }
+            if (result.declarations[i].id.type !== AST_NODE_TYPES2.Identifier) {
+              this.#throwError(
+                declaration.name,
+                `'${result.kind}' declarations may not have binding patterns.`,
+              );
+            }
+          });
+        }
+        return result;
+      }
+      // Expressions
+      case SyntaxKind6.ExpressionStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ExpressionStatement,
+          directive: void 0,
+          expression: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.ThisKeyword:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ThisExpression,
+        });
+      case SyntaxKind6.ArrayLiteralExpression: {
+        if (this.allowPattern) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.ArrayPattern,
+            decorators: [],
+            elements: node.elements.map((el) => this.convertPattern(el)),
+            optional: false,
+            typeAnnotation: void 0,
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ArrayExpression,
+          elements: this.convertChildren(node.elements),
+        });
+      }
+      case SyntaxKind6.ObjectLiteralExpression: {
+        if (this.allowPattern) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.ObjectPattern,
+            decorators: [],
+            optional: false,
+            properties: node.properties.map((el) => this.convertPattern(el)),
+            typeAnnotation: void 0,
+          });
+        }
+        const properties = [];
+        for (const property of node.properties) {
+          if (
+            (property.kind === SyntaxKind6.GetAccessor ||
+              property.kind === SyntaxKind6.SetAccessor ||
+              property.kind === SyntaxKind6.MethodDeclaration) &&
+            !property.body
+          ) {
+            this.#throwUnlessAllowInvalidAST(property.end - 1, "'{' expected.");
+          }
+          properties.push(this.convertChild(property));
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ObjectExpression,
+          properties,
+        });
+      }
+      case SyntaxKind6.PropertyAssignment: {
+        const { exclamationToken, questionToken } = node;
+        if (questionToken) {
+          this.#throwError(questionToken, 'A property assignment cannot have a question token.');
+        }
+        if (exclamationToken) {
+          this.#throwError(exclamationToken, 'A property assignment cannot have an exclamation token.');
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Property,
+          computed: (0, isComputedProperty)(node.name),
+          key: this.convertChild(node.name),
+          kind: 'init',
+          method: false,
+          optional: false,
+          shorthand: false,
+          value: this.converter(node.initializer, node, this.allowPattern),
+        });
+      }
+      case SyntaxKind6.ShorthandPropertyAssignment: {
+        const { exclamationToken, modifiers, questionToken } = node;
+        if (modifiers) {
+          this.#throwError(modifiers[0], 'A shorthand property assignment cannot have modifiers.');
+        }
+        if (questionToken) {
+          this.#throwError(questionToken, 'A shorthand property assignment cannot have a question token.');
+        }
+        if (exclamationToken) {
+          this.#throwError(
+            exclamationToken,
+            'A shorthand property assignment cannot have an exclamation token.',
+          );
+        }
+        if (node.objectAssignmentInitializer) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.Property,
+            computed: false,
+            key: this.convertChild(node.name),
+            kind: 'init',
+            method: false,
+            optional: false,
+            shorthand: true,
+            value: this.createNode(node, {
+              type: AST_NODE_TYPES2.AssignmentPattern,
+              decorators: [],
+              left: this.convertPattern(node.name),
+              optional: false,
+              right: this.convertChild(node.objectAssignmentInitializer),
+              typeAnnotation: void 0,
+            }),
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Property,
+          computed: false,
+          key: this.convertChild(node.name),
+          kind: 'init',
+          method: false,
+          optional: false,
+          shorthand: true,
+          value: this.convertChild(node.name),
+        });
+      }
+      case SyntaxKind6.ComputedPropertyName:
+        return this.convertChild(node.expression);
+      case SyntaxKind6.PropertyDeclaration: {
+        const isAbstract = (0, hasModifier)(SyntaxKind6.AbstractKeyword, node);
+        if (isAbstract && node.initializer) {
+          this.#throwError(node.initializer, `Abstract property cannot have an initializer.`);
+        }
+        if (node.name.kind === SyntaxKind6.StringLiteral && node.name.text === 'constructor') {
+          this.#throwError(node.name, "Classes may not have a field named 'constructor'.");
+        }
+        const isAccessor = (0, hasModifier)(SyntaxKind6.AccessorKeyword, node);
+        const type = (() => {
+          if (isAccessor) {
+            if (isAbstract) {
+              return AST_NODE_TYPES2.TSAbstractAccessorProperty;
+            }
+            return AST_NODE_TYPES2.AccessorProperty;
+          }
+          if (isAbstract) {
+            return AST_NODE_TYPES2.TSAbstractPropertyDefinition;
+          }
+          return AST_NODE_TYPES2.PropertyDefinition;
+        })();
+        const key = this.convertChild(node.name);
+        return this.createNode(node, {
+          type,
+          accessibility: (0, getTSNodeAccessibility)(node),
+          computed: (0, isComputedProperty)(node.name),
+          declare: (0, hasModifier)(SyntaxKind6.DeclareKeyword, node),
+          decorators: this.convertChildren((0, getDecorators2)(node) ?? []),
+          definite: !!node.exclamationToken,
+          key,
+          optional:
+            (key.type === AST_NODE_TYPES2.Literal ||
+              node.name.kind === SyntaxKind6.Identifier ||
+              node.name.kind === SyntaxKind6.ComputedPropertyName ||
+              node.name.kind === SyntaxKind6.PrivateIdentifier) &&
+            !!node.questionToken,
+          override: (0, hasModifier)(SyntaxKind6.OverrideKeyword, node),
+          readonly: (0, hasModifier)(SyntaxKind6.ReadonlyKeyword, node),
+          static: (0, hasModifier)(SyntaxKind6.StaticKeyword, node),
+          typeAnnotation: node.type && this.convertTypeAnnotation(node.type, node),
+          value: isAbstract ? null : this.convertChild(node.initializer),
+        });
+      }
+      case SyntaxKind6.GetAccessor:
+      case SyntaxKind6.SetAccessor: {
+        if (
+          node.parent.kind === SyntaxKind6.InterfaceDeclaration ||
+          node.parent.kind === SyntaxKind6.TypeLiteral
+        ) {
+          return this.convertMethodSignature(node);
+        }
+      }
+      // otherwise, it is a non-type accessor - intentional fallthrough
+      case SyntaxKind6.MethodDeclaration: {
+        const isAbstract = (0, hasModifier)(SyntaxKind6.AbstractKeyword, node);
+        if (isAbstract && node.body) {
+          this.#throwError(
+            node.name,
+            node.kind === SyntaxKind6.GetAccessor || node.kind === SyntaxKind6.SetAccessor
+              ? 'An abstract accessor cannot have an implementation.'
+              : `Method '${(0, declarationNameToString)(node.name, this.ast)}' cannot have an implementation because it is marked abstract.`,
+          );
+        }
+        const method = this.createNode(node, {
+          type: !node.body
+            ? AST_NODE_TYPES2.TSEmptyBodyFunctionExpression
+            : AST_NODE_TYPES2.FunctionExpression,
+          range: [node.parameters.pos - 1, node.end],
+          async: (0, hasModifier)(SyntaxKind6.AsyncKeyword, node),
+          body: this.convertChild(node.body),
+          declare: false,
+          expression: false,
+          // ESTreeNode as ESTreeNode here
+          generator: !!node.asteriskToken,
+          id: null,
+          params: [],
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+        if (method.typeParameters) {
+          this.fixParentLocation(method, method.typeParameters.range);
+        }
+        let result;
+        if (parent.kind === SyntaxKind6.ObjectLiteralExpression) {
+          method.params = this.convertChildren(node.parameters);
+          result = this.createNode(node, {
+            type: AST_NODE_TYPES2.Property,
+            computed: (0, isComputedProperty)(node.name),
+            key: this.convertChild(node.name),
+            kind: 'init',
+            method: node.kind === SyntaxKind6.MethodDeclaration,
+            optional: !!node.questionToken,
+            shorthand: false,
+            value: method,
+          });
+        } else {
+          method.params = this.convertParameters(node.parameters);
+          const methodDefinitionType = isAbstract
+            ? AST_NODE_TYPES2.TSAbstractMethodDefinition
+            : AST_NODE_TYPES2.MethodDefinition;
+          result = this.createNode(node, {
+            type: methodDefinitionType,
+            accessibility: (0, getTSNodeAccessibility)(node),
+            computed: (0, isComputedProperty)(node.name),
+            decorators: this.convertChildren((0, getDecorators2)(node) ?? []),
+            key: this.convertChild(node.name),
+            kind: 'method',
+            optional: !!node.questionToken,
+            override: (0, hasModifier)(SyntaxKind6.OverrideKeyword, node),
+            static: (0, hasModifier)(SyntaxKind6.StaticKeyword, node),
+            value: method,
+          });
+        }
+        if (node.kind === SyntaxKind6.GetAccessor) {
+          result.kind = 'get';
+        } else if (node.kind === SyntaxKind6.SetAccessor) {
+          result.kind = 'set';
+        } else if (
+          !result.static &&
+          node.name.kind === SyntaxKind6.StringLiteral &&
+          node.name.text === 'constructor' &&
+          result.type !== AST_NODE_TYPES2.Property
+        ) {
+          result.kind = 'constructor';
+        }
+        return result;
+      }
+      // TypeScript uses this even for static methods named "constructor"
+      case SyntaxKind6.Constructor: {
+        const lastModifier = (0, getLastModifier)(node);
+        const constructorToken =
+          (lastModifier && (0, findNextToken)(lastModifier, node, this.ast)) ?? node.getFirstToken();
+        const constructor = this.createNode(node, {
+          type: !node.body
+            ? AST_NODE_TYPES2.TSEmptyBodyFunctionExpression
+            : AST_NODE_TYPES2.FunctionExpression,
+          range: [node.parameters.pos - 1, node.end],
+          async: false,
+          body: this.convertChild(node.body),
+          declare: false,
+          expression: false,
+          // is not present in ESTreeNode
+          generator: false,
+          id: null,
+          params: this.convertParameters(node.parameters),
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+        if (constructor.typeParameters) {
+          this.fixParentLocation(constructor, constructor.typeParameters.range);
+        }
+        const constructorKey =
+          constructorToken.kind === SyntaxKind6.StringLiteral
+            ? this.createNode(constructorToken, {
+                type: AST_NODE_TYPES2.Literal,
+                raw: constructorToken.getText(),
+                value: 'constructor',
+              })
+            : this.createNode(node, {
+                type: AST_NODE_TYPES2.Identifier,
+                range: [constructorToken.getStart(this.ast), constructorToken.end],
+                decorators: [],
+                name: 'constructor',
+                optional: false,
+                typeAnnotation: void 0,
+              });
+        const isStatic = (0, hasModifier)(SyntaxKind6.StaticKeyword, node);
+        return this.createNode(node, {
+          type: (0, hasModifier)(SyntaxKind6.AbstractKeyword, node)
+            ? AST_NODE_TYPES2.TSAbstractMethodDefinition
+            : AST_NODE_TYPES2.MethodDefinition,
+          accessibility: (0, getTSNodeAccessibility)(node),
+          computed: false,
+          decorators: [],
+          key: constructorKey,
+          kind: isStatic ? 'method' : 'constructor',
+          optional: false,
+          override: false,
+          static: isStatic,
+          value: constructor,
+        });
+      }
+      case SyntaxKind6.FunctionExpression: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.FunctionExpression,
+          async: (0, hasModifier)(SyntaxKind6.AsyncKeyword, node),
+          body: this.convertChild(node.body),
+          declare: false,
+          expression: false,
+          generator: !!node.asteriskToken,
+          id: this.convertChild(node.name),
+          params: this.convertParameters(node.parameters),
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+      }
+      case SyntaxKind6.SuperKeyword:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Super,
+        });
+      case SyntaxKind6.ArrayBindingPattern:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ArrayPattern,
+          decorators: [],
+          elements: node.elements.map((el) => this.convertPattern(el)),
+          optional: false,
+          typeAnnotation: void 0,
+        });
+      // occurs with missing array elements like [,]
+      case SyntaxKind6.OmittedExpression:
+        return null;
+      case SyntaxKind6.ObjectBindingPattern:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ObjectPattern,
+          decorators: [],
+          optional: false,
+          properties: node.elements.map((el) => this.convertPattern(el)),
+          typeAnnotation: void 0,
+        });
+      case SyntaxKind6.BindingElement: {
+        if (parent.kind === SyntaxKind6.ArrayBindingPattern) {
+          const arrayItem = this.convertChild(node.name, parent);
+          if (node.initializer) {
+            return this.createNode(node, {
+              type: AST_NODE_TYPES2.AssignmentPattern,
+              decorators: [],
+              left: arrayItem,
+              optional: false,
+              right: this.convertChild(node.initializer),
+              typeAnnotation: void 0,
+            });
+          }
+          if (node.dotDotDotToken) {
+            return this.createNode(node, {
+              type: AST_NODE_TYPES2.RestElement,
+              argument: arrayItem,
+              decorators: [],
+              optional: false,
+              typeAnnotation: void 0,
+              value: void 0,
+            });
+          }
+          return arrayItem;
+        }
+        let result;
+        if (node.dotDotDotToken) {
+          result = this.createNode(node, {
+            type: AST_NODE_TYPES2.RestElement,
+            argument: this.convertChild(node.propertyName ?? node.name),
+            decorators: [],
+            optional: false,
+            typeAnnotation: void 0,
+            value: void 0,
+          });
+        } else {
+          result = this.createNode(node, {
+            type: AST_NODE_TYPES2.Property,
+            computed: Boolean(
+              node.propertyName && node.propertyName.kind === SyntaxKind6.ComputedPropertyName,
+            ),
+            key: this.convertChild(node.propertyName ?? node.name),
+            kind: 'init',
+            method: false,
+            optional: false,
+            shorthand: !node.propertyName,
+            value: this.convertChild(node.name),
+          });
+        }
+        if (node.initializer) {
+          result.value = this.createNode(node, {
+            type: AST_NODE_TYPES2.AssignmentPattern,
+            range: [node.name.getStart(this.ast), node.initializer.end],
+            decorators: [],
+            left: this.convertChild(node.name),
+            optional: false,
+            right: this.convertChild(node.initializer),
+            typeAnnotation: void 0,
+          });
+        }
+        return result;
+      }
+      case SyntaxKind6.ArrowFunction: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ArrowFunctionExpression,
+          async: (0, hasModifier)(SyntaxKind6.AsyncKeyword, node),
+          body: this.convertChild(node.body),
+          expression: node.body.kind !== SyntaxKind6.Block,
+          generator: false,
+          id: null,
+          params: this.convertParameters(node.parameters),
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+      }
+      case SyntaxKind6.YieldExpression:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.YieldExpression,
+          argument: this.convertChild(node.expression),
+          delegate: !!node.asteriskToken,
+        });
+      case SyntaxKind6.AwaitExpression:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.AwaitExpression,
+          argument: this.convertChild(node.expression),
+        });
+      // Template Literals
+      case SyntaxKind6.NoSubstitutionTemplateLiteral:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TemplateLiteral,
+          expressions: [],
+          quasis: [
+            this.createNode(node, {
+              type: AST_NODE_TYPES2.TemplateElement,
+              tail: true,
+              value: {
+                cooked: node.text,
+                raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - 1),
+              },
+            }),
+          ],
+        });
+      case SyntaxKind6.TemplateExpression: {
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TemplateLiteral,
+          expressions: [],
+          quasis: [this.convertChild(node.head)],
+        });
+        node.templateSpans.forEach((templateSpan) => {
+          result.expressions.push(this.convertChild(templateSpan.expression));
+          result.quasis.push(this.convertChild(templateSpan.literal));
+        });
+        return result;
+      }
+      case SyntaxKind6.TaggedTemplateExpression: {
+        if (node.tag.flags & ts.NodeFlags.OptionalChain) {
+          this.#throwError(node, 'Tagged template expressions are not permitted in an optional chain.');
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TaggedTemplateExpression,
+          quasi: this.convertChild(node.template),
+          tag: this.convertChild(node.tag),
+          typeArguments:
+            node.typeArguments &&
+            this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+        });
+      }
+      case SyntaxKind6.TemplateHead:
+      case SyntaxKind6.TemplateMiddle:
+      case SyntaxKind6.TemplateTail: {
+        const tail = node.kind === SyntaxKind6.TemplateTail;
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TemplateElement,
+          tail,
+          value: {
+            cooked: node.text,
+            raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - (tail ? 1 : 2)),
+          },
+        });
+      }
+      // Patterns
+      case SyntaxKind6.SpreadAssignment:
+      case SyntaxKind6.SpreadElement: {
+        if (this.allowPattern) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.RestElement,
+            argument: this.convertPattern(node.expression),
+            decorators: [],
+            optional: false,
+            typeAnnotation: void 0,
+            value: void 0,
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.SpreadElement,
+          argument: this.convertChild(node.expression),
+        });
+      }
+      case SyntaxKind6.Parameter: {
+        let parameter;
+        let result;
+        if (node.dotDotDotToken) {
+          parameter = result = this.createNode(node, {
+            type: AST_NODE_TYPES2.RestElement,
+            argument: this.convertChild(node.name),
+            decorators: [],
+            optional: false,
+            typeAnnotation: void 0,
+            value: void 0,
+          });
+        } else if (node.initializer) {
+          parameter = this.convertChild(node.name);
+          result = this.createNode(node, {
+            type: AST_NODE_TYPES2.AssignmentPattern,
+            range: [node.name.getStart(this.ast), node.initializer.end],
+            decorators: [],
+            left: parameter,
+            optional: false,
+            right: this.convertChild(node.initializer),
+            typeAnnotation: void 0,
+          });
+          const modifiers2 = (0, getModifiers2)(node);
+          if (modifiers2) {
+            result.range[0] = parameter.range[0];
+            result.loc = (0, getLocFor)(result.range, this.ast);
+          }
+        } else {
+          parameter = result = this.convertChild(node.name, parent);
+        }
+        if (node.type) {
+          parameter.typeAnnotation = this.convertTypeAnnotation(node.type, node);
+          this.fixParentLocation(parameter, parameter.typeAnnotation.range);
+        }
+        if (node.questionToken) {
+          if (node.questionToken.end > parameter.range[1]) {
+            parameter.range[1] = node.questionToken.end;
+            parameter.loc.end = (0, getLineAndCharacterFor)(parameter.range[1], this.ast);
+          }
+          parameter.optional = true;
+        }
+        const modifiers = (0, getModifiers2)(node);
+        if (modifiers) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.TSParameterProperty,
+            accessibility: (0, getTSNodeAccessibility)(node),
+            decorators: [],
+            override: (0, hasModifier)(SyntaxKind6.OverrideKeyword, node),
+            parameter: result,
+            readonly: (0, hasModifier)(SyntaxKind6.ReadonlyKeyword, node),
+            static: (0, hasModifier)(SyntaxKind6.StaticKeyword, node),
+          });
+        }
+        return result;
+      }
+      // Classes
+      case SyntaxKind6.ClassDeclaration:
+        if (
+          !node.name &&
+          (!(0, hasModifier)(ts.SyntaxKind.ExportKeyword, node) ||
+            !(0, hasModifier)(ts.SyntaxKind.DefaultKeyword, node))
+        ) {
+          this.#throwUnlessAllowInvalidAST(
+            node,
+            "A class declaration without the 'default' modifier must have a name.",
+          );
+        }
+      /* intentional fallthrough */
+      case SyntaxKind6.ClassExpression: {
+        const heritageClauses = node.heritageClauses ?? [];
+        const classNodeType =
+          node.kind === SyntaxKind6.ClassDeclaration
+            ? AST_NODE_TYPES2.ClassDeclaration
+            : AST_NODE_TYPES2.ClassExpression;
+        let extendsClause;
+        let implementsClause;
+        for (const heritageClause of heritageClauses) {
+          const { token, types } = heritageClause;
+          if (types.length === 0) {
+            this.#throwUnlessAllowInvalidAST(
+              heritageClause,
+              `'${ts.tokenToString(token)}' list cannot be empty.`,
+            );
+          }
+          if (token === SyntaxKind6.ExtendsKeyword) {
+            if (extendsClause) {
+              this.#throwUnlessAllowInvalidAST(heritageClause, "'extends' clause already seen.");
+            }
+            if (implementsClause) {
+              this.#throwUnlessAllowInvalidAST(
+                heritageClause,
+                "'extends' clause must precede 'implements' clause.",
+              );
+            }
+            if (types.length > 1) {
+              this.#throwUnlessAllowInvalidAST(types[1], 'Classes can only extend a single class.');
+            }
+            extendsClause ?? (extendsClause = heritageClause);
+          } else if (token === SyntaxKind6.ImplementsKeyword) {
+            if (implementsClause) {
+              this.#throwUnlessAllowInvalidAST(heritageClause, "'implements' clause already seen.");
+            }
+            implementsClause ?? (implementsClause = heritageClause);
+          }
+        }
+        const result = this.createNode(node, {
+          type: classNodeType,
+          abstract: (0, hasModifier)(SyntaxKind6.AbstractKeyword, node),
+          body: this.createNode(node, {
+            type: AST_NODE_TYPES2.ClassBody,
+            range: [node.members.pos - 1, node.end],
+            body: this.convertChildren(node.members.filter(isESTreeClassMember)),
+          }),
+          declare: (0, hasModifier)(SyntaxKind6.DeclareKeyword, node),
+          decorators: this.convertChildren((0, getDecorators2)(node) ?? []),
+          id: this.convertChild(node.name),
+          implements: this.convertChildren(implementsClause?.types ?? []),
+          superClass: extendsClause?.types[0] ? this.convertChild(extendsClause.types[0].expression) : null,
+          superTypeArguments: void 0,
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+        if (extendsClause?.types[0]?.typeArguments) {
+          result.superTypeArguments = this.convertTypeArgumentsToTypeParameterInstantiation(
+            extendsClause.types[0].typeArguments,
+            extendsClause.types[0],
+          );
+        }
+        return this.fixExports(node, result);
+      }
+      // Modules
+      case SyntaxKind6.ModuleBlock:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSModuleBlock,
+          body: this.convertBodyExpressions(node.statements, node),
+        });
+      case SyntaxKind6.ImportDeclaration: {
+        this.assertModuleSpecifier(node, false);
+        const result = this.createNode(
+          node,
+          this.#withDeprecatedAliasGetter(
+            {
+              type: AST_NODE_TYPES2.ImportDeclaration,
+              attributes: this.convertImportAttributes(node),
+              importKind: 'value',
+              source: this.convertChild(node.moduleSpecifier),
+              specifiers: [],
+            },
+            'assertions',
+            'attributes',
+            true,
+          ),
+        );
+        if (node.importClause) {
+          if (node.importClause.isTypeOnly) {
+            result.importKind = 'type';
+          }
+          if (node.importClause.name) {
+            result.specifiers.push(this.convertChild(node.importClause));
+          }
+          if (node.importClause.namedBindings) {
+            switch (node.importClause.namedBindings.kind) {
+              case SyntaxKind6.NamespaceImport:
+                result.specifiers.push(this.convertChild(node.importClause.namedBindings));
+                break;
+              case SyntaxKind6.NamedImports:
+                result.specifiers.push(...this.convertChildren(node.importClause.namedBindings.elements));
+                break;
+            }
+          }
+        }
+        return result;
+      }
+      case SyntaxKind6.NamespaceImport:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ImportNamespaceSpecifier,
+          local: this.convertChild(node.name),
+        });
+      case SyntaxKind6.ImportSpecifier:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ImportSpecifier,
+          imported: this.convertChild(node.propertyName ?? node.name),
+          importKind: node.isTypeOnly ? 'type' : 'value',
+          local: this.convertChild(node.name),
+        });
+      case SyntaxKind6.ImportClause: {
+        const local = this.convertChild(node.name);
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ImportDefaultSpecifier,
+          range: local.range,
+          local,
+        });
+      }
+      case SyntaxKind6.ExportDeclaration: {
+        if (node.exportClause?.kind === SyntaxKind6.NamedExports) {
+          this.assertModuleSpecifier(node, true);
+          return this.createNode(
+            node,
+            this.#withDeprecatedAliasGetter(
+              {
+                type: AST_NODE_TYPES2.ExportNamedDeclaration,
+                attributes: this.convertImportAttributes(node),
+                declaration: null,
+                exportKind: node.isTypeOnly ? 'type' : 'value',
+                source: this.convertChild(node.moduleSpecifier),
+                specifiers: this.convertChildren(node.exportClause.elements, node),
+              },
+              'assertions',
+              'attributes',
+              true,
+            ),
+          );
+        }
+        this.assertModuleSpecifier(node, false);
+        return this.createNode(
+          node,
+          this.#withDeprecatedAliasGetter(
+            {
+              type: AST_NODE_TYPES2.ExportAllDeclaration,
+              attributes: this.convertImportAttributes(node),
+              exported:
+                node.exportClause?.kind === SyntaxKind6.NamespaceExport
+                  ? this.convertChild(node.exportClause.name)
+                  : null,
+              exportKind: node.isTypeOnly ? 'type' : 'value',
+              source: this.convertChild(node.moduleSpecifier),
+            },
+            'assertions',
+            'attributes',
+            true,
+          ),
+        );
+      }
+      case SyntaxKind6.ExportSpecifier: {
+        const local = node.propertyName ?? node.name;
+        if (
+          local.kind === SyntaxKind6.StringLiteral &&
+          parent.kind === SyntaxKind6.ExportDeclaration &&
+          parent.moduleSpecifier?.kind !== SyntaxKind6.StringLiteral
+        ) {
+          this.#throwError(
+            local,
+            'A string literal cannot be used as a local exported binding without `from`.',
+          );
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ExportSpecifier,
+          exported: this.convertChild(node.name),
+          exportKind: node.isTypeOnly ? 'type' : 'value',
+          local: this.convertChild(local),
+        });
+      }
+      case SyntaxKind6.ExportAssignment:
+        if (node.isExportEquals) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.TSExportAssignment,
+            expression: this.convertChild(node.expression),
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ExportDefaultDeclaration,
+          declaration: this.convertChild(node.expression),
+          exportKind: 'value',
+        });
+      // Unary Operations
+      case SyntaxKind6.PrefixUnaryExpression:
+      case SyntaxKind6.PostfixUnaryExpression: {
+        const operator = (0, getTextForTokenKind)(node.operator);
+        if (operator === '++' || operator === '--') {
+          if (!(0, isValidAssignmentTarget)(node.operand)) {
+            this.#throwUnlessAllowInvalidAST(
+              node.operand,
+              'Invalid left-hand side expression in unary operation',
+            );
+          }
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.UpdateExpression,
+            argument: this.convertChild(node.operand),
+            operator,
+            prefix: node.kind === SyntaxKind6.PrefixUnaryExpression,
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.UnaryExpression,
+          argument: this.convertChild(node.operand),
+          operator,
+          prefix: node.kind === SyntaxKind6.PrefixUnaryExpression,
+        });
+      }
+      case SyntaxKind6.DeleteExpression:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.UnaryExpression,
+          argument: this.convertChild(node.expression),
+          operator: 'delete',
+          prefix: true,
+        });
+      case SyntaxKind6.VoidExpression:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.UnaryExpression,
+          argument: this.convertChild(node.expression),
+          operator: 'void',
+          prefix: true,
+        });
+      case SyntaxKind6.TypeOfExpression:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.UnaryExpression,
+          argument: this.convertChild(node.expression),
+          operator: 'typeof',
+          prefix: true,
+        });
+      case SyntaxKind6.TypeOperator:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeOperator,
+          operator: (0, getTextForTokenKind)(node.operator),
+          typeAnnotation: this.convertChild(node.type),
+        });
+      // Binary Operations
+      case SyntaxKind6.BinaryExpression: {
+        if (
+          node.operatorToken.kind !== SyntaxKind6.InKeyword &&
+          node.left.kind === SyntaxKind6.PrivateIdentifier
+        ) {
+          this.#throwError(
+            node.left,
+            "Private identifiers cannot appear on the right-hand-side of an 'in' expression.",
+          );
+        } else if (node.right.kind === SyntaxKind6.PrivateIdentifier) {
+          this.#throwError(
+            node.right,
+            "Private identifiers are only allowed on the left-hand-side of an 'in' expression.",
+          );
+        }
+        if ((0, isComma)(node.operatorToken)) {
+          const result = this.createNode(node, {
+            type: AST_NODE_TYPES2.SequenceExpression,
+            expressions: [],
+          });
+          const left = this.convertChild(node.left);
+          if (
+            left.type === AST_NODE_TYPES2.SequenceExpression &&
+            node.left.kind !== SyntaxKind6.ParenthesizedExpression
+          ) {
+            result.expressions.push(...left.expressions);
+          } else {
+            result.expressions.push(left);
+          }
+          result.expressions.push(this.convertChild(node.right));
+          return result;
+        }
+        const expressionType = (0, getBinaryExpressionType)(node.operatorToken);
+        if (this.allowPattern && expressionType.type === AST_NODE_TYPES2.AssignmentExpression) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.AssignmentPattern,
+            decorators: [],
+            left: this.convertPattern(node.left, node),
+            optional: false,
+            right: this.convertChild(node.right),
+            typeAnnotation: void 0,
+          });
+        }
+        return this.createNode(node, {
+          ...expressionType,
+          left: this.converter(node.left, node, expressionType.type === AST_NODE_TYPES2.AssignmentExpression),
+          right: this.convertChild(node.right),
+        });
+      }
+      case SyntaxKind6.PropertyAccessExpression: {
+        const object = this.convertChild(node.expression);
+        const property = this.convertChild(node.name);
+        const computed = false;
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.MemberExpression,
+          computed,
+          object,
+          optional: node.questionDotToken != null,
+          property,
+        });
+        return this.convertChainExpression(result, node);
+      }
+      case SyntaxKind6.ElementAccessExpression: {
+        const object = this.convertChild(node.expression);
+        const property = this.convertChild(node.argumentExpression);
+        const computed = true;
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.MemberExpression,
+          computed,
+          object,
+          optional: node.questionDotToken != null,
+          property,
+        });
+        return this.convertChainExpression(result, node);
+      }
+      case SyntaxKind6.CallExpression: {
+        if (node.expression.kind === SyntaxKind6.ImportKeyword) {
+          if (node.arguments.length !== 1 && node.arguments.length !== 2) {
+            this.#throwUnlessAllowInvalidAST(
+              node.arguments[2] ?? node,
+              'Dynamic import requires exactly one or two arguments.',
+            );
+          }
+          return this.createNode(
+            node,
+            this.#withDeprecatedAliasGetter(
+              {
+                type: AST_NODE_TYPES2.ImportExpression,
+                options: node.arguments[1] ? this.convertChild(node.arguments[1]) : null,
+                source: this.convertChild(node.arguments[0]),
+              },
+              'attributes',
+              'options',
+              true,
+            ),
+          );
+        }
+        const callee = this.convertChild(node.expression);
+        const args = this.convertChildren(node.arguments);
+        const typeArguments =
+          node.typeArguments &&
+          this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.CallExpression,
+          arguments: args,
+          callee,
+          optional: node.questionDotToken != null,
+          typeArguments,
+        });
+        return this.convertChainExpression(result, node);
+      }
+      case SyntaxKind6.NewExpression: {
+        const typeArguments =
+          node.typeArguments &&
+          this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.NewExpression,
+          arguments: this.convertChildren(node.arguments ?? []),
+          callee: this.convertChild(node.expression),
+          typeArguments,
+        });
+      }
+      case SyntaxKind6.ConditionalExpression:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ConditionalExpression,
+          alternate: this.convertChild(node.whenFalse),
+          consequent: this.convertChild(node.whenTrue),
+          test: this.convertChild(node.condition),
+        });
+      case SyntaxKind6.MetaProperty: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.MetaProperty,
+          meta: this.createNode(
+            // TODO: do we really want to convert it to Token?
+            node.getFirstToken(),
+            {
+              type: AST_NODE_TYPES2.Identifier,
+              decorators: [],
+              name: (0, getTextForTokenKind)(node.keywordToken),
+              optional: false,
+              typeAnnotation: void 0,
+            },
+          ),
+          property: this.convertChild(node.name),
+        });
+      }
+      case SyntaxKind6.Decorator: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Decorator,
+          expression: this.convertChild(node.expression),
+        });
+      }
+      // Literals
+      case SyntaxKind6.StringLiteral: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          raw: node.getText(),
+          value:
+            parent.kind === SyntaxKind6.JsxAttribute ? (0, unescapeStringLiteralText)(node.text) : node.text,
+        });
+      }
+      case SyntaxKind6.NumericLiteral: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          raw: node.getText(),
+          value: Number(node.text),
+        });
+      }
+      case SyntaxKind6.BigIntLiteral: {
+        const range = (0, getRange)(node, this.ast);
+        const rawValue = this.ast.text.slice(range[0], range[1]);
+        const bigint = method_replace_all_default(
+          /* OPTIONAL_OBJECT: false */
+          0,
+          rawValue.slice(0, -1),
+          '_',
+          '',
+        );
+        const value = typeof BigInt !== 'undefined' ? BigInt(bigint) : null;
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          range,
+          bigint: value == null ? bigint : String(value),
+          raw: rawValue,
+          value,
+        });
+      }
+      case SyntaxKind6.RegularExpressionLiteral: {
+        const pattern = node.text.slice(1, node.text.lastIndexOf('/'));
+        const flags = node.text.slice(node.text.lastIndexOf('/') + 1);
+        let regex = null;
+        try {
+          regex = new RegExp(pattern, flags);
+        } catch {}
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          raw: node.text,
+          regex: {
+            flags,
+            pattern,
+          },
+          value: regex,
+        });
+      }
+      case SyntaxKind6.TrueKeyword:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          raw: 'true',
+          value: true,
+        });
+      case SyntaxKind6.FalseKeyword:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          raw: 'false',
+          value: false,
+        });
+      case SyntaxKind6.NullKeyword: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.Literal,
+          raw: 'null',
+          value: null,
+        });
+      }
+      case SyntaxKind6.EmptyStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.EmptyStatement,
+        });
+      case SyntaxKind6.DebuggerStatement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.DebuggerStatement,
+        });
+      // JSX
+      case SyntaxKind6.JsxElement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXElement,
+          children: this.convertChildren(node.children),
+          closingElement: this.convertChild(node.closingElement),
+          openingElement: this.convertChild(node.openingElement),
+        });
+      case SyntaxKind6.JsxFragment:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXFragment,
+          children: this.convertChildren(node.children),
+          closingFragment: this.convertChild(node.closingFragment),
+          openingFragment: this.convertChild(node.openingFragment),
+        });
+      case SyntaxKind6.JsxSelfClosingElement: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXElement,
+          /**
+           * Convert SyntaxKind.JsxSelfClosingElement to SyntaxKind.JsxOpeningElement,
+           * TypeScript does not seem to have the idea of openingElement when tag is self-closing
+           */
+          children: [],
+          closingElement: null,
+          openingElement: this.createNode(node, {
+            type: AST_NODE_TYPES2.JSXOpeningElement,
+            range: (0, getRange)(node, this.ast),
+            attributes: this.convertChildren(node.attributes.properties),
+            name: this.convertJSXTagName(node.tagName, node),
+            selfClosing: true,
+            typeArguments: node.typeArguments
+              ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+              : void 0,
+          }),
+        });
+      }
+      case SyntaxKind6.JsxOpeningElement: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXOpeningElement,
+          attributes: this.convertChildren(node.attributes.properties),
+          name: this.convertJSXTagName(node.tagName, node),
+          selfClosing: false,
+          typeArguments:
+            node.typeArguments &&
+            this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+        });
+      }
+      case SyntaxKind6.JsxClosingElement:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXClosingElement,
+          name: this.convertJSXTagName(node.tagName, node),
+        });
+      case SyntaxKind6.JsxOpeningFragment:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXOpeningFragment,
+        });
+      case SyntaxKind6.JsxClosingFragment:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXClosingFragment,
+        });
+      case SyntaxKind6.JsxExpression: {
+        const expression = node.expression
+          ? this.convertChild(node.expression)
+          : this.createNode(node, {
+              type: AST_NODE_TYPES2.JSXEmptyExpression,
+              range: [node.getStart(this.ast) + 1, node.getEnd() - 1],
+            });
+        if (node.dotDotDotToken) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.JSXSpreadChild,
+            expression,
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXExpressionContainer,
+          expression,
+        });
+      }
+      case SyntaxKind6.JsxAttribute: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXAttribute,
+          name: this.convertJSXNamespaceOrIdentifier(node.name),
+          value: this.convertChild(node.initializer),
+        });
+      }
+      case SyntaxKind6.JsxText: {
+        const start = node.getFullStart();
+        const end = node.getEnd();
+        const text = this.ast.text.slice(start, end);
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXText,
+          range: [start, end],
+          raw: text,
+          value: (0, unescapeStringLiteralText)(text),
+        });
+      }
+      case SyntaxKind6.JsxSpreadAttribute:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.JSXSpreadAttribute,
+          argument: this.convertChild(node.expression),
+        });
+      case SyntaxKind6.QualifiedName: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSQualifiedName,
+          left: this.convertChild(node.left),
+          right: this.convertChild(node.right),
+        });
+      }
+      // TypeScript specific
+      case SyntaxKind6.TypeReference:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeReference,
+          typeArguments:
+            node.typeArguments &&
+            this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+          typeName: this.convertChild(node.typeName),
+        });
+      case SyntaxKind6.TypeParameter: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeParameter,
+          const: (0, hasModifier)(SyntaxKind6.ConstKeyword, node),
+          constraint: node.constraint && this.convertChild(node.constraint),
+          default: node.default ? this.convertChild(node.default) : void 0,
+          in: (0, hasModifier)(SyntaxKind6.InKeyword, node),
+          name: this.convertChild(node.name),
+          out: (0, hasModifier)(SyntaxKind6.OutKeyword, node),
+        });
+      }
+      case SyntaxKind6.ThisType:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSThisType,
+        });
+      case SyntaxKind6.AnyKeyword:
+      case SyntaxKind6.BigIntKeyword:
+      case SyntaxKind6.BooleanKeyword:
+      case SyntaxKind6.NeverKeyword:
+      case SyntaxKind6.NumberKeyword:
+      case SyntaxKind6.ObjectKeyword:
+      case SyntaxKind6.StringKeyword:
+      case SyntaxKind6.SymbolKeyword:
+      case SyntaxKind6.UnknownKeyword:
+      case SyntaxKind6.VoidKeyword:
+      case SyntaxKind6.UndefinedKeyword:
+      case SyntaxKind6.IntrinsicKeyword: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2[`TS${SyntaxKind6[node.kind]}`],
+        });
+      }
+      case SyntaxKind6.NonNullExpression: {
+        const nnExpr = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSNonNullExpression,
+          expression: this.convertChild(node.expression),
+        });
+        return this.convertChainExpression(nnExpr, node);
+      }
+      case SyntaxKind6.TypeLiteral: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeLiteral,
+          members: this.convertChildren(node.members),
+        });
+      }
+      case SyntaxKind6.ArrayType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSArrayType,
+          elementType: this.convertChild(node.elementType),
+        });
+      }
+      case SyntaxKind6.IndexedAccessType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSIndexedAccessType,
+          indexType: this.convertChild(node.indexType),
+          objectType: this.convertChild(node.objectType),
+        });
+      }
+      case SyntaxKind6.ConditionalType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSConditionalType,
+          checkType: this.convertChild(node.checkType),
+          extendsType: this.convertChild(node.extendsType),
+          falseType: this.convertChild(node.falseType),
+          trueType: this.convertChild(node.trueType),
+        });
+      }
+      case SyntaxKind6.TypeQuery:
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeQuery,
+          exprName: this.convertChild(node.exprName),
+          typeArguments:
+            node.typeArguments &&
+            this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+        });
+      case SyntaxKind6.MappedType: {
+        if (node.members && node.members.length > 0) {
+          this.#throwUnlessAllowInvalidAST(
+            node.members[0],
+            'A mapped type may not declare properties or methods.',
+          );
+        }
+        return this.createNode(
+          node,
+          this.#withDeprecatedGetter(
+            {
+              type: AST_NODE_TYPES2.TSMappedType,
+              constraint: this.convertChild(node.typeParameter.constraint),
+              key: this.convertChild(node.typeParameter.name),
+              nameType: this.convertChild(node.nameType) ?? null,
+              optional: node.questionToken
+                ? node.questionToken.kind === SyntaxKind6.QuestionToken ||
+                  (0, getTextForTokenKind)(node.questionToken.kind)
+                : false,
+              readonly: node.readonlyToken
+                ? node.readonlyToken.kind === SyntaxKind6.ReadonlyKeyword ||
+                  (0, getTextForTokenKind)(node.readonlyToken.kind)
+                : void 0,
+              typeAnnotation: node.type && this.convertChild(node.type),
+            },
+            'typeParameter',
+            "'constraint' and 'key'",
+            this.convertChild(node.typeParameter),
+          ),
+        );
+      }
+      case SyntaxKind6.ParenthesizedExpression:
+        return this.convertChild(node.expression, parent);
+      case SyntaxKind6.TypeAliasDeclaration: {
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeAliasDeclaration,
+          declare: (0, hasModifier)(SyntaxKind6.DeclareKeyword, node),
+          id: this.convertChild(node.name),
+          typeAnnotation: this.convertChild(node.type),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+        return this.fixExports(node, result);
+      }
+      case SyntaxKind6.MethodSignature: {
+        return this.convertMethodSignature(node);
+      }
+      case SyntaxKind6.PropertySignature: {
+        const { initializer } = node;
+        if (initializer) {
+          this.#throwError(initializer, 'A property signature cannot have an initializer.');
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSPropertySignature,
+          accessibility: (0, getTSNodeAccessibility)(node),
+          computed: (0, isComputedProperty)(node.name),
+          key: this.convertChild(node.name),
+          optional: (0, isOptional)(node),
+          readonly: (0, hasModifier)(SyntaxKind6.ReadonlyKeyword, node),
+          static: (0, hasModifier)(SyntaxKind6.StaticKeyword, node),
+          typeAnnotation: node.type && this.convertTypeAnnotation(node.type, node),
+        });
+      }
+      case SyntaxKind6.IndexSignature: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSIndexSignature,
+          accessibility: (0, getTSNodeAccessibility)(node),
+          parameters: this.convertChildren(node.parameters),
+          readonly: (0, hasModifier)(SyntaxKind6.ReadonlyKeyword, node),
+          static: (0, hasModifier)(SyntaxKind6.StaticKeyword, node),
+          typeAnnotation: node.type && this.convertTypeAnnotation(node.type, node),
+        });
+      }
+      case SyntaxKind6.ConstructorType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSConstructorType,
+          abstract: (0, hasModifier)(SyntaxKind6.AbstractKeyword, node),
+          params: this.convertParameters(node.parameters),
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+      }
+      case SyntaxKind6.FunctionType: {
+        const { modifiers } = node;
+        if (modifiers) {
+          this.#throwError(modifiers[0], 'A function type cannot have modifiers.');
+        }
+      }
+      // intentional fallthrough
+      case SyntaxKind6.ConstructSignature:
+      case SyntaxKind6.CallSignature: {
+        const type =
+          node.kind === SyntaxKind6.ConstructSignature
+            ? AST_NODE_TYPES2.TSConstructSignatureDeclaration
+            : node.kind === SyntaxKind6.CallSignature
+              ? AST_NODE_TYPES2.TSCallSignatureDeclaration
+              : AST_NODE_TYPES2.TSFunctionType;
+        return this.createNode(node, {
+          type,
+          params: this.convertParameters(node.parameters),
+          returnType: node.type && this.convertTypeAnnotation(node.type, node),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+      }
+      case SyntaxKind6.ExpressionWithTypeArguments: {
+        const parentKind = parent.kind;
+        const type =
+          parentKind === SyntaxKind6.InterfaceDeclaration
+            ? AST_NODE_TYPES2.TSInterfaceHeritage
+            : parentKind === SyntaxKind6.HeritageClause
+              ? AST_NODE_TYPES2.TSClassImplements
+              : AST_NODE_TYPES2.TSInstantiationExpression;
+        return this.createNode(node, {
+          type,
+          expression: this.convertChild(node.expression),
+          typeArguments:
+            node.typeArguments &&
+            this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+        });
+      }
+      case SyntaxKind6.InterfaceDeclaration: {
+        const interfaceHeritageClauses = node.heritageClauses ?? [];
+        const interfaceExtends = [];
+        let seenExtendsClause = false;
+        for (const heritageClause of interfaceHeritageClauses) {
+          if (heritageClause.token !== SyntaxKind6.ExtendsKeyword) {
+            this.#throwError(
+              heritageClause,
+              heritageClause.token === SyntaxKind6.ImplementsKeyword
+                ? "Interface declaration cannot have 'implements' clause."
+                : 'Unexpected token.',
+            );
+          }
+          if (seenExtendsClause) {
+            this.#throwError(heritageClause, "'extends' clause already seen.");
+          }
+          seenExtendsClause = true;
+          for (const heritageType of heritageClause.types) {
+            if (
+              !isEntityNameExpression(heritageType.expression) ||
+              ts.isOptionalChain(heritageType.expression)
+            ) {
+              this.#throwError(
+                heritageType,
+                'Interface declaration can only extend an identifier/qualified name with optional type arguments.',
+              );
+            }
+            interfaceExtends.push(this.convertChild(heritageType, node));
+          }
+        }
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSInterfaceDeclaration,
+          body: this.createNode(node, {
+            type: AST_NODE_TYPES2.TSInterfaceBody,
+            range: [node.members.pos - 1, node.end],
+            body: this.convertChildren(node.members),
+          }),
+          declare: (0, hasModifier)(SyntaxKind6.DeclareKeyword, node),
+          extends: interfaceExtends,
+          id: this.convertChild(node.name),
+          typeParameters:
+            node.typeParameters &&
+            this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+        });
+        return this.fixExports(node, result);
+      }
+      case SyntaxKind6.TypePredicate: {
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypePredicate,
+          asserts: node.assertsModifier != null,
+          parameterName: this.convertChild(node.parameterName),
+          typeAnnotation: null,
+        });
+        if (node.type) {
+          result.typeAnnotation = this.convertTypeAnnotation(node.type, node);
+          result.typeAnnotation.loc = result.typeAnnotation.typeAnnotation.loc;
+          result.typeAnnotation.range = result.typeAnnotation.typeAnnotation.range;
+        }
+        return result;
+      }
+      case SyntaxKind6.ImportType: {
+        const range = (0, getRange)(node, this.ast);
+        if (node.isTypeOf) {
+          const token = (0, findNextToken)(node.getFirstToken(), node, this.ast);
+          range[0] = token.getStart(this.ast);
+        }
+        let options = null;
+        if (node.attributes) {
+          const value = this.createNode(node.attributes, {
+            type: AST_NODE_TYPES2.ObjectExpression,
+            properties: node.attributes.elements.map((importAttribute) =>
+              this.createNode(importAttribute, {
+                type: AST_NODE_TYPES2.Property,
+                computed: false,
+                key: this.convertChild(importAttribute.name),
+                kind: 'init',
+                method: false,
+                optional: false,
+                shorthand: false,
+                value: this.convertChild(importAttribute.value),
+              }),
+            ),
+          });
+          const commaToken = (0, findNextToken)(node.argument, node, this.ast);
+          const openBraceToken = (0, findNextToken)(commaToken, node, this.ast);
+          const tokenAfterAttributes = (0, findNextToken)(node.attributes, node, this.ast);
+          const closeBraceToken =
+            tokenAfterAttributes.kind === ts.SyntaxKind.CommaToken
+              ? (0, findNextToken)(tokenAfterAttributes, node, this.ast)
+              : tokenAfterAttributes;
+          const withOrAssertToken = (0, findNextToken)(openBraceToken, node, this.ast);
+          const withOrAssertTokenRange = (0, getRange)(withOrAssertToken, this.ast);
+          const withOrAssertName = withOrAssertToken.kind === ts.SyntaxKind.AssertKeyword ? 'assert' : 'with';
+          options = this.createNode(node, {
+            type: AST_NODE_TYPES2.ObjectExpression,
+            range: [openBraceToken.getStart(this.ast), closeBraceToken.end],
+            properties: [
+              this.createNode(node, {
+                type: AST_NODE_TYPES2.Property,
+                range: [withOrAssertTokenRange[0], node.attributes.end],
+                computed: false,
+                key: this.createNode(node, {
+                  type: AST_NODE_TYPES2.Identifier,
+                  range: withOrAssertTokenRange,
+                  decorators: [],
+                  name: withOrAssertName,
+                  optional: false,
+                  typeAnnotation: void 0,
+                }),
+                kind: 'init',
+                method: false,
+                optional: false,
+                shorthand: false,
+                value,
+              }),
+            ],
+          });
+        }
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSImportType,
+          range,
+          argument: this.convertChild(node.argument),
+          options,
+          qualifier: this.convertChild(node.qualifier),
+          typeArguments: node.typeArguments
+            ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+            : null,
+        });
+        if (node.isTypeOf) {
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.TSTypeQuery,
+            exprName: result,
+            typeArguments: void 0,
+          });
+        }
+        return result;
+      }
+      case SyntaxKind6.EnumDeclaration: {
+        const members = this.convertChildren(node.members);
+        const result = this.createNode(
+          node,
+          this.#withDeprecatedGetter(
+            {
+              type: AST_NODE_TYPES2.TSEnumDeclaration,
+              body: this.createNode(node, {
+                type: AST_NODE_TYPES2.TSEnumBody,
+                range: [node.members.pos - 1, node.end],
+                members,
+              }),
+              const: (0, hasModifier)(SyntaxKind6.ConstKeyword, node),
+              declare: (0, hasModifier)(SyntaxKind6.DeclareKeyword, node),
+              id: this.convertChild(node.name),
+            },
+            'members',
+            `'body.members'`,
+            this.convertChildren(node.members),
+          ),
+        );
+        return this.fixExports(node, result);
+      }
+      case SyntaxKind6.EnumMember: {
+        const computed = node.name.kind === ts.SyntaxKind.ComputedPropertyName;
+        if (computed) {
+          this.#throwUnlessAllowInvalidAST(node.name, 'Computed property names are not allowed in enums.');
+        }
+        if (node.name.kind === SyntaxKind6.NumericLiteral || node.name.kind === SyntaxKind6.BigIntLiteral) {
+          this.#throwUnlessAllowInvalidAST(node.name, 'An enum member cannot have a numeric name.');
+        }
+        return this.createNode(
+          node,
+          this.#withDeprecatedGetter(
+            {
+              type: AST_NODE_TYPES2.TSEnumMember,
+              id: this.convertChild(node.name),
+              initializer: node.initializer && this.convertChild(node.initializer),
+            },
+            'computed',
+            void 0,
+            computed,
+          ),
+        );
+      }
+      case SyntaxKind6.ModuleDeclaration: {
+        let isDeclare = (0, hasModifier)(SyntaxKind6.DeclareKeyword, node);
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSModuleDeclaration,
+          ...(() => {
+            if (node.flags & ts.NodeFlags.GlobalAugmentation) {
+              const id = this.convertChild(node.name);
+              const body = this.convertChild(node.body);
+              if (body == null || body.type === AST_NODE_TYPES2.TSModuleDeclaration) {
+                this.#throwUnlessAllowInvalidAST(node.body ?? node, 'Expected a valid module body');
+              }
+              if (id.type !== AST_NODE_TYPES2.Identifier) {
+                this.#throwUnlessAllowInvalidAST(
+                  node.name,
+                  'global module augmentation must have an Identifier id',
+                );
+              }
+              return {
+                body,
+                declare: false,
+                global: false,
+                id,
+                kind: 'global',
+              };
+            }
+            if (ts.isStringLiteral(node.name)) {
+              const body = this.convertChild(node.body);
+              return {
+                kind: 'module',
+                ...(body != null
+                  ? {
+                      body,
+                    }
+                  : {}),
+                declare: false,
+                global: false,
+                id: this.convertChild(node.name),
+              };
+            }
+            if (node.body == null) {
+              this.#throwUnlessAllowInvalidAST(node, 'Expected a module body');
+            }
+            if (node.name.kind !== ts.SyntaxKind.Identifier) {
+              this.#throwUnlessAllowInvalidAST(node.name, '`namespace`s must have an Identifier id');
+            }
+            let name = this.createNode(node.name, {
+              type: AST_NODE_TYPES2.Identifier,
+              range: [node.name.getStart(this.ast), node.name.getEnd()],
+              decorators: [],
+              name: node.name.text,
+              optional: false,
+              typeAnnotation: void 0,
+            });
+            while (node.body && ts.isModuleDeclaration(node.body) && node.body.name) {
+              node = node.body;
+              isDeclare || (isDeclare = (0, hasModifier)(SyntaxKind6.DeclareKeyword, node));
+              const nextName = node.name;
+              const right = this.createNode(nextName, {
+                type: AST_NODE_TYPES2.Identifier,
+                range: [nextName.getStart(this.ast), nextName.getEnd()],
+                decorators: [],
+                name: nextName.text,
+                optional: false,
+                typeAnnotation: void 0,
+              });
+              name = this.createNode(nextName, {
+                type: AST_NODE_TYPES2.TSQualifiedName,
+                range: [name.range[0], right.range[1]],
+                left: name,
+                right,
+              });
+            }
+            return {
+              body: this.convertChild(node.body),
+              declare: false,
+              global: false,
+              id: name,
+              kind: node.flags & ts.NodeFlags.Namespace ? 'namespace' : 'module',
+            };
+          })(),
+        });
+        result.declare = isDeclare;
+        if (node.flags & ts.NodeFlags.GlobalAugmentation) {
+          result.global = true;
+        }
+        return this.fixExports(node, result);
+      }
+      // TypeScript specific types
+      case SyntaxKind6.ParenthesizedType: {
+        return this.convertChild(node.type);
+      }
+      case SyntaxKind6.UnionType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSUnionType,
+          types: this.convertChildren(node.types),
+        });
+      }
+      case SyntaxKind6.IntersectionType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSIntersectionType,
+          types: this.convertChildren(node.types),
+        });
+      }
+      case SyntaxKind6.AsExpression: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSAsExpression,
+          expression: this.convertChild(node.expression),
+          typeAnnotation: this.convertChild(node.type),
+        });
+      }
+      case SyntaxKind6.InferType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSInferType,
+          typeParameter: this.convertChild(node.typeParameter),
+        });
+      }
+      case SyntaxKind6.LiteralType: {
+        if (node.literal.kind === SyntaxKind6.NullKeyword) {
+          return this.createNode(node.literal, {
+            type: AST_NODE_TYPES2.TSNullKeyword,
+          });
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSLiteralType,
+          literal: this.convertChild(node.literal),
+        });
+      }
+      case SyntaxKind6.TypeAssertionExpression: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTypeAssertion,
+          expression: this.convertChild(node.expression),
+          typeAnnotation: this.convertChild(node.type),
+        });
+      }
+      case SyntaxKind6.ImportEqualsDeclaration: {
+        return this.fixExports(
+          node,
+          this.createNode(node, {
+            type: AST_NODE_TYPES2.TSImportEqualsDeclaration,
+            id: this.convertChild(node.name),
+            importKind: node.isTypeOnly ? 'type' : 'value',
+            moduleReference: this.convertChild(node.moduleReference),
+          }),
+        );
+      }
+      case SyntaxKind6.ExternalModuleReference: {
+        if (node.expression.kind !== SyntaxKind6.StringLiteral) {
+          this.#throwError(node.expression, 'String literal expected.');
+        }
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSExternalModuleReference,
+          expression: this.convertChild(node.expression),
+        });
+      }
+      case SyntaxKind6.NamespaceExportDeclaration: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSNamespaceExportDeclaration,
+          id: this.convertChild(node.name),
+        });
+      }
+      case SyntaxKind6.AbstractKeyword: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSAbstractKeyword,
+        });
+      }
+      // Tuple
+      case SyntaxKind6.TupleType: {
+        const elementTypes = this.convertChildren(node.elements);
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTupleType,
+          elementTypes,
+        });
+      }
+      case SyntaxKind6.NamedTupleMember: {
+        const member = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSNamedTupleMember,
+          elementType: this.convertChild(node.type, node),
+          label: this.convertChild(node.name, node),
+          optional: node.questionToken != null,
+        });
+        if (node.dotDotDotToken) {
+          member.range[0] = member.label.range[0];
+          member.loc.start = member.label.loc.start;
+          return this.createNode(node, {
+            type: AST_NODE_TYPES2.TSRestType,
+            typeAnnotation: member,
+          });
+        }
+        return member;
+      }
+      case SyntaxKind6.OptionalType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSOptionalType,
+          typeAnnotation: this.convertChild(node.type),
+        });
+      }
+      case SyntaxKind6.RestType: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSRestType,
+          typeAnnotation: this.convertChild(node.type),
+        });
+      }
+      // Template Literal Types
+      case SyntaxKind6.TemplateLiteralType: {
+        const result = this.createNode(node, {
+          type: AST_NODE_TYPES2.TSTemplateLiteralType,
+          quasis: [this.convertChild(node.head)],
+          types: [],
+        });
+        node.templateSpans.forEach((templateSpan) => {
+          result.types.push(this.convertChild(templateSpan.type));
+          result.quasis.push(this.convertChild(templateSpan.literal));
+        });
+        return result;
+      }
+      case SyntaxKind6.ClassStaticBlockDeclaration: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.StaticBlock,
+          body: this.convertBodyExpressions(node.body.statements, node),
+        });
+      }
+      case SyntaxKind6.AssertEntry:
+      case SyntaxKind6.ImportAttribute: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ImportAttribute,
+          key: this.convertChild(node.name),
+          value: this.convertChild(node.value),
+        });
+      }
+      case SyntaxKind6.SatisfiesExpression: {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.TSSatisfiesExpression,
+          expression: this.convertChild(node.expression),
+          typeAnnotation: this.convertChild(node.type),
+        });
+      }
+      default:
+        return this.deeplyCopy(node);
+    }
+  }
+  createNode(node, data) {
+    const result = data;
+    result.range ?? (result.range = (0, getRange)(node, this.ast));
+    result.loc ?? (result.loc = (0, getLocFor)(result.range, this.ast));
+    if (result && this.options.shouldPreserveNodeMaps) {
+      this.esTreeNodeToTSNodeMap.set(result, node);
+    }
+    return result;
+  }
+  convertProgram() {
+    return this.converter(this.ast);
+  }
+  /**
+   * For nodes that are copied directly from the TypeScript AST into
+   * ESTree mostly as-is. The only difference is the addition of a type
+   * property instead of a kind property. Recursively copies all children.
+   */
+  deeplyCopy(node) {
+    if (node.kind === ts.SyntaxKind.JSDocFunctionType) {
+      this.#throwError(node, 'JSDoc types can only be used inside documentation comments.');
+    }
+    const customType = `TS${SyntaxKind6[node.kind]}`;
+    if (this.options.errorOnUnknownASTType && !AST_NODE_TYPES2[customType]) {
+      throw new Error(`Unknown AST_NODE_TYPE: "${customType}"`);
+    }
+    const result = this.createNode(node, {
+      type: customType,
+    });
+    if ('type' in node) {
+      result.typeAnnotation =
+        node.type && 'kind' in node.type && ts.isTypeNode(node.type)
+          ? this.convertTypeAnnotation(node.type, node)
+          : null;
+    }
+    if ('typeArguments' in node) {
+      result.typeArguments =
+        node.typeArguments && 'pos' in node.typeArguments
+          ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+          : null;
+    }
+    if ('typeParameters' in node) {
+      result.typeParameters =
+        node.typeParameters && 'pos' in node.typeParameters
+          ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+          : null;
+    }
+    const decorators = (0, getDecorators2)(node);
+    if (decorators?.length) {
+      result.decorators = this.convertChildren(decorators);
+    }
+    const KEYS_TO_NOT_COPY = /* @__PURE__ */ new Set([
+      '_children',
+      'decorators',
+      'end',
+      'flags',
+      'heritageClauses',
+      'illegalDecorators',
+      'jsDoc',
+      'kind',
+      'locals',
+      'localSymbol',
+      'modifierFlagsCache',
+      'modifiers',
+      'nextContainer',
+      'parent',
+      'pos',
+      'symbol',
+      'transformFlags',
+      'type',
+      'typeArguments',
+      'typeParameters',
+    ]);
+    Object.entries(node)
+      .filter(([key]) => !KEYS_TO_NOT_COPY.has(key))
+      .forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          result[key] = this.convertChildren(value);
+        } else if (value && typeof value === 'object' && value.kind) {
+          result[key] = this.convertChild(value);
+        } else {
+          result[key] = value;
+        }
+      });
+    return result;
+  }
+  /**
+   * Fixes the exports of the given ts.Node
+   * @returns the ESTreeNode with fixed exports
+   */
+  fixExports(node, result) {
+    const isNamespaceNode = ts.isModuleDeclaration(node) && !ts.isStringLiteral(node.name);
+    const modifiers = isNamespaceNode ? (0, getNamespaceModifiers)(node) : (0, getModifiers2)(node);
+    if (modifiers?.[0].kind === SyntaxKind6.ExportKeyword) {
+      this.registerTSNodeInNodeMap(node, result);
+      const exportKeyword = modifiers[0];
+      const nextModifier = modifiers[1];
+      const declarationIsDefault = nextModifier?.kind === SyntaxKind6.DefaultKeyword;
+      const varToken = declarationIsDefault
+        ? (0, findNextToken)(nextModifier, this.ast, this.ast)
+        : (0, findNextToken)(exportKeyword, this.ast, this.ast);
+      result.range[0] = varToken.getStart(this.ast);
+      result.loc = (0, getLocFor)(result.range, this.ast);
+      if (declarationIsDefault) {
+        return this.createNode(node, {
+          type: AST_NODE_TYPES2.ExportDefaultDeclaration,
+          range: [exportKeyword.getStart(this.ast), result.range[1]],
+          declaration: result,
+          exportKind: 'value',
+        });
+      }
+      const isType =
+        result.type === AST_NODE_TYPES2.TSInterfaceDeclaration ||
+        result.type === AST_NODE_TYPES2.TSTypeAliasDeclaration;
+      const isDeclare = 'declare' in result && result.declare;
+      return this.createNode(
+        node,
+        // @ts-expect-error - TODO, narrow the types here
+        this.#withDeprecatedAliasGetter(
+          {
+            type: AST_NODE_TYPES2.ExportNamedDeclaration,
+            range: [exportKeyword.getStart(this.ast), result.range[1]],
+            attributes: [],
+            declaration: result,
+            exportKind: isType || isDeclare ? 'type' : 'value',
+            source: null,
+            specifiers: [],
+          },
+          'assertions',
+          'attributes',
+          true,
+        ),
+      );
+    }
+    return result;
+  }
+  getASTMaps() {
+    return {
+      esTreeNodeToTSNodeMap: this.esTreeNodeToTSNodeMap,
+      tsNodeToESTreeNodeMap: this.tsNodeToESTreeNodeMap,
+    };
+  }
+  /**
+   * Register specific TypeScript node into map with first ESTree node provided
+   */
+  registerTSNodeInNodeMap(node, result) {
+    if (result && this.options.shouldPreserveNodeMaps && !this.tsNodeToESTreeNodeMap.has(node)) {
+      this.tsNodeToESTreeNodeMap.set(node, result);
+    }
+  }
+};
+
+// node_modules/ts-api-utils/lib/index.js
+function forEachToken(node, callback, sourceFile = node.getSourceFile()) {
+  const queue = [];
+  while (true) {
+    if (ts.isTokenKind(node.kind)) {
+      callback(node);
+    } else {
+      const children = node.getChildren(sourceFile);
+      if (children.length === 1) {
+        node = children[0];
+        continue;
+      }
+      for (let i = children.length - 1; i >= 0; --i) {
+        queue.push(children[i]);
+      }
+    }
+    if (queue.length === 0) {
+      break;
+    }
+    node = queue.pop();
+  }
+}
+function forEachComment(node, callback, sourceFile = node.getSourceFile()) {
+  const fullText = sourceFile.text;
+  const notJsx = sourceFile.languageVariant !== ts.LanguageVariant.JSX;
+  return forEachToken(
+    node,
+    (token) => {
+      if (token.pos === token.end) {
+        return;
+      }
+      if (token.kind !== ts.SyntaxKind.JsxText) {
+        ts.forEachLeadingCommentRange(
+          fullText,
+          // skip shebang at position 0
+          token.pos === 0 ? (ts.getShebang(fullText) ?? '').length : token.pos,
+          commentCallback,
+        );
+      }
+      if (notJsx || canHaveTrailingTrivia(token)) {
+        return ts.forEachTrailingCommentRange(fullText, token.end, commentCallback);
+      }
+    },
+    sourceFile,
+  );
+  function commentCallback(pos, end, kind) {
+    callback(fullText, { end, kind, pos });
+  }
+}
+function canHaveTrailingTrivia(token) {
+  switch (token.kind) {
+    case ts.SyntaxKind.CloseBraceToken:
+      return (
+        token.parent.kind !== ts.SyntaxKind.JsxExpression || !isJsxElementOrFragment(token.parent.parent)
+      );
+    case ts.SyntaxKind.GreaterThanToken:
+      switch (token.parent.kind) {
+        case ts.SyntaxKind.JsxClosingElement:
+        case ts.SyntaxKind.JsxClosingFragment:
+          return !isJsxElementOrFragment(token.parent.parent.parent);
+        case ts.SyntaxKind.JsxOpeningElement:
+          return token.end !== token.parent.end;
+        case ts.SyntaxKind.JsxOpeningFragment:
+          return false;
+        // would be inside the fragment
+        case ts.SyntaxKind.JsxSelfClosingElement:
+          return (
+            token.end !== token.parent.end || // if end is not equal, this is part of the type arguments list
+            !isJsxElementOrFragment(token.parent.parent)
+          );
+      }
+  }
+  return true;
+}
+function isJsxElementOrFragment(node) {
+  return node.kind === ts.SyntaxKind.JsxElement || node.kind === ts.SyntaxKind.JsxFragment;
+}
+var [tsMajor, tsMinor] = ts.versionMajorMinor.split('.').map((raw) => Number.parseInt(raw, 10));
+var IntrinsicTypeFlags =
+  ts.TypeFlags.Intrinsic ??
+  ts.TypeFlags.Any |
+    ts.TypeFlags.Unknown |
+    ts.TypeFlags.String |
+    ts.TypeFlags.Number |
+    ts.TypeFlags.BigInt |
+    ts.TypeFlags.Boolean |
+    ts.TypeFlags.BooleanLiteral |
+    ts.TypeFlags.ESSymbol |
+    ts.TypeFlags.Void |
+    ts.TypeFlags.Undefined |
+    ts.TypeFlags.Null |
+    ts.TypeFlags.Never |
+    ts.TypeFlags.NonPrimitive;
+
+// node_modules/@typescript-eslint/typescript-estree/dist/convert-comments.js
+function convertComments(ast, code) {
+  const comments = [];
+  forEachComment(
+    ast,
+    (_, comment) => {
+      const type =
+        comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
+          ? AST_TOKEN_TYPES2.Line
+          : AST_TOKEN_TYPES2.Block;
+      const range = [comment.pos, comment.end];
+      const loc = (0, getLocFor)(range, ast);
+      const textStart = range[0] + 2;
+      const textEnd =
+        comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
+          ? // single line comments end at the end
+            range[1]
+          : // multiline comments end 2 characters early
+            range[1] - 2;
+      comments.push({
+        type,
+        loc,
+        range,
+        value: code.slice(textStart, textEnd),
+      });
+    },
+    ast,
+  );
+  return comments;
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/simple-traverse.js
+var simpleTraverse = () => {};
+
+// node_modules/@typescript-eslint/typescript-estree/dist/ast-converter.js
+function astConverter(ast, parseSettings, shouldPreserveNodeMaps) {
+  const { parseDiagnostics } = ast;
+  if (parseDiagnostics.length) {
+    throw (0, convertError)(parseDiagnostics[0]);
+  }
+  const instance = new Converter(ast, {
+    allowInvalidAST: parseSettings.allowInvalidAST,
+    errorOnUnknownASTType: parseSettings.errorOnUnknownASTType,
+    shouldPreserveNodeMaps,
+    suppressDeprecatedPropertyWarnings: parseSettings.suppressDeprecatedPropertyWarnings,
+  });
+  const estree = instance.convertProgram();
+  if (!parseSettings.range || !parseSettings.loc) {
+    (0, simpleTraverse)(estree, {
+      enter: (node) => {
+        if (!parseSettings.range) {
+          delete node.range;
+        }
+        if (!parseSettings.loc) {
+          delete node.loc;
+        }
+      },
+    });
+  }
+  if (parseSettings.tokens) {
+    estree.tokens = (0, convertTokens)(ast);
+  }
+  if (parseSettings.comment) {
+    estree.comments = (0, convertComments)(ast, parseSettings.codeFullText);
+  }
+  const astMaps = instance.getASTMaps();
+  return { astMaps, estree };
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/create-program/createSourceFile.js
+
+// node_modules/@typescript-eslint/typescript-estree/dist/source-files.js
+function isSourceFile2(code) {
+  if (typeof code !== 'object' || code == null) {
+    return false;
+  }
+  const maybeSourceFile = code;
+  return (
+    maybeSourceFile.kind === ts.SyntaxKind.SourceFile && typeof maybeSourceFile.getFullText === 'function'
+  );
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/create-program/getScriptKind.js
+var __importDefault = function (mod) {
+  return mod && mod.__esModule ? mod : { default: mod };
+};
+var node_path_1 = __importDefault({
+  extname: (file) => '.' + file.split('.').pop(),
+});
+function getScriptKind(filePath, jsx) {
+  const extension = node_path_1.default.extname(filePath).toLowerCase();
+  switch (extension) {
+    case ts.Extension.Cjs:
+    case ts.Extension.Js:
+    case ts.Extension.Mjs:
+      return ts.ScriptKind.JS;
+    case ts.Extension.Cts:
+    case ts.Extension.Mts:
+    case ts.Extension.Ts:
+      return ts.ScriptKind.TS;
+    case ts.Extension.Json:
+      return ts.ScriptKind.JSON;
+    case ts.Extension.Jsx:
+      return ts.ScriptKind.JSX;
+    case ts.Extension.Tsx:
+      return ts.ScriptKind.TSX;
+    default:
+      return jsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  }
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/create-program/createSourceFile.js
+var debug_1 = { default: debug_default };
+var log = (0, debug_1.default)('typescript-eslint:typescript-estree:create-program:createSourceFile');
+function createSourceFile2(parseSettings) {
+  log(
+    'Getting AST without type information in %s mode for: %s',
+    parseSettings.jsx ? 'TSX' : 'TS',
+    parseSettings.filePath,
+  );
+  return (0, isSourceFile2)(parseSettings.code)
+    ? parseSettings.code
+    : ts.createSourceFile(
+        parseSettings.filePath,
+        parseSettings.codeFullText,
+        {
+          jsDocParsingMode: parseSettings.jsDocParsingMode,
+          languageVersion: ts.ScriptTarget.Latest,
+          setExternalModuleIndicator: parseSettings.setExternalModuleIndicator,
+        },
+        /* setParentNodes */
+        true,
+        (0, getScriptKind)(parseSettings.filePath, parseSettings.jsx),
+      );
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/createParseSettings.js
+
+// node_modules/@typescript-eslint/typescript-estree/dist/create-program/shared.js
+var ensureAbsolutePath = (path) => path;
+
+// node_modules/@typescript-eslint/typescript-estree/dist/create-program/validateDefaultProjectForFilesGlob.js
+var validateDefaultProjectForFilesGlob = () => {};
+
+// node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/ExpiringCache.js
+var DEFAULT_TSCONFIG_CACHE_DURATION_SECONDS = void 0;
+var ExpiringCache = class {};
+
+// node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/inferSingleRun.js
+var inferSingleRun = () => false;
+
+// node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/warnAboutTSVersion.js
+var warnAboutTSVersion = () => {};
+
+// node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/createParseSettings.js
+var __importDefault2 = function (mod) {
+  return mod && mod.__esModule ? mod : { default: mod };
+};
+var project_service_1 = {};
+var debug_12 = { default: debug_default };
+var node_path_12 = __importDefault2({
+  extname: (file) => '.' + file.split('.').pop(),
+});
+var log2 = (0, debug_12.default)('typescript-eslint:typescript-estree:parseSettings:createParseSettings');
+var TSCONFIG_MATCH_CACHE;
+var TSSERVER_PROJECT_SERVICE = null;
+var JSDocParsingMode2 = {
+  ParseAll: ts.JSDocParsingMode?.ParseAll,
+  ParseForTypeErrors: ts.JSDocParsingMode?.ParseForTypeErrors,
+  ParseForTypeInfo: ts.JSDocParsingMode?.ParseForTypeInfo,
+  ParseNone: ts.JSDocParsingMode?.ParseNone,
+};
+function createParseSettings(code, tsestreeOptions = {}) {
+  const codeFullText = enforceCodeString(code);
+  const singleRun = (0, inferSingleRun)(tsestreeOptions);
+  const tsconfigRootDir = void 0;
+  const passedLoggerFn = typeof tsestreeOptions.loggerFn === 'function';
+  const filePath = (0, ensureAbsolutePath)(
+    typeof tsestreeOptions.filePath === 'string' && tsestreeOptions.filePath !== '<input>'
+      ? tsestreeOptions.filePath
+      : getFileName(tsestreeOptions.jsx),
+    tsconfigRootDir,
+  );
+  const extension = node_path_12.default.extname(filePath).toLowerCase();
+  const jsDocParsingMode = (() => {
+    switch (tsestreeOptions.jsDocParsingMode) {
+      case 'all':
+        return JSDocParsingMode2.ParseAll;
+      case 'none':
+        return JSDocParsingMode2.ParseNone;
+      case 'type-info':
+        return JSDocParsingMode2.ParseForTypeInfo;
+      default:
+        return JSDocParsingMode2.ParseAll;
+    }
+  })();
+  const parseSettings = {
+    loc: tsestreeOptions.loc === true,
+    range: tsestreeOptions.range === true,
+    allowInvalidAST: tsestreeOptions.allowInvalidAST === true,
+    code,
+    codeFullText,
+    comment: tsestreeOptions.comment === true,
+    comments: [],
+    debugLevel:
+      tsestreeOptions.debugLevel === true
+        ? /* @__PURE__ */ new Set(['typescript-eslint'])
+        : Array.isArray(tsestreeOptions.debugLevel)
+          ? new Set(tsestreeOptions.debugLevel)
+          : /* @__PURE__ */ new Set(),
+    errorOnTypeScriptSyntacticAndSemanticIssues: false,
+    errorOnUnknownASTType: tsestreeOptions.errorOnUnknownASTType === true,
+    extraFileExtensions:
+      Array.isArray(tsestreeOptions.extraFileExtensions) &&
+      tsestreeOptions.extraFileExtensions.every((ext) => typeof ext === 'string')
+        ? tsestreeOptions.extraFileExtensions
+        : [],
+    filePath,
+    jsDocParsingMode,
+    jsx: tsestreeOptions.jsx === true,
+    log:
+      typeof tsestreeOptions.loggerFn === 'function'
+        ? tsestreeOptions.loggerFn
+        : tsestreeOptions.loggerFn === false
+          ? () => {}
+          : console.log,
+    preserveNodeMaps: tsestreeOptions.preserveNodeMaps !== false,
+    programs: Array.isArray(tsestreeOptions.programs) ? tsestreeOptions.programs : null,
+    projects: /* @__PURE__ */ new Map(),
+    projectService:
+      tsestreeOptions.projectService ||
+      (tsestreeOptions.project &&
+        tsestreeOptions.projectService !== false &&
+        (void 0).env.TYPESCRIPT_ESLINT_PROJECT_SERVICE === 'true')
+        ? populateProjectService(tsestreeOptions.projectService, {
+            jsDocParsingMode,
+            tsconfigRootDir,
+          })
+        : void 0,
+    setExternalModuleIndicator:
+      tsestreeOptions.sourceType === 'module' ||
+      (tsestreeOptions.sourceType == null && extension === ts.Extension.Mjs) ||
+      (tsestreeOptions.sourceType == null && extension === ts.Extension.Mts)
+        ? (file) => {
+            file.externalModuleIndicator = true;
+          }
+        : void 0,
+    singleRun,
+    suppressDeprecatedPropertyWarnings: tsestreeOptions.suppressDeprecatedPropertyWarnings ?? true,
+    tokens: tsestreeOptions.tokens === true ? [] : null,
+    tsconfigMatchCache:
+      TSCONFIG_MATCH_CACHE ??
+      (TSCONFIG_MATCH_CACHE = new ExpiringCache(
+        singleRun
+          ? 'Infinity'
+          : (tsestreeOptions.cacheLifetime?.glob ?? DEFAULT_TSCONFIG_CACHE_DURATION_SECONDS),
+      )),
+    tsconfigRootDir,
+  };
+  if (parseSettings.debugLevel.size > 0) {
+    const namespaces = [];
+    if (parseSettings.debugLevel.has('typescript-eslint')) {
+      namespaces.push('typescript-eslint:*');
+    }
+    if (
+      parseSettings.debugLevel.has('eslint') || // make sure we don't turn off the eslint debug if it was enabled via --debug
+      debug_12.default.enabled('eslint:*,-eslint:code-path')
+    ) {
+      namespaces.push('eslint:*,-eslint:code-path');
+    }
+    debug_12.default.enable(namespaces.join(','));
+  }
+  if (Array.isArray(tsestreeOptions.programs)) {
+    if (!tsestreeOptions.programs.length) {
+      throw new Error(
+        `You have set parserOptions.programs to an empty array. This will cause all files to not be found in existing programs. Either provide one or more existing TypeScript Program instances in the array, or remove the parserOptions.programs setting.`,
+      );
+    }
+    log2('parserOptions.programs was provided, so parserOptions.project will be ignored.');
+  }
+  if (!parseSettings.programs && !parseSettings.projectService) {
+    parseSettings.projects = true
+      ? /* @__PURE__ */ new Map()
+      : (0, resolveProjectList)({
+          cacheLifetime: tsestreeOptions.cacheLifetime,
+          project: (0, void 0)(parseSettings, tsestreeOptions.project),
+          projectFolderIgnoreList: tsestreeOptions.projectFolderIgnoreList,
+          singleRun: parseSettings.singleRun,
+          tsconfigRootDir,
+        });
+  }
+  if (
+    tsestreeOptions.jsDocParsingMode == null &&
+    parseSettings.projects.size === 0 &&
+    parseSettings.programs == null &&
+    parseSettings.projectService == null
+  ) {
+    parseSettings.jsDocParsingMode = JSDocParsingMode2.ParseNone;
+  }
+  (0, warnAboutTSVersion)(parseSettings, passedLoggerFn);
+  return parseSettings;
+}
+function enforceCodeString(code) {
+  return (0, isSourceFile2)(code) ? code.getFullText(code) : typeof code === 'string' ? code : String(code);
+}
+function getFileName(jsx) {
+  return jsx ? 'estree.tsx' : 'estree.ts';
+}
+function populateProjectService(optionsRaw, settings) {
+  const options = typeof optionsRaw === 'object' ? optionsRaw : {};
+  (0, validateDefaultProjectForFilesGlob)(options.allowDefaultProject);
+  TSSERVER_PROJECT_SERVICE ??
+    (TSSERVER_PROJECT_SERVICE = (0, project_service_1.createProjectService)({
+      options,
+      ...settings,
+    }));
+  return TSSERVER_PROJECT_SERVICE;
+}
+
+// node_modules/@typescript-eslint/typescript-estree/dist/parser.js
+var debug_13 = { default: debug_default };
+var log3 = (0, debug_13.default)('typescript-eslint:typescript-estree:parser');
+function parse(code, options) {
+  const { ast } = parseWithNodeMapsInternal(code, options, false);
+  return ast;
+}
+function parseWithNodeMapsInternal(code, options, shouldPreserveNodeMaps) {
+  const parseSettings = (0, createParseSettings)(code, options);
+  if (options?.errorOnTypeScriptSyntacticAndSemanticIssues) {
+    throw new Error(
+      `"errorOnTypeScriptSyntacticAndSemanticIssues" is only supported for parseAndGenerateServices()`,
+    );
+  }
+  const ast = (0, createSourceFile2)(parseSettings);
+  const { astMaps, estree } = (0, astConverter)(ast, parseSettings, shouldPreserveNodeMaps);
+  return {
+    ast: estree,
+    esTreeNodeToTSNodeMap: astMaps.esTreeNodeToTSNodeMap,
+    tsNodeToESTreeNodeMap: astMaps.tsNodeToESTreeNodeMap,
+  };
+}
+
+// src/common/parser-create-error.js
+function createError2(message, options) {
+  const error = new SyntaxError(
+    message + ' (' + options.loc.start.line + ':' + options.loc.start.column + ')',
+  );
+  return Object.assign(error, options);
+}
+var parser_create_error_default = createError2;
+
+// src/utils/try-combinations.js
+function tryCombinations(combinations) {
+  const errors = [];
+  for (const fn of combinations) {
+    try {
+      return fn();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw Object.assign(new Error('All combinations failed'), { errors });
+}
+var try_combinations_default = tryCombinations;
+
+// scripts/build/shims/method-find-last.js
+var arrayFindLast =
+  Array.prototype.findLast ??
+  function (callback) {
+    for (let index = this.length - 1; index >= 0; index--) {
+      const element = this[index];
+      if (callback(element, index, this)) {
+        return element;
+      }
+    }
+  };
+var findLast = createMethodShim('findLast', function () {
+  if (Array.isArray(this)) {
+    return arrayFindLast;
+  }
+});
+var method_find_last_default = findLast;
+
+// scripts/build/shims/method-at.js
+function stringOrArrayAt(index) {
+  return this[index < 0 ? this.length + index : index];
+}
+var at = createMethodShim('at', function () {
+  if (Array.isArray(this) || typeof this === 'string') {
+    return stringOrArrayAt;
+  }
+});
+var method_at_default = at;
+
+// src/language-js/loc.js
+function locStart(node) {
+  const start = node.range?.[0] ?? node.start;
+  if (false) {
+    throw new TypeError("Can't not locate node.");
+  }
+  const firstDecorator = (node.declaration?.decorators ?? node.decorators)?.[0];
+  if (firstDecorator) {
+    return Math.min(locStart(firstDecorator), start);
+  }
+  return start;
+}
+function locEnd(node) {
+  const end = node.range?.[1] ?? node.end;
+  if (false) {
+    throw new TypeError("Can't not locate node.");
+  }
+  return end;
+}
+
+// src/language-js/utils/create-type-check-function.js
+function createTypeCheckFunction(typesArray) {
+  const types = new Set(typesArray);
+  if (false) {
+    noop_default(typesArray.length, types.size, "'typesArray' should be unique.");
+  }
+  return (node) => types.has(node?.type);
+}
+var create_type_check_function_default = createTypeCheckFunction;
+
+// src/language-js/utils/is-block-comment.js
+var isBlockComment = create_type_check_function_default([
+  'Block',
+  'CommentBlock',
+  // `meriyah`
+  'MultiLine',
+]);
+var is_block_comment_default = isBlockComment;
+
+// src/language-js/utils/is-line-comment.js
+var isLineComment = create_type_check_function_default([
+  'Line',
+  'CommentLine',
+  // `meriyah` has `SingleLine`, `HashbangComment`, `HTMLOpen`, and `HTMLClose`
+  'SingleLine',
+  'HashbangComment',
+  'HTMLOpen',
+  'HTMLClose',
+  // `espree`, and `oxc`(with `{astType: 'ts'}`)
+  'Hashbang',
+  // `babel` and `flow` hashbang
+  'InterpreterDirective',
+]);
+var is_line_comment_default = isLineComment;
+
+// src/language-js/utils/is-type-cast-comment.js
+var cache = /* @__PURE__ */ new WeakMap();
+function isTypeCastComment(comment) {
+  if (!cache.has(comment)) {
+    cache.set(
+      comment,
+      is_block_comment_default(comment) &&
+        comment.value[0] === '*' && // TypeScript expects the type to be enclosed in curly brackets, however
+        // Closure Compiler accepts types in parens and even without any delimiters at all.
+        // That's why we just search for "@type" and "@satisfies".
+        /@(?:type|satisfies)\b/u.test(comment.value),
+    );
+  }
+  return cache.get(comment);
+}
+var is_type_cast_comment_default = isTypeCastComment;
+
+// src/language-js/utils/is-indentable-block-comment.js
+function isIndentableBlockCommentInternal(comment) {
+  if (!is_block_comment_default(comment)) {
+    return false;
+  }
+  const lines = `*${comment.value}*`.split('\n');
+  return lines.length > 1 && lines.every((line) => line.trimStart()[0] === '*');
+}
+var cache2 = /* @__PURE__ */ new WeakMap();
+function isIndentableBlockComment(comment) {
+  if (!cache2.has(comment)) {
+    cache2.set(comment, isIndentableBlockCommentInternal(comment));
+  }
+  return cache2.get(comment);
+}
+var is_indentable_block_comment_default = isIndentableBlockComment;
+
+// src/language-js/parse/postprocess/merge-nestled-jsdoc-comments.js
+function mergeNestledJsdocComments(comments) {
+  if (comments.length < 2) {
+    return;
+  }
+  let followingComment;
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const comment = comments[i];
+    if (
+      followingComment &&
+      locEnd(comment) === locStart(followingComment) &&
+      is_indentable_block_comment_default(comment) &&
+      is_indentable_block_comment_default(followingComment)
+    ) {
+      comments.splice(i + 1, 1);
+      comment.value += '*//*' + followingComment.value;
+      comment.range = [locStart(comment), locEnd(followingComment)];
+    }
+    if (!is_line_comment_default(comment) && !is_block_comment_default(comment)) {
+      throw new TypeError(`Unknown comment type: "${comment.type}".`);
+    }
+    followingComment = comment;
+  }
+}
+var merge_nestled_jsdoc_comments_default = mergeNestledJsdocComments;
+
+// node_modules/to-fast-properties/index.js
+var fastProto = null;
+function FastObject(object) {
+  if (fastProto !== null && typeof fastProto.property) {
+    const result = fastProto;
+    fastProto = FastObject.prototype = null;
+    return result;
+  }
+  fastProto = FastObject.prototype = object == null ? /* @__PURE__ */ Object.create(null) : object;
+  return new FastObject();
+}
+var inlineCacheCutoff = 10;
+for (let index = 0; index <= inlineCacheCutoff; index++) {
+  FastObject();
+}
+function toFastproperties(object) {
+  return FastObject(object);
+}
+
+// src/utils/create-get-visitor-keys.js
+function createGetVisitorKeys(visitorKeys, typeProperty = 'type') {
+  toFastproperties(visitorKeys);
+  function getVisitorKeys2(node) {
+    const type = node[typeProperty];
+    if (false) {
+      throw new Error(`Can't get node type, you must pass the wrong typeProperty '${typeProperty}'`);
+    }
+    const keys = visitorKeys[type];
+    if (!Array.isArray(keys)) {
+      throw Object.assign(new Error(`Missing visitor keys for '${type}'.`), {
+        node,
+      });
+    }
+    return keys;
+  }
+  return getVisitorKeys2;
+}
+var create_get_visitor_keys_default = createGetVisitorKeys;
+
+// src/language-js/traverse/visitor-keys.evaluate.js
+var visitor_keys_evaluate_default = {
+  AccessorProperty: ['decorators', 'key', 'typeAnnotation', 'value'],
+  AnyTypeAnnotation: [],
+  ArgumentPlaceholder: [],
+  ArrayExpression: ['elements'],
+  ArrayPattern: ['elements', 'typeAnnotation', 'decorators'],
+  ArrayTypeAnnotation: ['elementType'],
+  ArrowFunctionExpression: ['typeParameters', 'params', 'predicate', 'returnType', 'body'],
+  AsConstExpression: ['expression'],
+  AsExpression: ['expression', 'typeAnnotation'],
+  AssignmentExpression: ['left', 'right'],
+  AssignmentPattern: ['left', 'right', 'decorators', 'typeAnnotation'],
+  AwaitExpression: ['argument'],
+  BigIntLiteral: [],
+  BigIntLiteralTypeAnnotation: [],
+  BigIntTypeAnnotation: [],
+  BinaryExpression: ['left', 'right'],
+  BindExpression: ['object', 'callee'],
+  BlockStatement: ['directives', 'body'],
+  BooleanLiteral: [],
+  BooleanLiteralTypeAnnotation: [],
+  BooleanTypeAnnotation: [],
+  BreakStatement: ['label'],
+  CallExpression: ['callee', 'typeArguments', 'arguments'],
+  CatchClause: ['param', 'body'],
+  ChainExpression: ['expression'],
+  ClassAccessorProperty: ['decorators', 'key', 'typeAnnotation', 'value'],
+  ClassBody: ['body'],
+  ClassDeclaration: [
+    'decorators',
+    'id',
+    'typeParameters',
+    'superClass',
+    'superTypeArguments',
+    'mixins',
+    'implements',
+    'body',
+    'superTypeParameters',
+  ],
+  ClassExpression: [
+    'decorators',
+    'id',
+    'typeParameters',
+    'superClass',
+    'superTypeArguments',
+    'mixins',
+    'implements',
+    'body',
+    'superTypeParameters',
+  ],
+  ClassImplements: ['id', 'typeParameters'],
+  ClassMethod: ['decorators', 'key', 'typeParameters', 'params', 'returnType', 'body'],
+  ClassPrivateMethod: ['decorators', 'key', 'typeParameters', 'params', 'returnType', 'body'],
+  ClassPrivateProperty: ['decorators', 'variance', 'key', 'typeAnnotation', 'value'],
+  ClassProperty: ['decorators', 'variance', 'key', 'typeAnnotation', 'value'],
+  ComponentDeclaration: ['id', 'params', 'body', 'typeParameters', 'rendersType'],
+  ComponentParameter: ['name', 'local'],
+  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'rendersType'],
+  ComponentTypeParameter: ['name', 'typeAnnotation'],
+  ConditionalExpression: ['test', 'consequent', 'alternate'],
+  ConditionalTypeAnnotation: ['checkType', 'extendsType', 'trueType', 'falseType'],
+  ContinueStatement: ['label'],
+  DebuggerStatement: [],
+  DeclareClass: ['id', 'typeParameters', 'extends', 'mixins', 'implements', 'body'],
+  DeclareComponent: ['id', 'params', 'rest', 'typeParameters', 'rendersType'],
+  DeclaredPredicate: ['value'],
+  DeclareEnum: ['id', 'body'],
+  DeclareExportAllDeclaration: ['source', 'attributes'],
+  DeclareExportDeclaration: ['declaration', 'specifiers', 'source', 'attributes'],
+  DeclareFunction: ['id', 'predicate'],
+  DeclareHook: ['id'],
+  DeclareInterface: ['id', 'typeParameters', 'extends', 'body'],
+  DeclareModule: ['id', 'body'],
+  DeclareModuleExports: ['typeAnnotation'],
+  DeclareNamespace: ['id', 'body'],
+  DeclareOpaqueType: ['id', 'typeParameters', 'supertype', 'lowerBound', 'upperBound'],
+  DeclareTypeAlias: ['id', 'typeParameters', 'right'],
+  DeclareVariable: ['id'],
+  Decorator: ['expression'],
+  Directive: ['value'],
+  DirectiveLiteral: [],
+  DoExpression: ['body'],
+  DoWhileStatement: ['body', 'test'],
+  EmptyStatement: [],
+  EmptyTypeAnnotation: [],
+  EnumBigIntBody: ['members'],
+  EnumBigIntMember: ['id', 'init'],
+  EnumBooleanBody: ['members'],
+  EnumBooleanMember: ['id', 'init'],
+  EnumDeclaration: ['id', 'body'],
+  EnumDefaultedMember: ['id'],
+  EnumNumberBody: ['members'],
+  EnumNumberMember: ['id', 'init'],
+  EnumStringBody: ['members'],
+  EnumStringMember: ['id', 'init'],
+  EnumSymbolBody: ['members'],
+  ExistsTypeAnnotation: [],
+  ExperimentalRestProperty: ['argument'],
+  ExperimentalSpreadProperty: ['argument'],
+  ExportAllDeclaration: ['source', 'attributes', 'exported'],
+  ExportDefaultDeclaration: ['declaration'],
+  ExportDefaultSpecifier: ['exported'],
+  ExportNamedDeclaration: ['declaration', 'specifiers', 'source', 'attributes'],
+  ExportNamespaceSpecifier: ['exported'],
+  ExportSpecifier: ['local', 'exported'],
+  ExpressionStatement: ['expression'],
+  File: ['program'],
+  ForInStatement: ['left', 'right', 'body'],
+  ForOfStatement: ['left', 'right', 'body'],
+  ForStatement: ['init', 'test', 'update', 'body'],
+  FunctionDeclaration: ['id', 'typeParameters', 'params', 'predicate', 'returnType', 'body'],
+  FunctionExpression: ['id', 'typeParameters', 'params', 'predicate', 'returnType', 'body'],
+  FunctionTypeAnnotation: ['typeParameters', 'this', 'params', 'rest', 'returnType'],
+  FunctionTypeParam: ['name', 'typeAnnotation'],
+  GenericTypeAnnotation: ['id', 'typeParameters'],
+  HookDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType'],
+  HookTypeAnnotation: ['params', 'returnType', 'rest', 'typeParameters'],
+  Identifier: ['typeAnnotation', 'decorators'],
+  IfStatement: ['test', 'consequent', 'alternate'],
+  ImportAttribute: ['key', 'value'],
+  ImportDeclaration: ['specifiers', 'source', 'attributes'],
+  ImportDefaultSpecifier: ['local'],
+  ImportExpression: ['source', 'options'],
+  ImportNamespaceSpecifier: ['local'],
+  ImportSpecifier: ['imported', 'local'],
+  IndexedAccessType: ['objectType', 'indexType'],
+  InferredPredicate: [],
+  InferTypeAnnotation: ['typeParameter'],
+  InterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
+  InterfaceExtends: ['id', 'typeParameters'],
+  InterfaceTypeAnnotation: ['extends', 'body'],
+  InterpreterDirective: [],
+  IntersectionTypeAnnotation: ['types'],
+  JsExpressionRoot: ['node'],
+  JsonRoot: ['node'],
+  JSXAttribute: ['name', 'value'],
+  JSXClosingElement: ['name'],
+  JSXClosingFragment: [],
+  JSXElement: ['openingElement', 'children', 'closingElement'],
+  JSXEmptyExpression: [],
+  JSXExpressionContainer: ['expression'],
+  JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+  JSXIdentifier: [],
+  JSXMemberExpression: ['object', 'property'],
+  JSXNamespacedName: ['namespace', 'name'],
+  JSXOpeningElement: ['name', 'typeArguments', 'attributes'],
+  JSXOpeningFragment: [],
+  JSXSpreadAttribute: ['argument'],
+  JSXSpreadChild: ['expression'],
+  JSXText: [],
+  KeyofTypeAnnotation: ['argument'],
+  LabeledStatement: ['label', 'body'],
+  Literal: [],
+  LogicalExpression: ['left', 'right'],
+  MatchArrayPattern: ['elements', 'rest'],
+  MatchAsPattern: ['pattern', 'target'],
+  MatchBindingPattern: ['id'],
+  MatchExpression: ['argument', 'cases'],
+  MatchExpressionCase: ['pattern', 'body', 'guard'],
+  MatchIdentifierPattern: ['id'],
+  MatchLiteralPattern: ['literal'],
+  MatchMemberPattern: ['base', 'property'],
+  MatchObjectPattern: ['properties', 'rest'],
+  MatchObjectPatternProperty: ['key', 'pattern'],
+  MatchOrPattern: ['patterns'],
+  MatchRestPattern: ['argument'],
+  MatchStatement: ['argument', 'cases'],
+  MatchStatementCase: ['pattern', 'body', 'guard'],
+  MatchUnaryPattern: ['argument'],
+  MatchWildcardPattern: [],
+  MemberExpression: ['object', 'property'],
+  MetaProperty: ['meta', 'property'],
+  MethodDefinition: ['decorators', 'key', 'value'],
+  MixedTypeAnnotation: [],
+  ModuleExpression: ['body'],
+  NeverTypeAnnotation: [],
+  NewExpression: ['callee', 'typeArguments', 'arguments'],
+  NGChainedExpression: ['expressions'],
+  NGEmptyExpression: [],
+  NGMicrosyntax: ['body'],
+  NGMicrosyntaxAs: ['key', 'alias'],
+  NGMicrosyntaxExpression: ['expression', 'alias'],
+  NGMicrosyntaxKey: [],
+  NGMicrosyntaxKeyedExpression: ['key', 'expression'],
+  NGMicrosyntaxLet: ['key', 'value'],
+  NGPipeExpression: ['left', 'right', 'arguments'],
+  NGRoot: ['node'],
+  NullableTypeAnnotation: ['typeAnnotation'],
+  NullLiteral: [],
+  NullLiteralTypeAnnotation: [],
+  NumberLiteralTypeAnnotation: [],
+  NumberTypeAnnotation: [],
+  NumericLiteral: [],
+  ObjectExpression: ['properties'],
+  ObjectMethod: ['decorators', 'key', 'typeParameters', 'params', 'returnType', 'body'],
+  ObjectPattern: ['decorators', 'properties', 'typeAnnotation'],
+  ObjectProperty: ['decorators', 'key', 'value'],
+  ObjectTypeAnnotation: ['properties', 'indexers', 'callProperties', 'internalSlots'],
+  ObjectTypeCallProperty: ['value'],
+  ObjectTypeIndexer: ['variance', 'id', 'key', 'value'],
+  ObjectTypeInternalSlot: ['id', 'value'],
+  ObjectTypeMappedTypeProperty: ['keyTparam', 'propType', 'sourceType', 'variance'],
+  ObjectTypeProperty: ['key', 'value', 'variance'],
+  ObjectTypeSpreadProperty: ['argument'],
+  OpaqueType: ['id', 'typeParameters', 'supertype', 'impltype', 'lowerBound', 'upperBound'],
+  OptionalCallExpression: ['callee', 'typeArguments', 'arguments'],
+  OptionalIndexedAccessType: ['objectType', 'indexType'],
+  OptionalMemberExpression: ['object', 'property'],
+  ParenthesizedExpression: ['expression'],
+  PipelineBareFunction: ['callee'],
+  PipelinePrimaryTopicReference: [],
+  PipelineTopicExpression: ['expression'],
+  Placeholder: [],
+  PrivateIdentifier: [],
+  PrivateName: ['id'],
+  Program: ['directives', 'body'],
+  Property: ['key', 'value'],
+  PropertyDefinition: ['decorators', 'key', 'typeAnnotation', 'value', 'variance'],
+  QualifiedTypeIdentifier: ['qualification', 'id'],
+  QualifiedTypeofIdentifier: ['qualification', 'id'],
+  RegExpLiteral: [],
+  RestElement: ['argument', 'typeAnnotation', 'decorators'],
+  ReturnStatement: ['argument'],
+  SatisfiesExpression: ['expression', 'typeAnnotation'],
+  SequenceExpression: ['expressions'],
+  SpreadElement: ['argument'],
+  StaticBlock: ['body'],
+  StringLiteral: [],
+  StringLiteralTypeAnnotation: [],
+  StringTypeAnnotation: [],
+  Super: [],
+  SwitchCase: ['test', 'consequent'],
+  SwitchStatement: ['discriminant', 'cases'],
+  SymbolTypeAnnotation: [],
+  TaggedTemplateExpression: ['tag', 'typeArguments', 'quasi'],
+  TemplateElement: [],
+  TemplateLiteral: ['quasis', 'expressions'],
+  ThisExpression: [],
+  ThisTypeAnnotation: [],
+  ThrowStatement: ['argument'],
+  TopicReference: [],
+  TryStatement: ['block', 'handler', 'finalizer'],
+  TSAbstractAccessorProperty: ['decorators', 'key', 'typeAnnotation'],
+  TSAbstractKeyword: [],
+  TSAbstractMethodDefinition: ['key', 'value'],
+  TSAbstractPropertyDefinition: ['decorators', 'key', 'typeAnnotation'],
+  TSAnyKeyword: [],
+  TSArrayType: ['elementType'],
+  TSAsExpression: ['expression', 'typeAnnotation'],
+  TSAsyncKeyword: [],
+  TSBigIntKeyword: [],
+  TSBooleanKeyword: [],
+  TSCallSignatureDeclaration: ['typeParameters', 'params', 'returnType'],
+  TSClassImplements: ['expression', 'typeArguments'],
+  TSConditionalType: ['checkType', 'extendsType', 'trueType', 'falseType'],
+  TSConstructorType: ['typeParameters', 'params', 'returnType'],
+  TSConstructSignatureDeclaration: ['typeParameters', 'params', 'returnType'],
+  TSDeclareFunction: ['id', 'typeParameters', 'params', 'returnType', 'body'],
+  TSDeclareKeyword: [],
+  TSDeclareMethod: ['decorators', 'key', 'typeParameters', 'params', 'returnType'],
+  TSEmptyBodyFunctionExpression: ['id', 'typeParameters', 'params', 'returnType'],
+  TSEnumBody: ['members'],
+  TSEnumDeclaration: ['id', 'body'],
+  TSEnumMember: ['id', 'initializer'],
+  TSExportAssignment: ['expression'],
+  TSExportKeyword: [],
+  TSExternalModuleReference: ['expression'],
+  TSFunctionType: ['typeParameters', 'params', 'returnType'],
+  TSImportEqualsDeclaration: ['id', 'moduleReference'],
+  TSImportType: ['argument', 'options', 'qualifier', 'typeArguments'],
+  TSIndexedAccessType: ['objectType', 'indexType'],
+  TSIndexSignature: ['parameters', 'typeAnnotation'],
+  TSInferType: ['typeParameter'],
+  TSInstantiationExpression: ['expression', 'typeArguments'],
+  TSInterfaceBody: ['body'],
+  TSInterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
+  TSInterfaceHeritage: ['expression', 'typeArguments'],
+  TSIntersectionType: ['types'],
+  TSIntrinsicKeyword: [],
+  TSJSDocAllType: [],
+  TSJSDocNonNullableType: ['typeAnnotation'],
+  TSJSDocNullableType: ['typeAnnotation'],
+  TSJSDocUnknownType: [],
+  TSLiteralType: ['literal'],
+  TSMappedType: ['key', 'constraint', 'nameType', 'typeAnnotation'],
+  TSMethodSignature: ['key', 'typeParameters', 'params', 'returnType'],
+  TSModuleBlock: ['body'],
+  TSModuleDeclaration: ['id', 'body'],
+  TSNamedTupleMember: ['label', 'elementType'],
+  TSNamespaceExportDeclaration: ['id'],
+  TSNeverKeyword: [],
+  TSNonNullExpression: ['expression'],
+  TSNullKeyword: [],
+  TSNumberKeyword: [],
+  TSObjectKeyword: [],
+  TSOptionalType: ['typeAnnotation'],
+  TSParameterProperty: ['parameter', 'decorators'],
+  TSParenthesizedType: ['typeAnnotation'],
+  TSPrivateKeyword: [],
+  TSPropertySignature: ['key', 'typeAnnotation'],
+  TSProtectedKeyword: [],
+  TSPublicKeyword: [],
+  TSQualifiedName: ['left', 'right'],
+  TSReadonlyKeyword: [],
+  TSRestType: ['typeAnnotation'],
+  TSSatisfiesExpression: ['expression', 'typeAnnotation'],
+  TSStaticKeyword: [],
+  TSStringKeyword: [],
+  TSSymbolKeyword: [],
+  TSTemplateLiteralType: ['quasis', 'types'],
+  TSThisType: [],
+  TSTupleType: ['elementTypes'],
+  TSTypeAliasDeclaration: ['id', 'typeParameters', 'typeAnnotation'],
+  TSTypeAnnotation: ['typeAnnotation'],
+  TSTypeAssertion: ['typeAnnotation', 'expression'],
+  TSTypeLiteral: ['members'],
+  TSTypeOperator: ['typeAnnotation'],
+  TSTypeParameter: ['name', 'constraint', 'default'],
+  TSTypeParameterDeclaration: ['params'],
+  TSTypeParameterInstantiation: ['params'],
+  TSTypePredicate: ['parameterName', 'typeAnnotation'],
+  TSTypeQuery: ['exprName', 'typeArguments'],
+  TSTypeReference: ['typeName', 'typeArguments'],
+  TSUndefinedKeyword: [],
+  TSUnionType: ['types'],
+  TSUnknownKeyword: [],
+  TSVoidKeyword: [],
+  TupleTypeAnnotation: ['types', 'elementTypes'],
+  TupleTypeLabeledElement: ['label', 'elementType', 'variance'],
+  TupleTypeSpreadElement: ['label', 'typeAnnotation'],
+  TypeAlias: ['id', 'typeParameters', 'right'],
+  TypeAnnotation: ['typeAnnotation'],
+  TypeCastExpression: ['expression', 'typeAnnotation'],
+  TypeofTypeAnnotation: ['argument', 'typeArguments'],
+  TypeOperator: ['typeAnnotation'],
+  TypeParameter: ['bound', 'default', 'variance'],
+  TypeParameterDeclaration: ['params'],
+  TypeParameterInstantiation: ['params'],
+  TypePredicate: ['parameterName', 'typeAnnotation'],
+  UnaryExpression: ['argument'],
+  UndefinedTypeAnnotation: [],
+  UnionTypeAnnotation: ['types'],
+  UnknownTypeAnnotation: [],
+  UpdateExpression: ['argument'],
+  V8IntrinsicIdentifier: [],
+  VariableDeclaration: ['declarations'],
+  VariableDeclarator: ['id', 'init'],
+  Variance: [],
+  VoidPattern: [],
+  VoidTypeAnnotation: [],
+  WhileStatement: ['test', 'body'],
+  WithStatement: ['object', 'body'],
+  YieldExpression: ['argument'],
+};
+
+// src/language-js/traverse/get-visitor-keys.js
+var getVisitorKeys = create_get_visitor_keys_default(visitor_keys_evaluate_default);
+var get_visitor_keys_default = getVisitorKeys;
+
+// src/language-js/parse/postprocess/visit-node.js
+function visitNode(node, options) {
+  if (!(node !== null && typeof node === 'object')) {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      node[i] = visitNode(node[i], options);
+    }
+    return node;
+  }
+  if (options.onEnter) {
+    node = options.onEnter(node) || node;
+  }
+  const keys = get_visitor_keys_default(node);
+  for (let i = 0; i < keys.length; i++) {
+    node[keys[i]] = visitNode(node[keys[i]], options);
+  }
+  return options.onLeave(node) || node;
+}
+var visit_node_default = visitNode;
+
+// src/language-js/parse/postprocess/index.js
+var isNodeWithRaw = create_type_check_function_default([
+  // Babel
+  'RegExpLiteral',
+  'BigIntLiteral',
+  'NumericLiteral',
+  'StringLiteral',
+  // "NullLiteral",
+  // "BooleanLiteral",
+  'DirectiveLiteral',
+  // ESTree
+  'Literal',
+  'JSXText',
+  'TemplateElement',
+  // Flow
+  'StringLiteralTypeAnnotation',
+  'NumberLiteralTypeAnnotation',
+  'BigIntLiteralTypeAnnotation',
+]);
+function postprocess(ast, options) {
+  const { parser, text } = options;
+  const { comments } = ast;
+  const isOxcTs = parser === 'oxc' && options.oxcAstType === 'ts';
+  merge_nestled_jsdoc_comments_default(comments);
+  let typeCastCommentsEnds;
+  ast = visit_node_default(ast, {
+    onLeave(node) {
+      switch (node.type) {
+        case 'ParenthesizedExpression': {
+          const { expression } = node;
+          const start = locStart(node);
+          if (expression.type === 'TypeCastExpression') {
+            expression.range = [start, locEnd(node)];
+            return expression;
+          }
+          let keepTypeCast = false;
+          if (!isOxcTs) {
+            if (!typeCastCommentsEnds) {
+              typeCastCommentsEnds = [];
+              for (const comment of comments) {
+                if (is_type_cast_comment_default(comment)) {
+                  typeCastCommentsEnds.push(locEnd(comment));
+                }
+              }
+            }
+            const previousCommentEnd = method_find_last_default(
+              /* OPTIONAL_OBJECT: false */
+              0,
+              typeCastCommentsEnds,
+              (end) => end <= start,
+            );
+            keepTypeCast =
+              previousCommentEnd && // check that there are only white spaces between the comment and the parenthesis
+              text.slice(previousCommentEnd, start).trim().length === 0;
+          }
+          if (!keepTypeCast) {
+            expression.extra = {
+              ...expression.extra,
+              parenthesized: true,
+            };
+            return expression;
+          }
+          break;
+        }
+        case 'LogicalExpression':
+          if (isUnbalancedLogicalTree(node)) {
+            return rebalanceLogicalTree(node);
+          }
+          break;
+        // This happens when use `oxc-parser` to parse `` `${foo satisfies bar}`; ``
+        // https://github.com/oxc-project/oxc/issues/11313
+        case 'TemplateLiteral':
+          if (node.expressions.length !== node.quasis.length - 1) {
+            throw new Error('Malformed template literal.');
+          }
+          break;
+        case 'TemplateElement':
+          if (
+            parser === 'flow' ||
+            parser === 'hermes' ||
+            parser === 'espree' ||
+            parser === 'typescript' ||
+            isOxcTs
+          ) {
+            const start = locStart(node) + 1;
+            const end = locEnd(node) - (node.tail ? 1 : 2);
+            node.range = [start, end];
+          }
+          break;
+        // fix unexpected locEnd caused by --no-semi style
+        case 'VariableDeclaration': {
+          const lastDeclaration = method_at_default(
+            /* OPTIONAL_OBJECT: false */
+            0,
+            node.declarations,
+            -1,
+          );
+          if (lastDeclaration?.init && text[locEnd(lastDeclaration)] !== ';') {
+            node.range = [locStart(node), locEnd(lastDeclaration)];
+          }
+          break;
+        }
+        // remove redundant TypeScript nodes
+        case 'TSParenthesizedType':
+          return node.typeAnnotation;
+        // For hack-style pipeline
+        case 'TopicReference':
+          ast.extra = {
+            ...ast.extra,
+            __isUsingHackPipeline: true,
+          };
+          break;
+        // In Flow parser, it doesn't generate union/intersection types for single type
+        case 'TSUnionType':
+        case 'TSIntersectionType':
+          if (node.types.length === 1) {
+            return node.types[0];
+          }
+          break;
+        // https://github.com/facebook/hermes/issues/1712
+        case 'ImportExpression':
+          if (parser === 'hermes' && node.attributes && !node.options) {
+            node.options = node.attributes;
+          }
+          break;
+      }
+      if (false) {
+        assertRaw(node, text);
+      }
+    },
+  });
+  const program = ast.type === 'File' ? ast.program : ast;
+  if (program.interpreter) {
+    comments.unshift(program.interpreter);
+    delete program.interpreter;
+  }
+  if (isOxcTs && ast.hashbang) {
+    comments.unshift(ast.hashbang);
+    delete ast.hashbang;
+  }
+  if (false) {
+    assertComments(comments, text);
+  }
+  if (ast.type === 'Program') {
+    ast.range = [0, text.length];
+  }
+  return ast;
+}
+function isUnbalancedLogicalTree(node) {
+  return (
+    node.type === 'LogicalExpression' &&
+    node.right.type === 'LogicalExpression' &&
+    node.operator === node.right.operator
+  );
+}
+function rebalanceLogicalTree(node) {
+  if (!isUnbalancedLogicalTree(node)) {
+    return node;
+  }
+  return rebalanceLogicalTree({
+    type: 'LogicalExpression',
+    operator: node.operator,
+    left: rebalanceLogicalTree({
+      type: 'LogicalExpression',
+      operator: node.operator,
+      left: node.left,
+      right: node.right.left,
+      range: [locStart(node.left), locEnd(node.right.left)],
+    }),
+    right: node.right.right,
+    range: [locStart(node), locEnd(node)],
+  });
+}
+var postprocess_default = postprocess;
+
+// node_modules/jest-docblock/build/index.js
+var commentEndRe = /\*\/$/;
+var commentStartRe = /^\/\*\*?/;
+var docblockRe = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/;
+var lineCommentRe = /(^|\s+)\/\/([^\n\r]*)/g;
+var ltrimNewlineRe = /^(\r?\n)+/;
+var multilineRe = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g;
+var propertyRe = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g;
+var stringStartRe = /(\r?\n|^) *\* ?/g;
+var STRING_ARRAY = [];
+function extract(contents) {
+  const match = contents.match(docblockRe);
+  return match ? match[0].trimStart() : '';
+}
+function parseWithComments(docblock) {
+  const line = '\n';
+  docblock = method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
+    docblock.replace(commentStartRe, '').replace(commentEndRe, ''),
+    stringStartRe,
+    '$1',
+  );
+  let prev = '';
+  while (prev !== docblock) {
+    prev = docblock;
+    docblock = method_replace_all_default(
+      /* OPTIONAL_OBJECT: false */
+      0,
+      docblock,
+      multilineRe,
+      `${line}$1 $2${line}`,
+    );
+  }
+  docblock = docblock.replace(ltrimNewlineRe, '').trimEnd();
+  const result = /* @__PURE__ */ Object.create(null);
+  const comments = method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
+    docblock,
+    propertyRe,
+    '',
+  )
+    .replace(ltrimNewlineRe, '')
+    .trimEnd();
+  let match;
+  while ((match = propertyRe.exec(docblock))) {
+    const nextPragma = method_replace_all_default(
+      /* OPTIONAL_OBJECT: false */
+      0,
+      match[2],
+      lineCommentRe,
+      '',
+    );
+    if (typeof result[match[1]] === 'string' || Array.isArray(result[match[1]])) {
+      const resultElement = result[match[1]];
+      result[match[1]] = [
+        ...STRING_ARRAY,
+        ...(Array.isArray(resultElement) ? resultElement : [resultElement]),
+        nextPragma,
+      ];
+    } else {
+      result[match[1]] = nextPragma;
+    }
+  }
+  return {
+    comments,
+    pragmas: result,
+  };
+}
+
+// src/utils/pragma/pragma.evaluate.js
+var FORMAT_IGNORE_PRAGMAS = ['noformat', 'noprettier'];
+var FORMAT_PRAGMAS = ['format', 'prettier'];
+
+// src/language-js/utils/get-shebang.js
+function getShebang2(text) {
+  if (!text.startsWith('#!')) {
+    return '';
+  }
+  const index = text.indexOf('\n');
+  if (index === -1) {
+    return text;
+  }
+  return text.slice(0, index);
+}
+var get_shebang_default = getShebang2;
+
+// src/language-js/pragma.js
+function parseDocBlock(text) {
+  const shebang = get_shebang_default(text);
+  if (shebang) {
+    text = text.slice(shebang.length + 1);
+  }
+  const docBlock = extract(text);
+  const { pragmas, comments } = parseWithComments(docBlock);
+  return {
+    shebang,
+    text,
+    pragmas,
+    comments,
+  };
+}
+function hasPragma(text) {
+  const { pragmas } = parseDocBlock(text);
+  return FORMAT_PRAGMAS.some((pragma) => Object.prototype.hasOwnProperty.call(pragmas, pragma));
+}
+function hasIgnorePragma(text) {
+  const { pragmas } = parseDocBlock(text);
+  return FORMAT_IGNORE_PRAGMAS.some((pragma) => Object.prototype.hasOwnProperty.call(pragmas, pragma));
+}
+
+// src/language-js/parse/utils/create-parser.js
+function createParser(options) {
+  options = typeof options === 'function' ? { parse: options } : options;
+  return {
+    astFormat: 'estree',
+    hasPragma,
+    hasIgnorePragma,
+    locStart,
+    locEnd,
+    ...options,
+  };
+}
+var create_parser_default = createParser;
+
+// src/language-js/parse/utils/jsx-regexp.evaluate.js
+var jsx_regexp_evaluate_default = /^[^"'`]*<\/|^[^/]{2}.*\/>/mu;
+
+// src/language-js/parse/utils/replace-hashbang.js
+function replaceHashbang(text) {
+  if (text.charAt(0) === '#' && text.charAt(1) === '!') {
+    return '//' + text.slice(2);
+  }
+  return text;
+}
+var replace_hashbang_default = replaceHashbang;
+
+// src/language-js/parse/utils/source-types.js
+var SOURCE_TYPE_MODULE = 'module';
+var SOURCE_TYPE_SCRIPT = 'script';
+var SOURCE_TYPE_COMBINATIONS = [SOURCE_TYPE_MODULE, SOURCE_TYPE_SCRIPT];
+function getSourceType(filepath) {
+  if (typeof filepath !== 'string') {
+    return;
+  }
+  filepath = filepath.toLowerCase();
+  if (/\.(?:mjs|mts)$/iu.test(filepath)) {
+    return SOURCE_TYPE_MODULE;
+  }
+  if (/\.(?:cjs|cts)$/iu.test(filepath)) {
+    return SOURCE_TYPE_SCRIPT;
+  }
+}
+
+// src/language-js/parse/typescript.js
+var baseParseOptions = {
+  // `jest@<=26.4.2` rely on `loc`
+  // https://github.com/facebook/jest/issues/10444
+  // Set `loc` and `range` to `true` also prevent AST traverse
+  // https://github.com/typescript-eslint/typescript-eslint/blob/733b3598c17d3a712cf6f043115587f724dbe3ef/packages/typescript-estree/src/ast-converter.ts#L38
+  loc: true,
+  range: true,
+  comment: true,
+  tokens: false,
+  loggerFn: false,
+  project: false,
+  jsDocParsingMode: 'none',
+  // TODO: Use new properties when update printer
+  suppressDeprecatedPropertyWarnings: true,
+};
+function createParseError(error) {
+  const { message, location } = error;
+  if (!location) {
+    return error;
+  }
+  const { start, end } = location;
+  return parser_create_error_default(message, {
+    loc: {
+      start: { line: start.line, column: start.column + 1 },
+      end: { line: end.line, column: end.column + 1 },
+    },
+    cause: error,
+  });
+}
+var isKnownFileType = (filepath) => filepath && /\.(?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$/iu.test(filepath);
+function getParseOptionsCombinations(text, filepath) {
+  let combinations = [{ ...baseParseOptions, filePath: filepath }];
+  const sourceType = getSourceType(filepath);
+  if (sourceType) {
+    combinations = combinations.map((parseOptions) => ({
+      ...parseOptions,
+      sourceType,
+    }));
+  } else {
+    combinations = SOURCE_TYPE_COMBINATIONS.flatMap((sourceType2) =>
+      combinations.map((parseOptions) => ({
+        ...parseOptions,
+        sourceType: sourceType2,
+      })),
+    );
+  }
+  if (isKnownFileType(filepath)) {
+    return combinations;
+  }
+  const shouldEnableJsx = jsx_regexp_evaluate_default.test(text);
+  return [shouldEnableJsx, !shouldEnableJsx].flatMap((jsx) =>
+    combinations.map((parseOptions) => ({ ...parseOptions, jsx })),
+  );
+}
+function parse2(text, options) {
+  let filepath = options?.filepath;
+  if (typeof filepath !== 'string') {
+    filepath = void 0;
+  }
+  const textToParse = replace_hashbang_default(text);
+  const parseOptionsCombinations = getParseOptionsCombinations(text, filepath);
+  let ast;
+  try {
+    ast = try_combinations_default(
+      parseOptionsCombinations.map((parseOptions) => () => parse(textToParse, parseOptions)),
+    );
+  } catch ({
+    // @ts-expect-error -- expected
+    errors: [
+      // Suppose our guess is correct, throw the first error
+      error,
+    ],
+  }) {
+    throw createParseError(error);
+  }
+  return postprocess_default(ast, { parser: 'typescript', text });
+}
+
+var typescript = create_parser_default(parse2);
+export const parsers = { typescript };