@typescript-eslint/typescript-estree 8.0.0-alpha.9 → 8.0.0

package/dist/convert.js

@@ -22,14 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Converter_instances, _Converter_checkModifiers, _Converter_throwUnlessAllowInvalidAST, _Converter_withDeprecatedAliasGetter, _Converter_withDeprecatedGetter, _Converter_throwError, _Converter_checkForStatementDeclaration;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Converter = exports.convertError = void 0;
+exports.Converter = void 0;
+exports.convertError = convertError;
 // There's lots of funny stuff due to the typing of ts.Node
 /* eslint-disable @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access */
 const ts = __importStar(require("typescript"));
@@ -45,8 +40,12 @@ const SyntaxKind = ts.SyntaxKind;
 function convertError(error) {
     return (0, node_utils_1.createError)(('message' in error && error.message) || error.messageText, error.file, error.start);
 }
-exports.convertError = convertError;
 class Converter {
+    ast;
+    options;
+    esTreeNodeToTSNodeMap = new WeakMap();
+    tsNodeToESTreeNodeMap = new WeakMap();
+    allowPattern = false;
     /**
      * Converts a TypeScript node into an ESTree node
      * @param ast the full TypeScript AST
@@ -54,10 +53,6 @@ class Converter {
      * @returns the converted ESTreeNode
      */
     constructor(ast, options) {
-        _Converter_instances.add(this);
-        this.esTreeNodeToTSNodeMap = new WeakMap();
-        this.tsNodeToESTreeNodeMap = new WeakMap();
-        this.allowPattern = false;
         this.ast = ast;
         this.options = { ...options };
     }
@@ -84,7 +79,7 @@ class Converter {
         if (!node) {
             return null;
         }
-        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_checkModifiers).call(this, node);
+        this.#checkModifiers(node);
         const pattern = this.allowPattern;
         if (allowPattern !== undefined) {
             this.allowPattern = allowPattern;
@@ -130,7 +125,7 @@ class Converter {
             const isDeclare = 'declare' in result && result.declare;
             return this.createNode(node, 
             // @ts-expect-error - TODO, narrow the types here
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+            this.#withDeprecatedAliasGetter({
                 type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration,
                 declaration: result,
                 specifiers: [],
@@ -325,7 +320,7 @@ class Converter {
      */
     deeplyCopy(node) {
         if (node.kind === ts.SyntaxKind.JSDocFunctionType) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node, 'JSDoc types can only be used inside documentation comments.');
+            this.#throwError(node, 'JSDoc types can only be used inside documentation comments.');
         }
         const customType = `TS${SyntaxKind[node.kind]}`;
         /**
@@ -349,7 +344,6 @@ class Converter {
                 node.typeArguments && 'pos' in node.typeArguments
                     ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
                     : null;
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, result, 'typeParameters', 'typeArguments');
         }
         if ('typeParameters' in node) {
             result.typeParameters =
@@ -465,7 +459,7 @@ class Converter {
                 if (node.name.kind === SyntaxKind.PrivateIdentifier) {
                     // This is one of the few times where TS explicitly errors, and doesn't even gracefully handle the syntax.
                     // So we shouldn't ever get into this state to begin with.
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node.name, 'Non-private identifier expected.');
+                    this.#throwError(node.name, 'Non-private identifier expected.');
                 }
                 result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXMemberExpression,
@@ -528,11 +522,11 @@ class Converter {
     }
     assertModuleSpecifier(node, allowNull) {
         if (!allowNull && node.moduleSpecifier == null) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node, 'Module specifier must be a string literal.');
+            this.#throwUnlessAllowInvalidAST(node, 'Module specifier must be a string literal.');
         }
         if (node.moduleSpecifier &&
             node.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.moduleSpecifier, 'Module specifier must be a string literal.');
+            this.#throwUnlessAllowInvalidAST(node.moduleSpecifier, 'Module specifier must be a string literal.');
         }
     }
     /**
@@ -620,7 +614,7 @@ class Converter {
                 });
             case SyntaxKind.SwitchStatement:
                 if (node.caseBlock.clauses.filter(switchCase => switchCase.kind === SyntaxKind.DefaultClause).length > 1) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
+                    this.#throwError(node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.SwitchStatement,
@@ -640,7 +634,7 @@ class Converter {
             // Exceptions
             case SyntaxKind.ThrowStatement:
                 if (node.expression.end === node.expression.pos) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node, 'A throw statement must throw an expression.');
+                    this.#throwUnlessAllowInvalidAST(node, 'A throw statement must throw an expression.');
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ThrowStatement,
@@ -655,7 +649,7 @@ class Converter {
                 });
             case SyntaxKind.CatchClause:
                 if (node.variableDeclaration?.initializer) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node.variableDeclaration.initializer, 'Catch clause variable cannot have an initializer.');
+                    this.#throwError(node.variableDeclaration.initializer, 'Catch clause variable cannot have an initializer.');
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.CatchClause,
@@ -690,7 +684,7 @@ class Converter {
                     body: this.convertChild(node.statement),
                 });
             case SyntaxKind.ForInStatement:
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_checkForStatementDeclaration).call(this, node.initializer);
+                this.#checkForStatementDeclaration(node.initializer);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ForInStatement,
                     left: this.convertPattern(node.initializer),
@@ -709,15 +703,32 @@ class Converter {
             // Declarations
             case SyntaxKind.FunctionDeclaration: {
                 const isDeclare = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node);
+                const isAsync = (0, node_utils_1.hasModifier)(SyntaxKind.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, {
-                    type: isDeclare || !node.body
+                    // declare implies no body due to the invariant above
+                    type: !node.body
                         ? ts_estree_1.AST_NODE_TYPES.TSDeclareFunction
                         : ts_estree_1.AST_NODE_TYPES.FunctionDeclaration,
-                    async: (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node),
+                    async: isAsync,
                     body: this.convertChild(node.body) || undefined,
                     declare: isDeclare,
                     expression: false,
-                    generator: !!node.asteriskToken,
+                    generator: isGenerator,
                     id: this.convertChild(node.name),
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
@@ -742,15 +753,15 @@ class Converter {
                     kind: (0, node_utils_1.getDeclarationKind)(node.declarationList),
                 });
                 if (!result.declarations.length) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node, 'A variable declaration list must have at least one variable declarator.');
+                    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) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, declaration, `'${result.kind}' declarations must be initialized.`);
+                            this.#throwError(declaration, `'${result.kind}' declarations must be initialized.`);
                         }
                         if (result.declarations[i].id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, declaration.name, `'${result.kind}' declarations may not have binding patterns.`);
+                            this.#throwError(declaration.name, `'${result.kind}' declarations may not have binding patterns.`);
                         }
                     });
                 }
@@ -774,10 +785,10 @@ class Converter {
                 if (result.kind === 'using' || result.kind === 'await using') {
                     node.declarations.forEach((declaration, i) => {
                         if (result.declarations[i].init != null) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, declaration, `'${result.kind}' declarations may not be initialized in for statement.`);
+                            this.#throwError(declaration, `'${result.kind}' declarations may not be initialized in for statement.`);
                         }
                         if (result.declarations[i].id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, declaration.name, `'${result.kind}' declarations may not have binding patterns.`);
+                            this.#throwError(declaration.name, `'${result.kind}' declarations may not have binding patterns.`);
                         }
                     });
                 }
@@ -827,7 +838,7 @@ class Converter {
                         property.kind === SyntaxKind.SetAccessor ||
                         property.kind === SyntaxKind.MethodDeclaration) &&
                         !property.body) {
-                        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, property.end - 1, "'{' expected.");
+                        this.#throwUnlessAllowInvalidAST(property.end - 1, "'{' expected.");
                     }
                     properties.push(this.convertChild(property));
                 }
@@ -840,10 +851,10 @@ class Converter {
                 // eslint-disable-next-line deprecation/deprecation
                 const { questionToken, exclamationToken } = node;
                 if (questionToken) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, questionToken, 'A property assignment cannot have a question token.');
+                    this.#throwError(questionToken, 'A property assignment cannot have a question token.');
                 }
                 if (exclamationToken) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, exclamationToken, 'A property assignment cannot have an exclamation token.');
+                    this.#throwError(exclamationToken, 'A property assignment cannot have an exclamation token.');
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Property,
@@ -860,13 +871,13 @@ class Converter {
                 // eslint-disable-next-line deprecation/deprecation
                 const { modifiers, questionToken, exclamationToken } = node;
                 if (modifiers) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifiers[0], 'A shorthand property assignment cannot have modifiers.');
+                    this.#throwError(modifiers[0], 'A shorthand property assignment cannot have modifiers.');
                 }
                 if (questionToken) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, questionToken, 'A shorthand property assignment cannot have a question token.');
+                    this.#throwError(questionToken, 'A shorthand property assignment cannot have a question token.');
                 }
                 if (exclamationToken) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, exclamationToken, 'A shorthand property assignment cannot have an exclamation token.');
+                    this.#throwError(exclamationToken, 'A shorthand property assignment cannot have an exclamation token.');
                 }
                 if (node.objectAssignmentInitializer) {
                     return this.createNode(node, {
@@ -903,7 +914,7 @@ class Converter {
             case SyntaxKind.PropertyDeclaration: {
                 const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
                 if (isAbstract && node.initializer) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node.initializer, `Abstract property cannot have an initializer.`);
+                    this.#throwError(node.initializer, `Abstract property cannot have an initializer.`);
                 }
                 const isAccessor = (0, node_utils_1.hasModifier)(SyntaxKind.AccessorKeyword, node);
                 const type = (() => {
@@ -1222,13 +1233,13 @@ class Converter {
                 return result;
             }
             case SyntaxKind.TaggedTemplateExpression:
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TaggedTemplateExpression,
                     typeArguments: node.typeArguments &&
                         this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
                     tag: this.convertChild(node.tag),
                     quasi: this.convertChild(node.template),
-                }, 'typeParameters', 'typeArguments'));
+                });
             case SyntaxKind.TemplateHead:
             case SyntaxKind.TemplateMiddle:
             case SyntaxKind.TemplateTail: {
@@ -1323,7 +1334,7 @@ class Converter {
                 if (!node.name &&
                     (!(0, node_utils_1.hasModifier)(ts.SyntaxKind.ExportKeyword, node) ||
                         !(0, node_utils_1.hasModifier)(ts.SyntaxKind.DefaultKeyword, node))) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node, "A class declaration without the 'default' modifier must have a name.");
+                    this.#throwUnlessAllowInvalidAST(node, "A class declaration without the 'default' modifier must have a name.");
                 }
             /* intentional fallthrough */
             case SyntaxKind.ClassExpression: {
@@ -1336,28 +1347,28 @@ class Converter {
                 for (const heritageClause of heritageClauses) {
                     const { token, types } = heritageClause;
                     if (types.length === 0) {
-                        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
+                        this.#throwUnlessAllowInvalidAST(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
                     }
                     if (token === SyntaxKind.ExtendsKeyword) {
                         if (extendsClause) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, heritageClause, "'extends' clause already seen.");
+                            this.#throwUnlessAllowInvalidAST(heritageClause, "'extends' clause already seen.");
                         }
                         if (implementsClause) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, heritageClause, "'extends' clause must precede 'implements' clause.");
+                            this.#throwUnlessAllowInvalidAST(heritageClause, "'extends' clause must precede 'implements' clause.");
                         }
                         if (types.length > 1) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, types[1], 'Classes can only extend a single class.');
+                            this.#throwUnlessAllowInvalidAST(types[1], 'Classes can only extend a single class.');
                         }
                         extendsClause ??= heritageClause;
                     }
                     else if (token === SyntaxKind.ImplementsKeyword) {
                         if (implementsClause) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, heritageClause, "'implements' clause already seen.");
+                            this.#throwUnlessAllowInvalidAST(heritageClause, "'implements' clause already seen.");
                         }
                         implementsClause ??= heritageClause;
                     }
                 }
-                const result = this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                const result = this.createNode(node, {
                     type: classNodeType,
                     abstract: (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node),
                     body: this.createNode(node, {
@@ -1377,7 +1388,7 @@ class Converter {
                     superTypeArguments: undefined,
                     typeParameters: node.typeParameters &&
                         this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
-                }, 'superTypeParameters', 'superTypeArguments'));
+                });
                 if (extendsClause?.types[0]?.typeArguments) {
                     result.superTypeArguments =
                         this.convertTypeArgumentsToTypeParameterInstantiation(extendsClause.types[0].typeArguments, extendsClause.types[0]);
@@ -1392,7 +1403,7 @@ class Converter {
                 });
             case SyntaxKind.ImportDeclaration: {
                 this.assertModuleSpecifier(node, false);
-                const result = this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                const result = this.createNode(node, this.#withDeprecatedAliasGetter({
                     type: ts_estree_1.AST_NODE_TYPES.ImportDeclaration,
                     source: this.convertChild(node.moduleSpecifier),
                     specifiers: [],
@@ -1444,7 +1455,7 @@ class Converter {
             case SyntaxKind.ExportDeclaration: {
                 if (node.exportClause?.kind === SyntaxKind.NamedExports) {
                     this.assertModuleSpecifier(node, true);
-                    return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                    return this.createNode(node, this.#withDeprecatedAliasGetter({
                         type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration,
                         source: this.convertChild(node.moduleSpecifier),
                         specifiers: node.exportClause.elements.map(el => this.convertChild(el)),
@@ -1456,7 +1467,7 @@ class Converter {
                     }, 'assertions', 'attributes', true));
                 }
                 this.assertModuleSpecifier(node, false);
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, this.#withDeprecatedAliasGetter({
                     type: ts_estree_1.AST_NODE_TYPES.ExportAllDeclaration,
                     source: this.convertChild(node.moduleSpecifier),
                     exportKind: node.isTypeOnly ? 'type' : 'value',
@@ -1496,7 +1507,7 @@ class Converter {
                  */
                 if (operator === '++' || operator === '--') {
                     if (!(0, node_utils_1.isValidAssignmentTarget)(node.operand)) {
-                        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.operand, 'Invalid left-hand side expression in unary operation');
+                        this.#throwUnlessAllowInvalidAST(node.operand, 'Invalid left-hand side expression in unary operation');
                     }
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.UpdateExpression,
@@ -1605,7 +1616,7 @@ class Converter {
             case SyntaxKind.CallExpression: {
                 if (node.expression.kind === SyntaxKind.ImportKeyword) {
                     if (node.arguments.length !== 1 && node.arguments.length !== 2) {
-                        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.arguments[2] ?? node, 'Dynamic import requires exactly one or two arguments.');
+                        this.#throwUnlessAllowInvalidAST(node.arguments[2] ?? node, 'Dynamic import requires exactly one or two arguments.');
                     }
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.ImportExpression,
@@ -1619,27 +1630,27 @@ class Converter {
                 const args = node.arguments.map(el => this.convertChild(el));
                 const typeArguments = node.typeArguments &&
                     this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
-                const result = this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.CallExpression,
                     callee,
                     arguments: args,
                     optional: node.questionDotToken !== undefined,
                     typeArguments,
-                }, 'typeParameters', 'typeArguments'));
+                });
                 return this.convertChainExpression(result, node);
             }
             case SyntaxKind.NewExpression: {
                 const typeArguments = node.typeArguments &&
                     this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
                 // NOTE - NewExpression cannot have an optional chain in it
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.NewExpression,
                     arguments: node.arguments
                         ? node.arguments.map(el => this.convertChild(el))
                         : [],
                     callee: this.convertChild(node.expression),
                     typeArguments,
-                }, 'typeParameters', 'typeArguments'));
+                });
             }
             case SyntaxKind.ConditionalExpression:
                 return this.createNode(node, {
@@ -1773,7 +1784,7 @@ class Converter {
                      * Convert SyntaxKind.JsxSelfClosingElement to SyntaxKind.JsxOpeningElement,
                      * TypeScript does not seem to have the idea of openingElement when tag is self-closing
                      */
-                    openingElement: this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                    openingElement: this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.JSXOpeningElement,
                         typeArguments: node.typeArguments
                             ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
@@ -1782,20 +1793,20 @@ class Converter {
                         name: this.convertJSXTagName(node.tagName, node),
                         attributes: node.attributes.properties.map(el => this.convertChild(el)),
                         range: (0, node_utils_1.getRange)(node, this.ast),
-                    }, 'typeParameters', 'typeArguments')),
+                    }),
                     closingElement: null,
                     children: [],
                 });
             }
             case SyntaxKind.JsxOpeningElement: {
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXOpeningElement,
                     typeArguments: node.typeArguments &&
                         this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
                     selfClosing: false,
                     name: this.convertJSXTagName(node.tagName, node),
                     attributes: node.attributes.properties.map(el => this.convertChild(el)),
-                }, 'typeParameters', 'typeArguments'));
+                });
             }
             case SyntaxKind.JsxClosingElement:
                 return this.createNode(node, {
@@ -1860,12 +1871,12 @@ class Converter {
             }
             // TypeScript specific
             case SyntaxKind.TypeReference:
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeReference,
                     typeName: this.convertChild(node.typeName),
                     typeArguments: node.typeArguments &&
                         this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
-                }, 'typeParameters', 'typeArguments'));
+                });
             case SyntaxKind.TypeParameter: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeParameter,
@@ -1933,17 +1944,17 @@ class Converter {
                 });
             }
             case SyntaxKind.TypeQuery:
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeQuery,
                     exprName: this.convertChild(node.exprName),
                     typeArguments: node.typeArguments &&
                         this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
-                }, 'typeParameters', 'typeArguments'));
+                });
             case SyntaxKind.MappedType: {
                 if (node.members && node.members.length > 0) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.members[0], 'A mapped type may not declare properties or methods.');
+                    this.#throwUnlessAllowInvalidAST(node.members[0], 'A mapped type may not declare properties or methods.');
                 }
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedGetter).call(this, {
+                return this.createNode(node, this.#withDeprecatedGetter({
                     type: ts_estree_1.AST_NODE_TYPES.TSMappedType,
                     constraint: this.convertChild(node.typeParameter.constraint),
                     key: this.convertChild(node.typeParameter.name),
@@ -1977,7 +1988,7 @@ class Converter {
                 // eslint-disable-next-line deprecation/deprecation
                 const { initializer } = node;
                 if (initializer) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, initializer, 'A property signature cannot have an initializer.');
+                    this.#throwError(initializer, 'A property signature cannot have an initializer.');
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSPropertySignature,
@@ -2014,7 +2025,7 @@ class Converter {
                 // eslint-disable-next-line deprecation/deprecation
                 const { modifiers } = node;
                 if (modifiers) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifiers[0], 'A function type cannot have modifiers.');
+                    this.#throwError(modifiers[0], 'A function type cannot have modifiers.');
                 }
             }
             // intentional fallthrough
@@ -2040,19 +2051,19 @@ class Converter {
                     : parentKind === SyntaxKind.HeritageClause
                         ? ts_estree_1.AST_NODE_TYPES.TSClassImplements
                         : ts_estree_1.AST_NODE_TYPES.TSInstantiationExpression;
-                return this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                return this.createNode(node, {
                     type,
                     expression: this.convertChild(node.expression),
                     typeArguments: node.typeArguments &&
                         this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
-                }, 'typeParameters', 'typeArguments'));
+                });
             }
             case SyntaxKind.InterfaceDeclaration: {
                 const interfaceHeritageClauses = node.heritageClauses ?? [];
                 const interfaceExtends = [];
                 for (const heritageClause of interfaceHeritageClauses) {
                     if (heritageClause.token !== SyntaxKind.ExtendsKeyword) {
-                        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, heritageClause, heritageClause.token === SyntaxKind.ImplementsKeyword
+                        this.#throwError(heritageClause, heritageClause.token === SyntaxKind.ImplementsKeyword
                             ? "Interface declaration cannot have 'implements' clause."
                             : 'Unexpected token.');
                     }
@@ -2099,7 +2110,7 @@ class Converter {
                     const token = (0, node_utils_1.findNextToken)(node.getFirstToken(), node, this.ast);
                     range[0] = token.getStart(this.ast);
                 }
-                const result = this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedAliasGetter).call(this, {
+                const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSImportType,
                     argument: this.convertChild(node.argument),
                     qualifier: this.convertChild(node.qualifier),
@@ -2107,20 +2118,19 @@ class Converter {
                         ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
                         : null,
                     range: range,
-                }, 'typeParameters', 'typeArguments'));
+                });
                 if (node.isTypeOf) {
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.TSTypeQuery,
                         exprName: result,
                         typeArguments: undefined,
-                        typeParameters: undefined,
                     });
                 }
                 return result;
             }
             case SyntaxKind.EnumDeclaration: {
                 const members = node.members.map(el => this.convertChild(el));
-                const result = this.createNode(node, __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_withDeprecatedGetter).call(this, {
+                const result = this.createNode(node, this.#withDeprecatedGetter({
                     type: ts_estree_1.AST_NODE_TYPES.TSEnumDeclaration,
                     body: this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.TSEnumBody,
@@ -2153,10 +2163,10 @@ class Converter {
                             const body = this.convertChild(node.body);
                             if (body == null ||
                                 body.type === ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration) {
-                                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.body ?? node, 'Expected a valid module body');
+                                this.#throwUnlessAllowInvalidAST(node.body ?? node, 'Expected a valid module body');
                             }
                             if (id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.name, 'global module augmentation must have an Identifier id');
+                                this.#throwUnlessAllowInvalidAST(node.name, 'global module augmentation must have an Identifier id');
                             }
                             return {
                                 kind: 'global',
@@ -2180,10 +2190,10 @@ class Converter {
                         // We "unravel" them here by making our own nested TSQualifiedName,
                         // with the innermost node's body as the actual node body.
                         if (node.body == null) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node, 'Expected a module body');
+                            this.#throwUnlessAllowInvalidAST(node, 'Expected a module body');
                         }
                         if (node.name.kind !== ts.SyntaxKind.Identifier) {
-                            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwUnlessAllowInvalidAST).call(this, node.name, '`namespace`s must have an Identifier id');
+                            this.#throwUnlessAllowInvalidAST(node.name, '`namespace`s must have an Identifier id');
                         }
                         let name = this.createNode(node.name, {
                             decorators: [],
@@ -2225,6 +2235,7 @@ class Converter {
                 });
                 result.declare = isDeclare;
                 if (node.flags & ts.NodeFlags.GlobalAugmentation) {
+                    // eslint-disable-next-line deprecation/deprecation
                     result.global = true;
                 }
                 return this.fixExports(node, result);
@@ -2287,6 +2298,9 @@ class Converter {
                 }));
             }
             case SyntaxKind.ExternalModuleReference: {
+                if (node.expression.kind !== SyntaxKind.StringLiteral) {
+                    this.#throwError(node.expression, 'String literal expected.');
+                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSExternalModuleReference,
                     expression: this.convertChild(node.expression),
@@ -2380,203 +2394,215 @@ class Converter {
                 return this.deeplyCopy(node);
         }
     }
-}
-exports.Converter = Converter;
-_Converter_instances = new WeakSet(), _Converter_checkModifiers = function _Converter_checkModifiers(node) {
-    if (this.options.allowInvalidAST) {
-        return;
-    }
-    // typescript<5.0.0
-    if ((0, node_utils_1.nodeHasIllegalDecorators)(node)) {
-        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node.illegalDecorators[0], 'Decorators are not valid here.');
-    }
-    for (const decorator of (0, getModifiers_1.getDecorators)(node, 
-    /* includeIllegalDecorators */ true) ?? []) {
-        // `checkGrammarModifiers` function in typescript
-        if (!(0, node_utils_1.nodeCanBeDecorated)(node)) {
-            if (ts.isMethodDeclaration(node) && !(0, node_utils_1.nodeIsPresent)(node.body)) {
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, decorator, 'A decorator can only decorate a method implementation, not an overload.');
-            }
-            else {
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, decorator, 'Decorators are not valid here.');
-            }
-        }
-    }
-    for (const modifier of (0, getModifiers_1.getModifiers)(node, 
-    /* includeIllegalModifiers */ true) ?? []) {
-        if (modifier.kind !== SyntaxKind.ReadonlyKeyword) {
-            if (node.kind === SyntaxKind.PropertySignature ||
-                node.kind === SyntaxKind.MethodSignature) {
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type member`);
-            }
-            if (node.kind === SyntaxKind.IndexSignature &&
-                (modifier.kind !== SyntaxKind.StaticKeyword ||
-                    !ts.isClassLike(node.parent))) {
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on an index signature`);
-            }
-        }
-        if (modifier.kind !== SyntaxKind.InKeyword &&
-            modifier.kind !== SyntaxKind.OutKeyword &&
-            modifier.kind !== SyntaxKind.ConstKeyword &&
-            node.kind === SyntaxKind.TypeParameter) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type parameter`);
-        }
-        if ((modifier.kind === SyntaxKind.InKeyword ||
-            modifier.kind === SyntaxKind.OutKeyword) &&
-            (node.kind !== SyntaxKind.TypeParameter ||
-                !(ts.isInterfaceDeclaration(node.parent) ||
-                    ts.isClassLike(node.parent) ||
-                    ts.isTypeAliasDeclaration(node.parent)))) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a type parameter of a class, interface or type alias`);
-        }
-        if (modifier.kind === SyntaxKind.ReadonlyKeyword &&
-            node.kind !== SyntaxKind.PropertyDeclaration &&
-            node.kind !== SyntaxKind.PropertySignature &&
-            node.kind !== SyntaxKind.IndexSignature &&
-            node.kind !== SyntaxKind.Parameter) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, "'readonly' modifier can only appear on a property declaration or index signature.");
-        }
-        if (modifier.kind === SyntaxKind.DeclareKeyword &&
-            ts.isClassLike(node.parent) &&
-            !ts.isPropertyDeclaration(node)) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on class elements of this kind.`);
-        }
-        if (modifier.kind === SyntaxKind.DeclareKeyword &&
-            ts.isVariableStatement(node)) {
-            const declarationKind = (0, node_utils_1.getDeclarationKind)(node.declarationList);
-            if (declarationKind === 'using' || declarationKind === 'await using') {
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'declare' modifier cannot appear on a '${declarationKind}' declaration.`);
-            }
-        }
-        if (modifier.kind === SyntaxKind.AbstractKeyword &&
-            node.kind !== SyntaxKind.ClassDeclaration &&
-            node.kind !== SyntaxKind.ConstructorType &&
-            node.kind !== SyntaxKind.MethodDeclaration &&
-            node.kind !== SyntaxKind.PropertyDeclaration &&
-            node.kind !== SyntaxKind.GetAccessor &&
-            node.kind !== SyntaxKind.SetAccessor) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a class, method, or property declaration.`);
+    #checkModifiers(node) {
+        if (this.options.allowInvalidAST) {
+            return;
         }
-        if ((modifier.kind === SyntaxKind.StaticKeyword ||
-            modifier.kind === SyntaxKind.PublicKeyword ||
-            modifier.kind === SyntaxKind.ProtectedKeyword ||
-            modifier.kind === SyntaxKind.PrivateKeyword) &&
-            (node.parent.kind === SyntaxKind.ModuleBlock ||
-                node.parent.kind === SyntaxKind.SourceFile)) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a module or namespace element.`);
+        // typescript<5.0.0
+        if ((0, node_utils_1.nodeHasIllegalDecorators)(node)) {
+            this.#throwError(node.illegalDecorators[0], 'Decorators are not valid here.');
         }
-        if (modifier.kind === SyntaxKind.AccessorKeyword &&
-            node.kind !== SyntaxKind.PropertyDeclaration) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, "'accessor' modifier can only appear on a property declaration.");
-        }
-        // `checkGrammarAsyncModifier` function in `typescript`
-        if (modifier.kind === SyntaxKind.AsyncKeyword &&
-            node.kind !== SyntaxKind.MethodDeclaration &&
-            node.kind !== SyntaxKind.FunctionDeclaration &&
-            node.kind !== SyntaxKind.FunctionExpression &&
-            node.kind !== SyntaxKind.ArrowFunction) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, "'async' modifier cannot be used here.");
-        }
-        // `checkGrammarModifiers` function in `typescript`
-        if (node.kind === SyntaxKind.Parameter &&
-            (modifier.kind === SyntaxKind.StaticKeyword ||
-                modifier.kind === SyntaxKind.ExportKeyword ||
-                modifier.kind === SyntaxKind.DeclareKeyword ||
-                modifier.kind === SyntaxKind.AsyncKeyword)) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
-        }
-        // `checkGrammarModifiers` function in `typescript`
-        if (modifier.kind === SyntaxKind.PublicKeyword ||
-            modifier.kind === SyntaxKind.ProtectedKeyword ||
-            modifier.kind === SyntaxKind.PrivateKeyword) {
-            for (const anotherModifier of (0, getModifiers_1.getModifiers)(node) ?? []) {
-                if (anotherModifier !== modifier &&
-                    (anotherModifier.kind === SyntaxKind.PublicKeyword ||
-                        anotherModifier.kind === SyntaxKind.ProtectedKeyword ||
-                        anotherModifier.kind === SyntaxKind.PrivateKeyword)) {
-                    __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, anotherModifier, `Accessibility modifier already seen.`);
+        for (const decorator of (0, getModifiers_1.getDecorators)(node, 
+        /* includeIllegalDecorators */ true) ?? []) {
+            // `checkGrammarModifiers` function in typescript
+            if (!(0, node_utils_1.nodeCanBeDecorated)(node)) {
+                if (ts.isMethodDeclaration(node) && !(0, node_utils_1.nodeIsPresent)(node.body)) {
+                    this.#throwError(decorator, 'A decorator can only decorate a method implementation, not an overload.');
+                }
+                else {
+                    this.#throwError(decorator, 'Decorators are not valid here.');
                 }
             }
         }
-        // `checkParameter` function in `typescript`
-        if (node.kind === SyntaxKind.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 === SyntaxKind.PublicKeyword ||
-                modifier.kind === SyntaxKind.PrivateKeyword ||
+        for (const modifier of (0, getModifiers_1.getModifiers)(node, 
+        /* includeIllegalModifiers */ true) ?? []) {
+            if (modifier.kind !== SyntaxKind.ReadonlyKeyword) {
+                if (node.kind === SyntaxKind.PropertySignature ||
+                    node.kind === SyntaxKind.MethodSignature) {
+                    this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type member`);
+                }
+                if (node.kind === SyntaxKind.IndexSignature &&
+                    (modifier.kind !== SyntaxKind.StaticKeyword ||
+                        !ts.isClassLike(node.parent))) {
+                    this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on an index signature`);
+                }
+            }
+            if (modifier.kind !== SyntaxKind.InKeyword &&
+                modifier.kind !== SyntaxKind.OutKeyword &&
+                modifier.kind !== SyntaxKind.ConstKeyword &&
+                node.kind === SyntaxKind.TypeParameter) {
+                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type parameter`);
+            }
+            if ((modifier.kind === SyntaxKind.InKeyword ||
+                modifier.kind === SyntaxKind.OutKeyword) &&
+                (node.kind !== SyntaxKind.TypeParameter ||
+                    !(ts.isInterfaceDeclaration(node.parent) ||
+                        ts.isClassLike(node.parent) ||
+                        ts.isTypeAliasDeclaration(node.parent)))) {
+                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a type parameter of a class, interface or type alias`);
+            }
+            if (modifier.kind === SyntaxKind.ReadonlyKeyword &&
+                node.kind !== SyntaxKind.PropertyDeclaration &&
+                node.kind !== SyntaxKind.PropertySignature &&
+                node.kind !== SyntaxKind.IndexSignature &&
+                node.kind !== SyntaxKind.Parameter) {
+                this.#throwError(modifier, "'readonly' modifier can only appear on a property declaration or index signature.");
+            }
+            if (modifier.kind === SyntaxKind.DeclareKeyword &&
+                ts.isClassLike(node.parent) &&
+                !ts.isPropertyDeclaration(node)) {
+                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on class elements of this kind.`);
+            }
+            if (modifier.kind === SyntaxKind.DeclareKeyword &&
+                ts.isVariableStatement(node)) {
+                const declarationKind = (0, node_utils_1.getDeclarationKind)(node.declarationList);
+                if (declarationKind === 'using' || declarationKind === 'await using') {
+                    this.#throwError(modifier, `'declare' modifier cannot appear on a '${declarationKind}' declaration.`);
+                }
+            }
+            if (modifier.kind === SyntaxKind.AbstractKeyword &&
+                node.kind !== SyntaxKind.ClassDeclaration &&
+                node.kind !== SyntaxKind.ConstructorType &&
+                node.kind !== SyntaxKind.MethodDeclaration &&
+                node.kind !== SyntaxKind.PropertyDeclaration &&
+                node.kind !== SyntaxKind.GetAccessor &&
+                node.kind !== SyntaxKind.SetAccessor) {
+                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a class, method, or property declaration.`);
+            }
+            if ((modifier.kind === SyntaxKind.StaticKeyword ||
+                modifier.kind === SyntaxKind.PublicKeyword ||
                 modifier.kind === SyntaxKind.ProtectedKeyword ||
-                modifier.kind === SyntaxKind.ReadonlyKeyword ||
-                modifier.kind === SyntaxKind.OverrideKeyword)) {
-            const func = (0, node_utils_1.getContainingFunction)(node);
-            if (!(func.kind === SyntaxKind.Constructor && (0, node_utils_1.nodeIsPresent)(func.body))) {
-                __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, modifier, 'A parameter property is only allowed in a constructor implementation.');
+                modifier.kind === SyntaxKind.PrivateKeyword) &&
+                (node.parent.kind === SyntaxKind.ModuleBlock ||
+                    node.parent.kind === SyntaxKind.SourceFile)) {
+                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a module or namespace element.`);
+            }
+            if (modifier.kind === SyntaxKind.AccessorKeyword &&
+                node.kind !== SyntaxKind.PropertyDeclaration) {
+                this.#throwError(modifier, "'accessor' modifier can only appear on a property declaration.");
+            }
+            // `checkGrammarAsyncModifier` function in `typescript`
+            if (modifier.kind === SyntaxKind.AsyncKeyword &&
+                node.kind !== SyntaxKind.MethodDeclaration &&
+                node.kind !== SyntaxKind.FunctionDeclaration &&
+                node.kind !== SyntaxKind.FunctionExpression &&
+                node.kind !== SyntaxKind.ArrowFunction) {
+                this.#throwError(modifier, "'async' modifier cannot be used here.");
+            }
+            // `checkGrammarModifiers` function in `typescript`
+            if (node.kind === SyntaxKind.Parameter &&
+                (modifier.kind === SyntaxKind.StaticKeyword ||
+                    modifier.kind === SyntaxKind.ExportKeyword ||
+                    modifier.kind === SyntaxKind.DeclareKeyword ||
+                    modifier.kind === SyntaxKind.AsyncKeyword)) {
+                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
+            }
+            // `checkGrammarModifiers` function in `typescript`
+            if (modifier.kind === SyntaxKind.PublicKeyword ||
+                modifier.kind === SyntaxKind.ProtectedKeyword ||
+                modifier.kind === SyntaxKind.PrivateKeyword) {
+                for (const anotherModifier of (0, getModifiers_1.getModifiers)(node) ?? []) {
+                    if (anotherModifier !== modifier &&
+                        (anotherModifier.kind === SyntaxKind.PublicKeyword ||
+                            anotherModifier.kind === SyntaxKind.ProtectedKeyword ||
+                            anotherModifier.kind === SyntaxKind.PrivateKeyword)) {
+                        this.#throwError(anotherModifier, `Accessibility modifier already seen.`);
+                    }
+                }
+            }
+            // `checkParameter` function in `typescript`
+            if (node.kind === SyntaxKind.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 === SyntaxKind.PublicKeyword ||
+                    modifier.kind === SyntaxKind.PrivateKeyword ||
+                    modifier.kind === SyntaxKind.ProtectedKeyword ||
+                    modifier.kind === SyntaxKind.ReadonlyKeyword ||
+                    modifier.kind === SyntaxKind.OverrideKeyword)) {
+                const func = (0, node_utils_1.getContainingFunction)(node);
+                if (!(func.kind === SyntaxKind.Constructor && (0, node_utils_1.nodeIsPresent)(func.body))) {
+                    this.#throwError(modifier, 'A parameter property is only allowed in a constructor implementation.');
+                }
             }
         }
     }
-}, _Converter_throwUnlessAllowInvalidAST = function _Converter_throwUnlessAllowInvalidAST(node, message) {
-    if (!this.options.allowInvalidAST) {
-        __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, node, message);
+    #throwUnlessAllowInvalidAST(node, message) {
+        if (!this.options.allowInvalidAST) {
+            this.#throwError(node, message);
+        }
     }
-}, _Converter_withDeprecatedAliasGetter = function _Converter_withDeprecatedAliasGetter(node, aliasKey, valueKey, suppressWarnings = false) {
-    let warned = suppressWarnings;
-    Object.defineProperty(node, aliasKey, {
-        configurable: true,
-        get: this.options.suppressDeprecatedPropertyWarnings
-            ? () => node[valueKey]
-            : () => {
-                if (!warned) {
-                    process.emitWarning(`The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://typescript-eslint.io/linting/troubleshooting#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, 'DeprecationWarning');
-                    warned = true;
-                }
-                return node[valueKey];
+    /**
+     * 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) {
+                        process.emitWarning(`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,
+                    writable: true,
+                    value,
+                });
             },
-        set(value) {
-            Object.defineProperty(node, aliasKey, {
-                enumerable: true,
-                writable: true,
-                value,
-            });
-        },
-    });
-    return node;
-}, _Converter_withDeprecatedGetter = function _Converter_withDeprecatedGetter(node, deprecatedKey, preferredKey, value) {
-    let warned = false;
-    Object.defineProperty(node, deprecatedKey, {
-        configurable: true,
-        get: this.options.suppressDeprecatedPropertyWarnings
-            ? () => value
-            : () => {
-                if (!warned) {
-                    process.emitWarning(`The '${deprecatedKey}' property is deprecated on ${node.type} nodes. Use ${preferredKey} instead. See https://typescript-eslint.io/linting/troubleshooting#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, 'DeprecationWarning');
-                    warned = true;
-                }
-                return value;
+        });
+        return node;
+    }
+    #withDeprecatedGetter(node, deprecatedKey, preferredKey, value) {
+        let warned = false;
+        Object.defineProperty(node, deprecatedKey, {
+            configurable: true,
+            get: this.options.suppressDeprecatedPropertyWarnings
+                ? () => value
+                : () => {
+                    if (!warned) {
+                        process.emitWarning(`The '${deprecatedKey}' property is deprecated on ${node.type} nodes. Use ${preferredKey} 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 value;
+                },
+            set(value) {
+                Object.defineProperty(node, deprecatedKey, {
+                    enumerable: true,
+                    writable: true,
+                    value,
+                });
             },
-        set(value) {
-            Object.defineProperty(node, deprecatedKey, {
-                enumerable: true,
-                writable: true,
-                value,
-            });
-        },
-    });
-    return node;
-}, _Converter_throwError = function _Converter_throwError(node, message) {
-    let start;
-    let end;
-    if (typeof node === 'number') {
-        start = end = node;
+        });
+        return node;
     }
-    else {
-        start = node.getStart(this.ast);
-        end = node.getEnd();
+    #throwError(node, message) {
+        let start;
+        let end;
+        if (typeof node === 'number') {
+            start = end = node;
+        }
+        else {
+            start = node.getStart(this.ast);
+            end = node.getEnd();
+        }
+        throw (0, node_utils_1.createError)(message, this.ast, start, end);
     }
-    throw (0, node_utils_1.createError)(message, this.ast, start, end);
-}, _Converter_checkForStatementDeclaration = function _Converter_checkForStatementDeclaration(initializer) {
-    if (ts.isVariableDeclarationList(initializer)) {
-        if ((initializer.flags & ts.NodeFlags.Using) !== 0) {
-            __classPrivateFieldGet(this, _Converter_instances, "m", _Converter_throwError).call(this, initializer, "The left-hand side of a 'for...in' statement cannot be a 'using' declaration.");
+    #checkForStatementDeclaration(initializer) {
+        if (ts.isVariableDeclarationList(initializer)) {
+            if ((initializer.flags & ts.NodeFlags.Using) !== 0) {
+                this.#throwError(initializer, "The left-hand side of a 'for...in' statement cannot be a 'using' declaration.");
+            }
         }
     }
-};
+}
+exports.Converter = Converter;
 //# sourceMappingURL=convert.js.map