@typescript-eslint/typescript-estree 8.10.1-alpha.7 → 8.11.1-alpha.0

package/dist/convert.js

@@ -41,11 +41,11 @@ function convertError(error) {
     return (0, node_utils_1.createError)(('message' in error && error.message) || error.messageText, error.file, error.start);
 }
 class Converter {
+    allowPattern = false;
     ast;
-    options;
     esTreeNodeToTSNodeMap = new WeakMap();
+    options;
     tsNodeToESTreeNodeMap = new WeakMap();
-    allowPattern = false;
     /**
      * Converts a TypeScript node into an ESTree node
      * @param ast the full TypeScript AST
@@ -56,232 +56,276 @@ class Converter {
         this.ast = ast;
         this.options = { ...options };
     }
-    getASTMaps() {
-        return {
-            esTreeNodeToTSNodeMap: this.esTreeNodeToTSNodeMap,
-            tsNodeToESTreeNodeMap: this.tsNodeToESTreeNodeMap,
-        };
-    }
-    convertProgram() {
-        return this.converter(this.ast);
-    }
-    /**
-     * 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) {
-        /**
-         * Exit early for null and undefined
-         */
-        if (!node) {
-            return null;
-        }
-        this.#checkModifiers(node);
-        const pattern = this.allowPattern;
-        if (allowPattern !== undefined) {
-            this.allowPattern = allowPattern;
-        }
-        const result = this.convertNode(node, (parent ?? node.parent));
-        this.registerTSNodeInNodeMap(node, result);
-        this.allowPattern = pattern;
-        return result;
-    }
-    /**
-     * Fixes the exports of the given ts.Node
-     * @returns the ESTreeNode with fixed exports
-     */
-    fixExports(node, result) {
-        const isNamespaceNode = ts.isModuleDeclaration(node) &&
-            Boolean(node.flags & ts.NodeFlags.Namespace);
-        const modifiers = isNamespaceNode
-            ? (0, node_utils_1.getNamespaceModifiers)(node)
-            : (0, getModifiers_1.getModifiers)(node);
-        if (modifiers?.[0].kind === SyntaxKind.ExportKeyword) {
-            /**
-             * Make sure that original node is registered instead of export
-             */
-            this.registerTSNodeInNodeMap(node, result);
-            const exportKeyword = modifiers[0];
-            const nextModifier = modifiers[1];
-            const declarationIsDefault = nextModifier?.kind === SyntaxKind.DefaultKeyword;
-            const varToken = declarationIsDefault
-                ? (0, node_utils_1.findNextToken)(nextModifier, this.ast, this.ast)
-                : (0, node_utils_1.findNextToken)(exportKeyword, this.ast, this.ast);
-            result.range[0] = varToken.getStart(this.ast);
-            result.loc = (0, node_utils_1.getLocFor)(result.range, this.ast);
-            if (declarationIsDefault) {
-                return this.createNode(node, {
-                    type: ts_estree_1.AST_NODE_TYPES.ExportDefaultDeclaration,
-                    declaration: result,
-                    range: [exportKeyword.getStart(this.ast), result.range[1]],
-                    exportKind: 'value',
-                });
+    #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.");
             }
-            const isType = result.type === ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
-                result.type === ts_estree_1.AST_NODE_TYPES.TSTypeAliasDeclaration;
-            const isDeclare = 'declare' in result && result.declare;
-            return this.createNode(node, 
-            // @ts-expect-error - TODO, narrow the types here
-            this.#withDeprecatedAliasGetter({
-                type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration,
-                declaration: result,
-                specifiers: [],
-                source: null,
-                exportKind: isType || isDeclare ? 'type' : 'value',
-                range: [exportKeyword.getStart(this.ast), result.range[1]],
-                attributes: [],
-            }, 'assertions', 'attributes', true));
         }
-        return result;
-    }
-    /**
-     * 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);
+        else if (!(0, node_utils_1.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.`);
         }
     }
-    /**
-     * 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 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);
-    }
-    createNode(
-    // The 'parent' property will be added later if specified
-    node, data) {
-        const result = data;
-        result.range ??= (0, node_utils_1.getRange)(node, this.ast);
-        result.loc ??= (0, node_utils_1.getLocFor)(result.range, this.ast);
-        if (result && this.options.shouldPreserveNodeMaps) {
-            this.esTreeNodeToTSNodeMap.set(result, node);
+    #checkModifiers(node) {
+        if (this.options.allowInvalidAST) {
+            return;
         }
-        return result;
-    }
-    convertBindingNameWithTypeAnnotation(name, tsType, parent) {
-        const id = this.convertPattern(name);
-        if (tsType) {
-            id.typeAnnotation = this.convertTypeAnnotation(tsType, parent);
-            this.fixParentLocation(id, id.typeAnnotation.range);
+        // typescript<5.0.0
+        if ((0, node_utils_1.nodeHasIllegalDecorators)(node)) {
+            this.#throwError(node.illegalDecorators[0], 'Decorators are not valid here.');
         }
-        return id;
-    }
-    /**
-     * 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) {
-        // in FunctionType and ConstructorType typeAnnotation has 2 characters `=>` and in other places is just colon
-        const offset = parent?.kind === SyntaxKind.FunctionType ||
-            parent?.kind === SyntaxKind.ConstructorType
-            ? 2
-            : 1;
-        const annotationStartCol = child.getFullStart() - offset;
-        const range = [annotationStartCol, child.end];
-        const loc = (0, node_utils_1.getLocFor)(range, this.ast);
-        return {
-            type: ts_estree_1.AST_NODE_TYPES.TSTypeAnnotation,
-            loc,
-            range,
-            typeAnnotation: this.convertChild(child),
-        };
-    }
-    /**
-     * 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, node_utils_1.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; // child can be null, but it's filtered below
+        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.');
                 }
-                allowDirectives = false;
             }
-            return child; // child can be null, but it's filtered below
-        })
-            // filter out unknown nodes for now
-            .filter(statement => statement));
-    }
-    /**
-     * 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, node_utils_1.findNextToken)(typeArguments, this.ast, this.ast);
-        return this.createNode(node, {
-            type: ts_estree_1.AST_NODE_TYPES.TSTypeParameterInstantiation,
-            range: [typeArguments.pos - 1, greaterThanToken.end],
-            params: typeArguments.map(typeArgument => this.convertChild(typeArgument)),
-        });
-    }
-    /**
-     * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node
-     * @param typeParameters ts.Node typeParameters
-     * @returns TypeParameterDeclaration node
-     */
-    convertTSTypeParametersToTypeParametersDeclaration(typeParameters) {
-        const greaterThanToken = (0, node_utils_1.findNextToken)(typeParameters, this.ast, this.ast);
-        const range = [
-            typeParameters.pos - 1,
-            greaterThanToken.end,
-        ];
-        return {
-            type: ts_estree_1.AST_NODE_TYPES.TSTypeParameterDeclaration,
-            range,
-            loc: (0, node_utils_1.getLocFor)(range, this.ast),
-            params: typeParameters.map(typeParameter => this.convertChild(typeParameter)),
-        };
-    }
-    /**
-     * 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 =
-                (0, getModifiers_1.getDecorators)(param)?.map(el => this.convertChild(el)) ?? [];
-            return convertedParam;
-        });
-    }
-    convertChainExpression(node, tsNode) {
+        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.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.');
+                }
+            }
+        }
+    }
+    #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);
+    }
+    #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) {
+                        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,
+                    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) {
+                        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,
+                    value,
+                    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 !== SyntaxKind.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, node_utils_1.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; // child can be null, but it's filtered below
+                }
+                allowDirectives = false;
+            }
+            return child; // child can be null, but it's filtered below
+        })
+            // filter out unknown nodes for now
+            .filter(statement => statement));
+    }
+    convertChainExpression(node, tsNode) {
         const { child, isOptional } = (() => {
             if (node.type === ts_estree_1.AST_NODE_TYPES.MemberExpression) {
                 return { child: node.object, isOptional: node.optional };
@@ -314,87 +358,123 @@ class Converter {
         });
     }
     /**
-     * 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.
+     * Converts a TypeScript node into an ESTree node.
+     * @param child the child ts.Node
+     * @param parent parentNode
+     * @returns the converted ESTree node
      */
-    deeplyCopy(node) {
-        if (node.kind === ts.SyntaxKind.JSDocFunctionType) {
-            this.#throwError(node, 'JSDoc types can only be used inside documentation comments.');
-        }
-        const customType = `TS${SyntaxKind[node.kind]}`;
-        /**
-         * If the "errorOnUnknownASTType" option is set to true, throw an error,
-         * otherwise fallback to just including the unknown type as-is.
-         */
-        if (this.options.errorOnUnknownASTType && !ts_estree_1.AST_NODE_TYPES[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;
+    convertChild(child, parent) {
+        return 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) {
+        // in FunctionType and ConstructorType typeAnnotation has 2 characters `=>` and in other places is just colon
+        const offset = parent?.kind === SyntaxKind.FunctionType ||
+            parent?.kind === SyntaxKind.ConstructorType
+            ? 2
+            : 1;
+        const annotationStartCol = child.getFullStart() - offset;
+        const range = [annotationStartCol, child.end];
+        const loc = (0, node_utils_1.getLocFor)(range, this.ast);
+        return {
+            type: ts_estree_1.AST_NODE_TYPES.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, node_utils_1.findNextToken)(typeArguments, this.ast, this.ast);
+        return this.createNode(node, {
+            type: ts_estree_1.AST_NODE_TYPES.TSTypeParameterInstantiation,
+            range: [typeArguments.pos - 1, greaterThanToken.end],
+            params: typeArguments.map(typeArgument => this.convertChild(typeArgument)),
+        });
+    }
+    /**
+     * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node
+     * @param typeParameters ts.Node typeParameters
+     * @returns TypeParameterDeclaration node
+     */
+    convertTSTypeParametersToTypeParametersDeclaration(typeParameters) {
+        const greaterThanToken = (0, node_utils_1.findNextToken)(typeParameters, this.ast, this.ast);
+        const range = [
+            typeParameters.pos - 1,
+            greaterThanToken.end,
+        ];
+        return {
+            type: ts_estree_1.AST_NODE_TYPES.TSTypeParameterDeclaration,
+            loc: (0, node_utils_1.getLocFor)(range, this.ast),
+            range,
+            params: typeParameters.map(typeParameter => this.convertChild(typeParameter)),
+        };
+    }
+    /**
+     * 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 [];
         }
-        if ('typeParameters' in node) {
-            result.typeParameters =
-                node.typeParameters && 'pos' in node.typeParameters
-                    ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
-                    : null;
+        return parameters.map(param => {
+            const convertedParam = this.convertChild(param);
+            convertedParam.decorators =
+                (0, getModifiers_1.getDecorators)(param)?.map(el => this.convertChild(el)) ?? [];
+            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) {
+        /**
+         * Exit early for null and undefined
+         */
+        if (!node) {
+            return null;
         }
-        const decorators = (0, getModifiers_1.getDecorators)(node);
-        if (decorators?.length) {
-            result.decorators = decorators.map(el => this.convertChild(el));
+        this.#checkModifiers(node);
+        const pattern = this.allowPattern;
+        if (allowPattern !== undefined) {
+            this.allowPattern = allowPattern;
         }
-        // keys we never want to clone from the base typescript node as they
-        // introduce garbage into our AST
-        const KEYS_TO_NOT_COPY = new Set([
-            '_children',
-            'decorators',
-            'end',
-            'flags',
-            'illegalDecorators',
-            'heritageClauses',
-            'locals',
-            'localSymbol',
-            'jsDoc',
-            'kind',
-            '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] = value.map(el => this.convertChild(el));
-            }
-            else if (value && typeof value === 'object' && value.kind) {
-                // need to check node[key].kind to ensure we don't try to convert a symbol
-                result[key] = this.convertChild(value);
-            }
-            else {
-                result[key] = value;
-            }
-        });
+        const result = this.convertNode(node, (parent ?? node.parent));
+        this.registerTSNodeInNodeMap(node, result);
+        this.allowPattern = pattern;
         return result;
     }
+    convertImportAttributes(node) {
+        return node === undefined
+            ? []
+            : node.elements.map(element => this.convertChild(element));
+    }
     convertJSXIdentifier(node) {
         const result = this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
@@ -409,14 +489,14 @@ class Converter {
         if (node.kind === ts.SyntaxKind.JsxNamespacedName) {
             const result = this.createNode(node, {
                 type: ts_estree_1.AST_NODE_TYPES.JSXNamespacedName,
-                namespace: this.createNode(node.namespace, {
-                    type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
-                    name: node.namespace.text,
-                }),
                 name: this.createNode(node.name, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
                     name: node.name.text,
                 }),
+                namespace: this.createNode(node.namespace, {
+                    type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
+                    name: node.namespace.text,
+                }),
             });
             this.registerTSNodeInNodeMap(node, result);
             return result;
@@ -430,17 +510,17 @@ class Converter {
             // @ts-expect-error -- TypeScript@<5.1 doesn't have ts.JsxNamespacedName
             const result = this.createNode(node, {
                 type: ts_estree_1.AST_NODE_TYPES.JSXNamespacedName,
-                namespace: this.createNode(node, {
-                    type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
-                    name: text.slice(0, colonIndex),
-                    range: [range[0], range[0] + colonIndex],
-                }),
+                range,
                 name: this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
-                    name: text.slice(colonIndex + 1),
                     range: [range[0] + colonIndex + 1, range[1]],
+                    name: text.slice(colonIndex + 1),
+                }),
+                namespace: this.createNode(node, {
+                    type: ts_estree_1.AST_NODE_TYPES.JSXIdentifier,
+                    range: [range[0], range[0] + colonIndex],
+                    name: text.slice(0, colonIndex),
                 }),
-                range,
             });
             this.registerTSNodeInNodeMap(node, result);
             return result;
@@ -493,18 +573,13 @@ class Converter {
             })(),
             optional: (0, node_utils_1.isOptional)(node),
             params: this.convertParameters(node.parameters),
-            returnType: node.type && this.convertTypeAnnotation(node.type, node),
             readonly: (0, node_utils_1.hasModifier)(SyntaxKind.ReadonlyKeyword, node),
+            returnType: node.type && this.convertTypeAnnotation(node.type, node),
             static: (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node),
             typeParameters: node.typeParameters &&
                 this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
         });
     }
-    convertImportAttributes(node) {
-        return node === undefined
-            ? []
-            : node.elements.map(element => this.convertChild(element));
-    }
     /**
      * 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
@@ -520,15 +595,6 @@ class Converter {
             result.loc.end = (0, node_utils_1.getLineAndCharacterFor)(result.range[1], this.ast);
         }
     }
-    assertModuleSpecifier(node, allowNull) {
-        if (!allowNull && node.moduleSpecifier == null) {
-            this.#throwUnlessAllowInvalidAST(node, 'Module specifier must be a string literal.');
-        }
-        if (node.moduleSpecifier &&
-            node.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-            this.#throwUnlessAllowInvalidAST(node.moduleSpecifier, 'Module specifier must be a string literal.');
-        }
-    }
     /**
      * Converts a TypeScript node into an ESTree node.
      * The core of the conversion logic:
@@ -540,9 +606,9 @@ class Converter {
             case SyntaxKind.SourceFile: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Program,
+                    range: [node.getStart(this.ast), node.endOfFileToken.end],
                     body: this.convertBodyExpressions(node.statements, node),
                     comments: undefined,
-                    range: [node.getStart(this.ast), node.endOfFileToken.end],
                     sourceType: node.externalModuleIndicator ? 'module' : 'script',
                     tokens: undefined,
                 });
@@ -579,8 +645,8 @@ class Converter {
             case SyntaxKind.WithStatement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.WithStatement,
-                    object: this.convertChild(node.expression),
                     body: this.convertChild(node.statement),
+                    object: this.convertChild(node.expression),
                 });
             // Control Flow
             case SyntaxKind.ReturnStatement:
@@ -591,8 +657,8 @@ class Converter {
             case SyntaxKind.LabeledStatement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.LabeledStatement,
-                    label: this.convertChild(node.label),
                     body: this.convertChild(node.statement),
+                    label: this.convertChild(node.label),
                 });
             case SyntaxKind.ContinueStatement:
                 return this.createNode(node, {
@@ -608,9 +674,9 @@ class Converter {
             case SyntaxKind.IfStatement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.IfStatement,
-                    test: this.convertChild(node.expression),
-                    consequent: this.convertChild(node.thenStatement),
                     alternate: this.convertChild(node.elseStatement),
+                    consequent: this.convertChild(node.thenStatement),
+                    test: this.convertChild(node.expression),
                 });
             case SyntaxKind.SwitchStatement:
                 if (node.caseBlock.clauses.filter(switchCase => switchCase.kind === SyntaxKind.DefaultClause).length > 1) {
@@ -618,18 +684,18 @@ class Converter {
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.SwitchStatement,
-                    discriminant: this.convertChild(node.expression),
                     cases: node.caseBlock.clauses.map(el => this.convertChild(el)),
+                    discriminant: this.convertChild(node.expression),
                 });
             case SyntaxKind.CaseClause:
             case SyntaxKind.DefaultClause:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.SwitchCase,
                     // expression is present in case only
+                    consequent: node.statements.map(el => this.convertChild(el)),
                     test: node.kind === SyntaxKind.CaseClause
                         ? this.convertChild(node.expression)
                         : null,
-                    consequent: node.statements.map(el => this.convertChild(el)),
                 });
             // Exceptions
             case SyntaxKind.ThrowStatement:
@@ -644,8 +710,8 @@ class Converter {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TryStatement,
                     block: this.convertChild(node.tryBlock),
-                    handler: this.convertChild(node.catchClause),
                     finalizer: this.convertChild(node.finallyBlock),
+                    handler: this.convertChild(node.catchClause),
                 });
             case SyntaxKind.CatchClause:
                 if (node.variableDeclaration?.initializer) {
@@ -653,17 +719,17 @@ class Converter {
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.CatchClause,
+                    body: this.convertChild(node.block),
                     param: node.variableDeclaration
                         ? this.convertBindingNameWithTypeAnnotation(node.variableDeclaration.name, node.variableDeclaration.type)
                         : null,
-                    body: this.convertChild(node.block),
                 });
             // Loops
             case SyntaxKind.WhileStatement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.WhileStatement,
-                    test: this.convertChild(node.expression),
                     body: this.convertChild(node.statement),
+                    test: this.convertChild(node.expression),
                 });
             /**
              * Unlike other parsers, TypeScript calls a "DoWhileStatement"
@@ -672,34 +738,34 @@ class Converter {
             case SyntaxKind.DoStatement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.DoWhileStatement,
-                    test: this.convertChild(node.expression),
                     body: this.convertChild(node.statement),
+                    test: this.convertChild(node.expression),
                 });
             case SyntaxKind.ForStatement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ForStatement,
+                    body: this.convertChild(node.statement),
                     init: this.convertChild(node.initializer),
                     test: this.convertChild(node.condition),
                     update: this.convertChild(node.incrementor),
-                    body: this.convertChild(node.statement),
                 });
             case SyntaxKind.ForInStatement:
                 this.#checkForStatementDeclaration(node.initializer, node.kind);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ForInStatement,
+                    body: this.convertChild(node.statement),
                     left: this.convertPattern(node.initializer),
                     right: this.convertChild(node.expression),
-                    body: this.convertChild(node.statement),
                 });
             case SyntaxKind.ForOfStatement: {
                 this.#checkForStatementDeclaration(node.initializer, node.kind);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ForOfStatement,
-                    left: this.convertPattern(node.initializer),
-                    right: this.convertChild(node.expression),
-                    body: this.convertChild(node.statement),
                     await: Boolean(node.awaitModifier &&
                         node.awaitModifier.kind === SyntaxKind.AwaitKeyword),
+                    body: this.convertChild(node.statement),
+                    left: this.convertPattern(node.initializer),
+                    right: this.convertChild(node.expression),
                 });
             }
             // Declarations
@@ -781,7 +847,7 @@ class Converter {
                 }
                 // Definite assignment only allowed for non-declare let and var
                 if (result.declare ||
-                    ['using', 'await using', 'const'].includes(result.kind)) {
+                    ['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.`);
@@ -888,7 +954,7 @@ class Converter {
             }
             case SyntaxKind.PropertyAssignment: {
                 // eslint-disable-next-line @typescript-eslint/no-deprecated
-                const { questionToken, exclamationToken } = node;
+                const { exclamationToken, questionToken } = node;
                 if (questionToken) {
                     this.#throwError(questionToken, 'A property assignment cannot have a question token.');
                 }
@@ -897,18 +963,18 @@ class Converter {
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Property,
-                    key: this.convertChild(node.name),
-                    value: this.converter(node.initializer, node, this.allowPattern),
                     computed: (0, node_utils_1.isComputedProperty)(node.name),
+                    key: this.convertChild(node.name),
+                    kind: 'init',
                     method: false,
                     optional: false,
                     shorthand: false,
-                    kind: 'init',
+                    value: this.converter(node.initializer, node, this.allowPattern),
                 });
             }
             case SyntaxKind.ShorthandPropertyAssignment: {
                 // eslint-disable-next-line @typescript-eslint/no-deprecated
-                const { modifiers, questionToken, exclamationToken } = node;
+                const { exclamationToken, modifiers, questionToken } = node;
                 if (modifiers) {
                     this.#throwError(modifiers[0], 'A shorthand property assignment cannot have modifiers.');
                 }
@@ -921,7 +987,12 @@ class Converter {
                 if (node.objectAssignmentInitializer) {
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.Property,
+                        computed: false,
                         key: this.convertChild(node.name),
+                        kind: 'init',
+                        method: false,
+                        optional: false,
+                        shorthand: true,
                         value: this.createNode(node, {
                             type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern,
                             decorators: [],
@@ -930,11 +1001,6 @@ class Converter {
                             right: this.convertChild(node.objectAssignmentInitializer),
                             typeAnnotation: undefined,
                         }),
-                        computed: false,
-                        method: false,
-                        optional: false,
-                        shorthand: true,
-                        kind: 'init',
                     });
                 }
                 return this.createNode(node, {
@@ -971,25 +1037,25 @@ class Converter {
                 const key = this.convertChild(node.name);
                 return this.createNode(node, {
                     type,
-                    key,
                     accessibility: (0, node_utils_1.getTSNodeAccessibility)(node),
-                    value: isAbstract ? null : this.convertChild(node.initializer),
                     computed: (0, node_utils_1.isComputedProperty)(node.name),
-                    static: (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node),
-                    readonly: (0, node_utils_1.hasModifier)(SyntaxKind.ReadonlyKeyword, node),
-                    decorators: (0, getModifiers_1.getDecorators)(node)?.map(el => this.convertChild(el)) ?? [],
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
-                    override: (0, node_utils_1.hasModifier)(SyntaxKind.OverrideKeyword, node),
-                    typeAnnotation: node.type && this.convertTypeAnnotation(node.type, node),
+                    decorators: (0, getModifiers_1.getDecorators)(node)?.map(el => this.convertChild(el)) ?? [],
+                    definite: !!node.exclamationToken,
+                    key,
                     optional: (key.type === ts_estree_1.AST_NODE_TYPES.Literal ||
                         node.name.kind === SyntaxKind.Identifier ||
                         node.name.kind === SyntaxKind.ComputedPropertyName ||
                         node.name.kind === SyntaxKind.PrivateIdentifier) &&
                         !!node.questionToken,
-                    definite: !!node.exclamationToken,
-                });
-            }
-            case SyntaxKind.GetAccessor:
+                    override: (0, node_utils_1.hasModifier)(SyntaxKind.OverrideKeyword, node),
+                    readonly: (0, node_utils_1.hasModifier)(SyntaxKind.ReadonlyKeyword, node),
+                    static: (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node),
+                    typeAnnotation: node.type && this.convertTypeAnnotation(node.type, node),
+                    value: isAbstract ? null : this.convertChild(node.initializer),
+                });
+            }
+            case SyntaxKind.GetAccessor:
             case SyntaxKind.SetAccessor: {
                 if (node.parent.kind === SyntaxKind.InterfaceDeclaration ||
                     node.parent.kind === SyntaxKind.TypeLiteral) {
@@ -1002,13 +1068,13 @@ class Converter {
                     type: !node.body
                         ? ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression
                         : ts_estree_1.AST_NODE_TYPES.FunctionExpression,
-                    id: null,
-                    generator: !!node.asteriskToken,
-                    expression: false, // ESTreeNode as ESTreeNode here
+                    range: [node.parameters.pos - 1, node.end],
                     async: (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node),
                     body: this.convertChild(node.body),
                     declare: false,
-                    range: [node.parameters.pos - 1, node.end],
+                    expression: false, // ESTreeNode as ESTreeNode here
+                    generator: !!node.asteriskToken,
+                    id: null,
                     params: [],
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
                     typeParameters: node.typeParameters &&
@@ -1022,13 +1088,13 @@ class Converter {
                     method.params = node.parameters.map(el => this.convertChild(el));
                     result = this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.Property,
-                        key: this.convertChild(node.name),
-                        value: method,
                         computed: (0, node_utils_1.isComputedProperty)(node.name),
-                        optional: !!node.questionToken,
+                        key: this.convertChild(node.name),
+                        kind: 'init',
                         method: node.kind === SyntaxKind.MethodDeclaration,
+                        optional: !!node.questionToken,
                         shorthand: false,
-                        kind: 'init',
+                        value: method,
                     });
                 }
                 else {
@@ -1079,6 +1145,7 @@ class Converter {
                     type: !node.body
                         ? ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression
                         : ts_estree_1.AST_NODE_TYPES.FunctionExpression,
+                    range: [node.parameters.pos - 1, node.end],
                     async: false,
                     body: this.convertChild(node.body),
                     declare: false,
@@ -1086,7 +1153,6 @@ class Converter {
                     generator: false,
                     id: null,
                     params: this.convertParameters(node.parameters),
-                    range: [node.parameters.pos - 1, node.end],
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
                     typeParameters: node.typeParameters &&
                         this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
@@ -1096,10 +1162,10 @@ class Converter {
                 }
                 const constructorKey = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Identifier,
+                    range: [constructorToken.getStart(this.ast), constructorToken.end],
                     decorators: [],
                     name: 'constructor',
                     optional: false,
-                    range: [constructorToken.getStart(this.ast), constructorToken.end],
                     typeAnnotation: undefined,
                 });
                 const isStatic = (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node);
@@ -1110,9 +1176,9 @@ class Converter {
                     accessibility: (0, node_utils_1.getTSNodeAccessibility)(node),
                     computed: false,
                     decorators: [],
-                    optional: false,
                     key: constructorKey,
                     kind: isStatic ? 'method' : 'constructor',
+                    optional: false,
                     override: false,
                     static: isStatic,
                     value: constructor,
@@ -1195,23 +1261,23 @@ class Converter {
                 else {
                     result = this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.Property,
-                        key: this.convertChild(node.propertyName ?? node.name),
-                        value: this.convertChild(node.name),
                         computed: Boolean(node.propertyName &&
                             node.propertyName.kind === SyntaxKind.ComputedPropertyName),
+                        key: this.convertChild(node.propertyName ?? node.name),
+                        kind: 'init',
                         method: false,
                         optional: false,
                         shorthand: !node.propertyName,
-                        kind: 'init',
+                        value: this.convertChild(node.name),
                     });
                 }
                 if (node.initializer) {
                     result.value = this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.AssignmentPattern,
+                        range: [node.name.getStart(this.ast), node.initializer.end],
                         decorators: [],
                         left: this.convertChild(node.name),
                         optional: false,
-                        range: [node.name.getStart(this.ast), node.initializer.end],
                         right: this.convertChild(node.initializer),
                         typeAnnotation: undefined,
                     });
@@ -1221,12 +1287,12 @@ class Converter {
             case SyntaxKind.ArrowFunction: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ArrowFunctionExpression,
+                    async: (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node),
+                    body: this.convertChild(node.body),
+                    expression: node.body.kind !== SyntaxKind.Block,
                     generator: false,
                     id: null,
                     params: this.convertParameters(node.parameters),
-                    body: this.convertChild(node.body),
-                    async: (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node),
-                    expression: node.body.kind !== SyntaxKind.Block,
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
                     typeParameters: node.typeParameters &&
                         this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
@@ -1235,8 +1301,8 @@ class Converter {
             case SyntaxKind.YieldExpression:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.YieldExpression,
-                    delegate: !!node.asteriskToken,
                     argument: this.convertChild(node.expression),
+                    delegate: !!node.asteriskToken,
                 });
             case SyntaxKind.AwaitExpression:
                 return this.createNode(node, {
@@ -1247,23 +1313,23 @@ class Converter {
             case SyntaxKind.NoSubstitutionTemplateLiteral:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TemplateLiteral,
+                    expressions: [],
                     quasis: [
                         this.createNode(node, {
                             type: ts_estree_1.AST_NODE_TYPES.TemplateElement,
+                            tail: true,
                             value: {
-                                raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - 1),
                                 cooked: node.text,
+                                raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - 1),
                             },
-                            tail: true,
                         }),
                     ],
-                    expressions: [],
                 });
             case SyntaxKind.TemplateExpression: {
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TemplateLiteral,
-                    quasis: [this.convertChild(node.head)],
                     expressions: [],
+                    quasis: [this.convertChild(node.head)],
                 });
                 node.templateSpans.forEach(templateSpan => {
                     result.expressions.push(this.convertChild(templateSpan.expression));
@@ -1274,10 +1340,10 @@ class Converter {
             case SyntaxKind.TaggedTemplateExpression:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TaggedTemplateExpression,
+                    quasi: this.convertChild(node.template),
+                    tag: this.convertChild(node.tag),
                     typeArguments: node.typeArguments &&
                         this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
-                    tag: this.convertChild(node.tag),
-                    quasi: this.convertChild(node.template),
                 });
             case SyntaxKind.TemplateHead:
             case SyntaxKind.TemplateMiddle:
@@ -1285,11 +1351,11 @@ class Converter {
                 const tail = node.kind === SyntaxKind.TemplateTail;
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TemplateElement,
+                    tail,
                     value: {
-                        raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - (tail ? 1 : 2)),
                         cooked: node.text,
+                        raw: this.ast.text.slice(node.getStart(this.ast) + 1, node.end - (tail ? 1 : 2)),
                     },
-                    tail,
                 });
             }
             // Patterns
@@ -1412,10 +1478,10 @@ class Converter {
                     abstract: (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node),
                     body: this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.ClassBody,
+                        range: [node.members.pos - 1, node.end],
                         body: node.members
                             .filter(node_utils_1.isESTreeClassMember)
                             .map(el => this.convertChild(el)),
-                        range: [node.members.pos - 1, node.end],
                     }),
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
                     decorators: (0, getModifiers_1.getDecorators)(node)?.map(el => this.convertChild(el)) ?? [],
@@ -1444,12 +1510,12 @@ class Converter {
                 this.assertModuleSpecifier(node, false);
                 const result = this.createNode(node, this.#withDeprecatedAliasGetter({
                     type: ts_estree_1.AST_NODE_TYPES.ImportDeclaration,
-                    source: this.convertChild(node.moduleSpecifier),
-                    specifiers: [],
-                    importKind: 'value',
                     attributes: this.convertImportAttributes(
                     // eslint-disable-next-line @typescript-eslint/no-deprecated
                     node.attributes ?? node.assertClause),
+                    importKind: 'value',
+                    source: this.convertChild(node.moduleSpecifier),
+                    specifiers: [],
                 }, 'assertions', 'attributes', true));
                 if (node.importClause) {
                     if (node.importClause.isTypeOnly) {
@@ -1479,16 +1545,16 @@ class Converter {
             case SyntaxKind.ImportSpecifier:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ImportSpecifier,
-                    local: this.convertChild(node.name),
                     imported: this.convertChild(node.propertyName ?? node.name),
                     importKind: node.isTypeOnly ? 'type' : 'value',
+                    local: this.convertChild(node.name),
                 });
             case SyntaxKind.ImportClause: {
                 const local = this.convertChild(node.name);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ImportDefaultSpecifier,
-                    local,
                     range: local.range,
+                    local,
                 });
             }
             case SyntaxKind.ExportDeclaration: {
@@ -1496,26 +1562,26 @@ class Converter {
                     this.assertModuleSpecifier(node, true);
                     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, node)),
-                        exportKind: node.isTypeOnly ? 'type' : 'value',
-                        declaration: null,
                         attributes: this.convertImportAttributes(
                         // eslint-disable-next-line @typescript-eslint/no-deprecated
                         node.attributes ?? node.assertClause),
+                        declaration: null,
+                        exportKind: node.isTypeOnly ? 'type' : 'value',
+                        source: this.convertChild(node.moduleSpecifier),
+                        specifiers: node.exportClause.elements.map(el => this.convertChild(el, node)),
                     }, 'assertions', 'attributes', true));
                 }
                 this.assertModuleSpecifier(node, false);
                 return this.createNode(node, this.#withDeprecatedAliasGetter({
                     type: ts_estree_1.AST_NODE_TYPES.ExportAllDeclaration,
-                    source: this.convertChild(node.moduleSpecifier),
-                    exportKind: node.isTypeOnly ? 'type' : 'value',
-                    exported: node.exportClause?.kind === SyntaxKind.NamespaceExport
-                        ? this.convertChild(node.exportClause.name)
-                        : null,
                     attributes: this.convertImportAttributes(
                     // eslint-disable-next-line @typescript-eslint/no-deprecated
                     node.attributes ?? node.assertClause),
+                    exported: node.exportClause?.kind === SyntaxKind.NamespaceExport
+                        ? this.convertChild(node.exportClause.name)
+                        : null,
+                    exportKind: node.isTypeOnly ? 'type' : 'value',
+                    source: this.convertChild(node.moduleSpecifier),
                 }, 'assertions', 'attributes', true));
             }
             case SyntaxKind.ExportSpecifier: {
@@ -1527,9 +1593,9 @@ class Converter {
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ExportSpecifier,
-                    local: this.convertChild(local),
                     exported: this.convertChild(node.name),
                     exportKind: node.isTypeOnly ? 'type' : 'value',
+                    local: this.convertChild(local),
                 });
             }
             case SyntaxKind.ExportAssignment:
@@ -1557,38 +1623,38 @@ class Converter {
                     }
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.UpdateExpression,
+                        argument: this.convertChild(node.operand),
                         operator,
                         prefix: node.kind === SyntaxKind.PrefixUnaryExpression,
-                        argument: this.convertChild(node.operand),
                     });
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.UnaryExpression,
+                    argument: this.convertChild(node.operand),
                     operator,
                     prefix: node.kind === SyntaxKind.PrefixUnaryExpression,
-                    argument: this.convertChild(node.operand),
                 });
             }
             case SyntaxKind.DeleteExpression:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.UnaryExpression,
+                    argument: this.convertChild(node.expression),
                     operator: 'delete',
                     prefix: true,
-                    argument: this.convertChild(node.expression),
                 });
             case SyntaxKind.VoidExpression:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.UnaryExpression,
+                    argument: this.convertChild(node.expression),
                     operator: 'void',
                     prefix: true,
-                    argument: this.convertChild(node.expression),
                 });
             case SyntaxKind.TypeOfExpression:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.UnaryExpression,
+                    argument: this.convertChild(node.expression),
                     operator: 'typeof',
                     prefix: true,
-                    argument: this.convertChild(node.expression),
                 });
             case SyntaxKind.TypeOperator:
                 return this.createNode(node, {
@@ -1639,10 +1705,10 @@ class Converter {
                 const computed = false;
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.MemberExpression,
-                    object,
-                    property,
                     computed,
+                    object,
                     optional: node.questionDotToken !== undefined,
+                    property,
                 });
                 return this.convertChainExpression(result, node);
             }
@@ -1652,10 +1718,10 @@ class Converter {
                 const computed = true;
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.MemberExpression,
-                    object,
-                    property,
                     computed,
+                    object,
                     optional: node.questionDotToken !== undefined,
+                    property,
                 });
                 return this.convertChainExpression(result, node);
             }
@@ -1666,10 +1732,10 @@ class Converter {
                     }
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.ImportExpression,
-                        source: this.convertChild(node.arguments[0]),
                         attributes: node.arguments[1]
                             ? this.convertChild(node.arguments[1])
                             : null,
+                        source: this.convertChild(node.arguments[0]),
                     });
                 }
                 const callee = this.convertChild(node.expression);
@@ -1678,8 +1744,8 @@ class Converter {
                     this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.CallExpression,
-                    callee,
                     arguments: args,
+                    callee,
                     optional: node.questionDotToken !== undefined,
                     typeArguments,
                 });
@@ -1701,9 +1767,9 @@ class Converter {
             case SyntaxKind.ConditionalExpression:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ConditionalExpression,
-                    test: this.convertChild(node.condition),
-                    consequent: this.convertChild(node.whenTrue),
                     alternate: this.convertChild(node.whenFalse),
+                    consequent: this.convertChild(node.whenTrue),
+                    test: this.convertChild(node.condition),
                 });
             case SyntaxKind.MetaProperty: {
                 return this.createNode(node, {
@@ -1730,17 +1796,17 @@ class Converter {
             case SyntaxKind.StringLiteral: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
+                    raw: node.getText(),
                     value: parent.kind === SyntaxKind.JsxAttribute
                         ? (0, node_utils_1.unescapeStringLiteralText)(node.text)
                         : node.text,
-                    raw: node.getText(),
                 });
             }
             case SyntaxKind.NumericLiteral: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
-                    value: Number(node.text),
                     raw: node.getText(),
+                    value: Number(node.text),
                 });
             }
             case SyntaxKind.BigIntLiteral: {
@@ -1755,10 +1821,10 @@ class Converter {
                 const value = typeof BigInt !== 'undefined' ? BigInt(bigint) : null;
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
+                    range,
+                    bigint: value == null ? bigint : String(value),
                     raw: rawValue,
                     value,
-                    bigint: value == null ? bigint : String(value),
-                    range,
                 });
             }
             case SyntaxKind.RegularExpressionLiteral: {
@@ -1773,31 +1839,31 @@ class Converter {
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
-                    value: regex,
                     raw: node.text,
                     regex: {
-                        pattern,
                         flags,
+                        pattern,
                     },
+                    value: regex,
                 });
             }
             case SyntaxKind.TrueKeyword:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
-                    value: true,
                     raw: 'true',
+                    value: true,
                 });
             case SyntaxKind.FalseKeyword:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
-                    value: false,
                     raw: 'false',
+                    value: false,
                 });
             case SyntaxKind.NullKeyword: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Literal,
-                    value: null,
                     raw: 'null',
+                    value: null,
                 });
             }
             case SyntaxKind.EmptyStatement:
@@ -1812,16 +1878,16 @@ class Converter {
             case SyntaxKind.JsxElement:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXElement,
-                    openingElement: this.convertChild(node.openingElement),
-                    closingElement: this.convertChild(node.closingElement),
                     children: node.children.map(el => this.convertChild(el)),
+                    closingElement: this.convertChild(node.closingElement),
+                    openingElement: this.convertChild(node.openingElement),
                 });
             case SyntaxKind.JsxFragment:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXFragment,
-                    openingFragment: this.convertChild(node.openingFragment),
-                    closingFragment: this.convertChild(node.closingFragment),
                     children: node.children.map(el => this.convertChild(el)),
+                    closingFragment: this.convertChild(node.closingFragment),
+                    openingFragment: this.convertChild(node.openingFragment),
                 });
             case SyntaxKind.JsxSelfClosingElement: {
                 return this.createNode(node, {
@@ -1830,28 +1896,28 @@ class Converter {
                      * 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: ts_estree_1.AST_NODE_TYPES.JSXOpeningElement,
+                        range: (0, node_utils_1.getRange)(node, this.ast),
+                        attributes: node.attributes.properties.map(el => this.convertChild(el)),
+                        name: this.convertJSXTagName(node.tagName, node),
+                        selfClosing: true,
                         typeArguments: node.typeArguments
                             ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
                             : undefined,
-                        selfClosing: true,
-                        name: this.convertJSXTagName(node.tagName, node),
-                        attributes: node.attributes.properties.map(el => this.convertChild(el)),
-                        range: (0, node_utils_1.getRange)(node, this.ast),
                     }),
-                    closingElement: null,
-                    children: [],
                 });
             }
             case SyntaxKind.JsxOpeningElement: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXOpeningElement,
+                    attributes: node.attributes.properties.map(el => this.convertChild(el)),
+                    name: this.convertJSXTagName(node.tagName, node),
+                    selfClosing: false,
                     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)),
                 });
             }
             case SyntaxKind.JsxClosingElement:
@@ -1898,9 +1964,9 @@ class Converter {
                 const text = this.ast.text.slice(start, end);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.JSXText,
-                    value: (0, node_utils_1.unescapeStringLiteralText)(text),
-                    raw: text,
                     range: [start, end],
+                    raw: text,
+                    value: (0, node_utils_1.unescapeStringLiteralText)(text),
                 });
             }
             case SyntaxKind.JsxSpreadAttribute:
@@ -1919,19 +1985,19 @@ class Converter {
             case SyntaxKind.TypeReference:
                 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),
+                    typeName: this.convertChild(node.typeName),
                 });
             case SyntaxKind.TypeParameter: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeParameter,
-                    name: this.convertChild(node.name),
+                    const: (0, node_utils_1.hasModifier)(SyntaxKind.ConstKeyword, node),
                     constraint: node.constraint && this.convertChild(node.constraint),
                     default: node.default ? this.convertChild(node.default) : undefined,
                     in: (0, node_utils_1.hasModifier)(SyntaxKind.InKeyword, node),
+                    name: this.convertChild(node.name),
                     out: (0, node_utils_1.hasModifier)(SyntaxKind.OutKeyword, node),
-                    const: (0, node_utils_1.hasModifier)(SyntaxKind.ConstKeyword, node),
                 });
             }
             case SyntaxKind.ThisType:
@@ -1976,8 +2042,8 @@ class Converter {
             case SyntaxKind.IndexedAccessType: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSIndexedAccessType,
-                    objectType: this.convertChild(node.objectType),
                     indexType: this.convertChild(node.indexType),
+                    objectType: this.convertChild(node.objectType),
                 });
             }
             case SyntaxKind.ConditionalType: {
@@ -1985,8 +2051,8 @@ class Converter {
                     type: ts_estree_1.AST_NODE_TYPES.TSConditionalType,
                     checkType: this.convertChild(node.checkType),
                     extendsType: this.convertChild(node.extendsType),
-                    trueType: this.convertChild(node.trueType),
                     falseType: this.convertChild(node.falseType),
+                    trueType: this.convertChild(node.trueType),
                 });
             }
             case SyntaxKind.TypeQuery:
@@ -2121,8 +2187,8 @@ class Converter {
                     type: ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration,
                     body: this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.TSInterfaceBody,
-                        body: node.members.map(member => this.convertChild(member)),
                         range: [node.members.pos - 1, node.end],
+                        body: node.members.map(member => this.convertChild(member)),
                     }),
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
                     extends: interfaceExtends,
@@ -2158,12 +2224,12 @@ class Converter {
                 }
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSImportType,
+                    range,
                     argument: this.convertChild(node.argument),
                     qualifier: this.convertChild(node.qualifier),
                     typeArguments: node.typeArguments
                         ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
                         : null,
-                    range,
                 });
                 if (node.isTypeOf) {
                     return this.createNode(node, {
@@ -2180,8 +2246,8 @@ class Converter {
                     type: ts_estree_1.AST_NODE_TYPES.TSEnumDeclaration,
                     body: this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.TSEnumBody,
-                        members,
                         range: [node.members.pos - 1, node.end],
+                        members,
                     }),
                     const: (0, node_utils_1.hasModifier)(SyntaxKind.ConstKeyword, node),
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
@@ -2215,11 +2281,11 @@ class Converter {
                                 this.#throwUnlessAllowInvalidAST(node.name, 'global module augmentation must have an Identifier id');
                             }
                             return {
-                                kind: 'global',
                                 body: body,
                                 declare: false,
                                 global: false,
                                 id,
+                                kind: 'global',
                             };
                         }
                         if (!(node.flags & ts.NodeFlags.Namespace)) {
@@ -2242,11 +2308,11 @@ class Converter {
                             this.#throwUnlessAllowInvalidAST(node.name, '`namespace`s must have an Identifier id');
                         }
                         let name = this.createNode(node.name, {
+                            type: ts_estree_1.AST_NODE_TYPES.Identifier,
+                            range: [node.name.getStart(this.ast), node.name.getEnd()],
                             decorators: [],
                             name: node.name.text,
                             optional: false,
-                            range: [node.name.getStart(this.ast), node.name.getEnd()],
-                            type: ts_estree_1.AST_NODE_TYPES.Identifier,
                             typeAnnotation: undefined,
                         });
                         while (node.body &&
@@ -2256,26 +2322,26 @@ class Converter {
                             isDeclare ||= (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node);
                             const nextName = node.name;
                             const right = this.createNode(nextName, {
+                                type: ts_estree_1.AST_NODE_TYPES.Identifier,
+                                range: [nextName.getStart(this.ast), nextName.getEnd()],
                                 decorators: [],
                                 name: nextName.text,
                                 optional: false,
-                                range: [nextName.getStart(this.ast), nextName.getEnd()],
-                                type: ts_estree_1.AST_NODE_TYPES.Identifier,
                                 typeAnnotation: undefined,
                             });
                             name = this.createNode(nextName, {
+                                type: ts_estree_1.AST_NODE_TYPES.TSQualifiedName,
+                                range: [name.range[0], right.range[1]],
                                 left: name,
                                 right,
-                                range: [name.range[0], right.range[1]],
-                                type: ts_estree_1.AST_NODE_TYPES.TSQualifiedName,
                             });
                         }
                         return {
-                            kind: 'namespace',
                             body: this.convertChild(node.body),
                             declare: false,
                             global: false,
                             id: name,
+                            kind: 'namespace',
                         };
                     })(),
                 });
@@ -2331,8 +2397,8 @@ class Converter {
             case SyntaxKind.TypeAssertionExpression: {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeAssertion,
-                    typeAnnotation: this.convertChild(node.type),
                     expression: this.convertChild(node.expression),
+                    typeAnnotation: this.convertChild(node.type),
                 });
             }
             case SyntaxKind.ImportEqualsDeclaration: {
@@ -2440,230 +2506,164 @@ class Converter {
                 return this.deeplyCopy(node);
         }
     }
-    #checkModifiers(node) {
-        if (this.options.allowInvalidAST) {
-            return;
+    createNode(
+    // The 'parent' property will be added later if specified
+    node, data) {
+        const result = data;
+        result.range ??= (0, node_utils_1.getRange)(node, this.ast);
+        result.loc ??= (0, node_utils_1.getLocFor)(result.range, this.ast);
+        if (result && this.options.shouldPreserveNodeMaps) {
+            this.esTreeNodeToTSNodeMap.set(result, node);
         }
-        // typescript<5.0.0
-        if ((0, node_utils_1.nodeHasIllegalDecorators)(node)) {
-            this.#throwError(node.illegalDecorators[0], 'Decorators are not valid here.');
+        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.');
         }
-        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.');
-                }
-            }
+        const customType = `TS${SyntaxKind[node.kind]}`;
+        /**
+         * If the "errorOnUnknownASTType" option is set to true, throw an error,
+         * otherwise fallback to just including the unknown type as-is.
+         */
+        if (this.options.errorOnUnknownASTType && !ts_estree_1.AST_NODE_TYPES[customType]) {
+            throw new Error(`Unknown AST_NODE_TYPE: "${customType}"`);
         }
-        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.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.');
-                }
-            }
+        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;
         }
-    }
-    #throwUnlessAllowInvalidAST(node, message) {
-        if (!this.options.allowInvalidAST) {
-            this.#throwError(node, message);
+        if ('typeArguments' in node) {
+            result.typeArguments =
+                node.typeArguments && 'pos' in node.typeArguments
+                    ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+                    : null;
         }
-    }
-    /**
-     * 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,
-                });
-            },
-        });
-        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,
-                });
-            },
-        });
-        return node;
-    }
-    #throwError(node, message) {
-        let start;
-        let end;
-        if (typeof node === 'number') {
-            start = end = node;
+        if ('typeParameters' in node) {
+            result.typeParameters =
+                node.typeParameters && 'pos' in node.typeParameters
+                    ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+                    : null;
         }
-        else {
-            start = node.getStart(this.ast);
-            end = node.getEnd();
+        const decorators = (0, getModifiers_1.getDecorators)(node);
+        if (decorators?.length) {
+            result.decorators = decorators.map(el => this.convertChild(el));
         }
-        throw (0, node_utils_1.createError)(message, this.ast, start, end);
-    }
-    #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.`);
+        // keys we never want to clone from the base typescript node as they
+        // introduce garbage into our AST
+        const KEYS_TO_NOT_COPY = 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] = value.map(el => this.convertChild(el));
             }
-            const declaration = initializer.declarations[0];
-            if (declaration.initializer) {
-                this.#throwError(declaration, `The variable declaration of a '${loop}' statement cannot have an initializer.`);
+            else if (value && typeof value === 'object' && value.kind) {
+                // need to check node[key].kind to ensure we don't try to convert a symbol
+                result[key] = this.convertChild(value);
             }
-            else if (declaration.type) {
-                this.#throwError(declaration, `The variable declaration of a '${loop}' statement cannot have a type annotation.`);
+            else {
+                result[key] = value;
             }
-            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.");
+        });
+        return result;
+    }
+    /**
+     * Fixes the exports of the given ts.Node
+     * @returns the ESTreeNode with fixed exports
+     */
+    fixExports(node, result) {
+        const isNamespaceNode = ts.isModuleDeclaration(node) &&
+            Boolean(node.flags & ts.NodeFlags.Namespace);
+        const modifiers = isNamespaceNode
+            ? (0, node_utils_1.getNamespaceModifiers)(node)
+            : (0, getModifiers_1.getModifiers)(node);
+        if (modifiers?.[0].kind === SyntaxKind.ExportKeyword) {
+            /**
+             * Make sure that original node is registered instead of export
+             */
+            this.registerTSNodeInNodeMap(node, result);
+            const exportKeyword = modifiers[0];
+            const nextModifier = modifiers[1];
+            const declarationIsDefault = nextModifier?.kind === SyntaxKind.DefaultKeyword;
+            const varToken = declarationIsDefault
+                ? (0, node_utils_1.findNextToken)(nextModifier, this.ast, this.ast)
+                : (0, node_utils_1.findNextToken)(exportKeyword, this.ast, this.ast);
+            result.range[0] = varToken.getStart(this.ast);
+            result.loc = (0, node_utils_1.getLocFor)(result.range, this.ast);
+            if (declarationIsDefault) {
+                return this.createNode(node, {
+                    type: ts_estree_1.AST_NODE_TYPES.ExportDefaultDeclaration,
+                    range: [exportKeyword.getStart(this.ast), result.range[1]],
+                    declaration: result,
+                    exportKind: 'value',
+                });
             }
+            const isType = result.type === ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+                result.type === ts_estree_1.AST_NODE_TYPES.TSTypeAliasDeclaration;
+            const isDeclare = 'declare' in result && result.declare;
+            return this.createNode(node, 
+            // @ts-expect-error - TODO, narrow the types here
+            this.#withDeprecatedAliasGetter({
+                type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration,
+                range: [exportKeyword.getStart(this.ast), result.range[1]],
+                attributes: [],
+                declaration: result,
+                exportKind: isType || isDeclare ? 'type' : 'value',
+                source: null,
+                specifiers: [],
+            }, 'assertions', 'attributes', true));
         }
-        else if (!(0, node_utils_1.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.`);
+        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);
         }
     }
 }