@putout/babel 5.3.4 → 5.3.6

package/bundle/index.js

@@ -414,6 +414,7 @@ __export(lib_exports, {
     BOOLEAN_UNARY_OPERATORS: () => BOOLEAN_UNARY_OPERATORS,
     BUILDER_KEYS: () => BUILDER_KEYS,
     BigIntLiteral: () => BigIntLiteral,
+    BigIntLiteralTypeAnnotation: () => BigIntLiteralTypeAnnotation,
     BinaryExpression: () => BinaryExpression,
     BindExpression: () => BindExpression,
     BlockStatement: () => BlockStatement,
@@ -743,6 +744,7 @@ __export(lib_exports, {
     assertAssignmentPattern: () => assertAssignmentPattern,
     assertAwaitExpression: () => assertAwaitExpression,
     assertBigIntLiteral: () => assertBigIntLiteral,
+    assertBigIntLiteralTypeAnnotation: () => assertBigIntLiteralTypeAnnotation,
     assertBinary: () => assertBinary,
     assertBinaryExpression: () => assertBinaryExpression,
     assertBindExpression: () => assertBindExpression,
@@ -1039,6 +1041,7 @@ __export(lib_exports, {
     assignmentPattern: () => assignmentPattern,
     awaitExpression: () => awaitExpression,
     bigIntLiteral: () => bigIntLiteral,
+    bigIntLiteralTypeAnnotation: () => bigIntLiteralTypeAnnotation,
     binaryExpression: () => binaryExpression,
     bindExpression: () => bindExpression,
     blockStatement: () => blockStatement,
@@ -1153,6 +1156,7 @@ __export(lib_exports, {
     isAssignmentPattern: () => isAssignmentPattern,
     isAwaitExpression: () => isAwaitExpression,
     isBigIntLiteral: () => isBigIntLiteral,
+    isBigIntLiteralTypeAnnotation: () => isBigIntLiteralTypeAnnotation,
     isBinary: () => isBinary,
     isBinaryExpression: () => isBinaryExpression,
     isBindExpression: () => isBindExpression,
@@ -3832,16 +3836,6 @@ function isImportSpecifier(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
-function isImportExpression(node, opts) {
-    if (!node)
-        return false;
-    
-    if (node.type !== 'ImportExpression')
-        return false;
-    
-    return opts == null || shallowEqual(node, opts);
-}
-
 function isMetaProperty(node, opts) {
     if (!node)
         return false;
@@ -3942,6 +3936,16 @@ function isAwaitExpression(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
+function isImportExpression(node, opts) {
+    if (!node)
+        return false;
+    
+    if (node.type !== 'ImportExpression')
+        return false;
+    
+    return opts == null || shallowEqual(node, opts);
+}
+
 function isImport(node, opts) {
     if (!node)
         return false;
@@ -4352,6 +4356,16 @@ function isNumberLiteralTypeAnnotation(node, opts) {
     return opts == null || shallowEqual(node, opts);
 }
 
+function isBigIntLiteralTypeAnnotation(node, opts) {
+    if (!node)
+        return false;
+    
+    if (node.type !== 'BigIntLiteralTypeAnnotation')
+        return false;
+    
+    return opts == null || shallowEqual(node, opts);
+}
+
 function isNumberTypeAnnotation(node, opts) {
     if (!node)
         return false;
@@ -5713,7 +5727,6 @@ function isStandardized(node, opts) {
     case 'ImportDefaultSpecifier':    
     case 'ImportNamespaceSpecifier':    
     case 'ImportSpecifier':    
-    case 'ImportExpression':    
     case 'MetaProperty':    
     case 'ClassMethod':    
     case 'ObjectPattern':    
@@ -5724,6 +5737,7 @@ function isStandardized(node, opts) {
     case 'TemplateLiteral':    
     case 'YieldExpression':    
     case 'AwaitExpression':    
+    case 'ImportExpression':    
     case 'Import':    
     case 'BigIntLiteral':    
     case 'ExportNamespaceSpecifier':    
@@ -5787,13 +5801,12 @@ function isExpression(node, opts) {
     case 'UpdateExpression':    
     case 'ArrowFunctionExpression':    
     case 'ClassExpression':    
-    case 'ImportExpression':    
     case 'MetaProperty':    
     case 'TaggedTemplateExpression':    
     case 'TemplateLiteral':    
     case 'YieldExpression':    
     case 'AwaitExpression':    
-    case 'Import':    
+    case 'ImportExpression':    
     case 'BigIntLiteral':    
     case 'OptionalMemberExpression':    
     case 'OptionalCallExpression':    
@@ -7646,6 +7659,29 @@ var classMethodOrPropertyUnionShapeCommon = (allowPrivateName = false) => ({
     },
 });
 
+var memberExpressionUnionShapeCommon = {
+    unionShape: {
+        discriminator: 'computed',
+        shapes: [{
+            name: 'computed',
+            value: [true],
+            properties: {
+                property: {
+                    validate: assertNodeType('Expression'),
+                },
+            },
+        }, {
+            name: 'nonComputed',
+            value: [false],
+            properties: {
+                property: {
+                    validate: assertNodeType('Identifier', 'PrivateName'),
+                },
+            },
+        }],
+    },
+};
+
 var defineType$4 = defineAliasedType('Standardized');
 
 defineType$4('ArrayExpression', {
@@ -7716,6 +7752,26 @@ defineType$4('BinaryExpression', {
             validate: assertNodeType('Expression'),
         },
     },
+    unionShape: {
+        discriminator: 'operator',
+        shapes: [{
+            name: 'in',
+            value: ['in'],
+            properties: {
+                left: {
+                    validate: assertNodeType('Expression', 'PrivateName'),
+                },
+            },
+        }, {
+            name: 'notIn',
+            value: BINARY_OPERATORS.filter((op) => op !== 'in'),
+            properties: {
+                left: {
+                    validate: assertNodeType('Expression'),
+                },
+            },
+        }],
+    },
     visitor: ['left', 'right'],
     aliases: ['Binary', 'Expression'],
 });
@@ -7784,7 +7840,7 @@ defineType$4('CallExpression', {
     aliases: ['Expression'],
     fields: {
         callee: {
-            validate: assertNodeType('Expression', 'Super', 'V8IntrinsicIdentifier'),
+            validate: assertNodeType('Expression', 'Super', 'Import', 'V8IntrinsicIdentifier'),
         },
         arguments: validateArrayOfType('Expression', 'SpreadElement', 'ArgumentPlaceholder'),
         typeArguments: {
@@ -8010,7 +8066,7 @@ defineType$4('FunctionDeclaration', {
             validate: assertNodeType('BlockStatement'),
         },
         predicate: {
-            validate: assertNodeType('DeclaredPredicate', 'InferredPredicate'),
+            validate: assertNodeType('FlowPredicate'),
             optional: true,
         },
     },
@@ -8054,7 +8110,7 @@ defineType$4('FunctionExpression', {
             validate: assertNodeType('BlockStatement'),
         },
         predicate: {
-            validate: assertNodeType('DeclaredPredicate', 'InferredPredicate'),
+            validate: assertNodeType('FlowPredicate'),
             optional: true,
         },
     },
@@ -8282,7 +8338,6 @@ defineType$4('MemberExpression', {
         'object',
         'property',
         'computed',
-        ...[],
     ],
     visitor: ['object', 'property'],
     aliases: [
@@ -8290,26 +8345,7 @@ defineType$4('MemberExpression', {
         'LVal',
         'PatternLike',
     ],
-    unionShape: {
-        discriminator: 'computed',
-        shapes: [{
-            name: 'computed',
-            value: [true],
-            properties: {
-                property: {
-                    validate: assertNodeType('Expression'),
-                },
-            },
-        }, {
-            name: 'nonComputed',
-            value: [false],
-            properties: {
-                property: {
-                    validate: assertNodeType('Identifier', 'PrivateName'),
-                },
-            },
-        }],
-    },
+    ...memberExpressionUnionShapeCommon,
     fields: {
         object: {
             validate: assertNodeType('Expression', 'Super'),
@@ -8447,28 +8483,8 @@ defineType$4('ObjectProperty', {
         'value',
         'computed',
         'shorthand',
-        ...[],
     ],
-    unionShape: {
-        discriminator: 'computed',
-        shapes: [{
-            name: 'computed',
-            value: [true],
-            properties: {
-                key: {
-                    validate: assertNodeType('Expression'),
-                },
-            },
-        }, {
-            name: 'nonComputed',
-            value: [false],
-            properties: {
-                key: {
-                    validate: assertNodeType('Identifier', 'StringLiteral', 'NumericLiteral', 'BigIntLiteral', 'PrivateName'),
-                },
-            },
-        }],
-    },
+    ...classMethodOrPropertyUnionShapeCommon(true),
     fields: {
         computed: {
             default: false,
@@ -8876,7 +8892,7 @@ defineType$4('ArrowFunctionExpression', {
             validate: assertNodeType('BlockStatement', 'Expression'),
         },
         predicate: {
-            validate: assertNodeType('DeclaredPredicate', 'InferredPredicate'),
+            validate: assertNodeType('FlowPredicate'),
             optional: true,
         },
     },
@@ -9034,7 +9050,7 @@ defineType$4('ExportDefaultDeclaration', {
         'ExportDeclaration',
     ],
     fields: {
-        declaration: validateType('TSDeclareFunction', 'FunctionDeclaration', 'ClassDeclaration', 'Expression'),
+        declaration: validateType('FunctionDeclaration', 'ClassDeclaration', 'Expression', 'TSDeclareFunction', 'TSInterfaceDeclaration', 'EnumDeclaration'),
         exportKind: validateOptional(assertOneOf('value')),
     },
 });
@@ -9069,7 +9085,21 @@ defineType$4('ExportNamedDeclaration', {
                     throw new TypeError('Cannot export a declaration from a source');
                 }
             }, {
-                oneOfNodeTypes: ['Declaration'],
+                oneOfNodeTypes: [
+                    'VariableDeclaration',
+                    'FunctionDeclaration',
+                    'ClassDeclaration',
+                    'TSDeclareFunction',
+                    'TSEnumDeclaration',
+                    'TSImportEqualsDeclaration',
+                    'TSInterfaceDeclaration',
+                    'TSModuleDeclaration',
+                    'TSTypeAliasDeclaration',
+                    'EnumDeclaration',
+                    'InterfaceDeclaration',
+                    'OpaqueType',
+                    'TypeAlias',
+                ],
             })),
         },
         ...importAttributes,
@@ -9243,23 +9273,6 @@ defineType$4('ImportSpecifier', {
         },
     },
 });
-defineType$4('ImportExpression', {
-    visitor: ['source', 'options'],
-    aliases: ['Expression'],
-    fields: {
-        phase: {
-            default: null,
-            validate: assertOneOf('source', 'defer'),
-        },
-        source: {
-            validate: assertNodeType('Expression'),
-        },
-        options: {
-            validate: assertNodeType('Expression'),
-            optional: true,
-        },
-    },
-});
 defineType$4('MetaProperty', {
     visitor: ['meta', 'property'],
     aliases: ['Expression'],
@@ -9415,7 +9428,7 @@ defineType$4('SpreadElement', {
         },
     },
 });
-defineType$4('Super', void 0);
+defineType$4('Super');
 defineType$4('TaggedTemplateExpression', {
     visitor: [
         'tag',
@@ -9528,9 +9541,24 @@ defineType$4('AwaitExpression', {
         },
     },
 });
-defineType$4('Import', {
+defineType$4('ImportExpression', {
+    visitor: ['source', 'options'],
     aliases: ['Expression'],
+    fields: {
+        phase: {
+            default: null,
+            validate: assertOneOf('source', 'defer'),
+        },
+        source: {
+            validate: assertNodeType('Expression'),
+        },
+        options: {
+            validate: assertNodeType('Expression'),
+            optional: true,
+        },
+    },
 });
+defineType$4('Import');
 defineType$4('BigIntLiteral', {
     builder: ['value'],
     fields: {
@@ -9550,7 +9578,7 @@ defineType$4('ExportNamespaceSpecifier', {
     aliases: ['ModuleSpecifier'],
     fields: {
         exported: {
-            validate: assertNodeType('Identifier'),
+            validate: assertNodeType('Identifier', 'StringLiteral'),
         },
     },
 });
@@ -9563,19 +9591,20 @@ defineType$4('OptionalMemberExpression', {
     ],
     visitor: ['object', 'property'],
     aliases: ['Expression'],
+    ...memberExpressionUnionShapeCommon,
     fields: {
         object: {
             validate: assertNodeType('Expression'),
         },
         property: {
             validate: (function() {
-                const normal = assertNodeType('Identifier');
+                const normal = assertNodeType('Identifier', 'PrivateName');
                 const computed = assertNodeType('Expression');
                 const validator = Object.assign(function(node, key, val) {
                     const validator2 = node.computed ? computed : normal;
                     validator2(node, key, val);
                 }, {
-                    oneOfNodeTypes: ['Expression', 'Identifier'],
+                    oneOfNodeTypes: ['Expression', 'PrivateName'],
                 });
                 
                 return validator;
@@ -9869,7 +9898,7 @@ defineType$3('DeclareFunction', {
     ],
     fields: {
         id: validateType('Identifier'),
-        predicate: validateOptionalType('DeclaredPredicate'),
+        predicate: validateOptionalType('FlowPredicate'),
     },
 });
 defineInterfaceishType('DeclareInterface');
@@ -9981,7 +10010,7 @@ defineType$3('DeclaredPredicate', {
     visitor: ['value'],
     aliases: ['FlowPredicate'],
     fields: {
-        value: validateType('Flow'),
+        value: validateType('Expression'),
     },
 });
 defineType$3('ExistsTypeAnnotation', {
@@ -10072,6 +10101,13 @@ defineType$3('NumberLiteralTypeAnnotation', {
         value: validate$2(assertValueType('number')),
     },
 });
+defineType$3('BigIntLiteralTypeAnnotation', {
+    builder: ['value'],
+    aliases: ['FlowType'],
+    fields: {
+        value: validate$2(assertValueType('bigint')),
+    },
+});
 defineType$3('NumberTypeAnnotation', {
     aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
@@ -10170,7 +10206,7 @@ defineType$3('ObjectTypeProperty', {
     ],
     aliases: ['UserWhitespacable'],
     fields: {
-        key: validateType('Identifier', 'StringLiteral'),
+        key: validateType('Identifier', 'StringLiteral', 'NumericLiteral'),
         value: validateType('FlowType'),
         kind: {
             validate: assertOneOf('init', 'get', 'set'),
@@ -10651,7 +10687,7 @@ defineType$5('BindExpression', {
     aliases: ['Expression'],
     fields: {
         object: {
-            validate: assertNodeType('Expression'),
+            validate: assertNodeOrValueType('null', 'Expression'),
         },
         callee: {
             validate: assertNodeType('Expression'),
@@ -11195,7 +11231,7 @@ defineType('TSInterfaceDeclaration', {
         declare: validateOptional(bool),
         id: validateType('Identifier'),
         typeParameters: validateOptionalType('TSTypeParameterDeclaration'),
-        extends: validateOptional(arrayOfType('TSClassImplements')),
+        extends: validateOptional(arrayOfType('TSInterfaceHeritage')),
         body: validateType('TSInterfaceBody'),
     },
 });
@@ -11282,7 +11318,7 @@ defineType('TSModuleDeclaration', {
     visitor: ['id', 'body'],
     fields: {
         kind: {
-            validate: assertOneOf('global', 'namespace'),
+            validate: assertOneOf('global', 'namespace', 'module'),
             default: 'namespace',
         },
         declare: validateOptional(bool),
@@ -12383,19 +12419,6 @@ function importSpecifier(local, imported) {
     return node;
 }
 
-function importExpression(source, options = null) {
-    const node = {
-        type: 'ImportExpression',
-        source,
-        options,
-    };
-    
-    const defs2 = NODE_FIELDS.ImportExpression;
-    validate(defs2.source, node, 'source', source, 1);
-    validate(defs2.options, node, 'options', options, 1);
-    return node;
-}
-
 function metaProperty(meta, property) {
     const node = {
         type: 'MetaProperty',
@@ -12525,6 +12548,19 @@ function awaitExpression(argument) {
     return node;
 }
 
+function importExpression(source, options = null) {
+    const node = {
+        type: 'ImportExpression',
+        source,
+        options,
+    };
+    
+    const defs2 = NODE_FIELDS.ImportExpression;
+    validate(defs2.source, node, 'source', source, 1);
+    validate(defs2.options, node, 'options', options, 1);
+    return node;
+}
+
 function _import() {
     return {
         type: 'Import',
@@ -13029,6 +13065,17 @@ function numberLiteralTypeAnnotation(value) {
     return node;
 }
 
+function bigIntLiteralTypeAnnotation(value) {
+    const node = {
+        type: 'BigIntLiteralTypeAnnotation',
+        value,
+    };
+    
+    const defs2 = NODE_FIELDS.BigIntLiteralTypeAnnotation;
+    validate(defs2.value, node, 'value', value);
+    return node;
+}
+
 function numberTypeAnnotation() {
     return {
         type: 'NumberTypeAnnotation',
@@ -14581,6 +14628,7 @@ var b = /* @__PURE__ */Object.freeze({
     assignmentPattern,
     awaitExpression,
     bigIntLiteral,
+    bigIntLiteralTypeAnnotation,
     binaryExpression,
     bindExpression,
     blockStatement,
@@ -14897,7 +14945,6 @@ var ImportDeclaration = alias('importDeclaration');
 var ImportDefaultSpecifier = alias('importDefaultSpecifier');
 var ImportNamespaceSpecifier = alias('importNamespaceSpecifier');
 var ImportSpecifier = alias('importSpecifier');
-var ImportExpression = alias('importExpression');
 var MetaProperty = alias('metaProperty');
 var ClassMethod = alias('classMethod');
 var ObjectPattern = alias('objectPattern');
@@ -14908,6 +14955,7 @@ var TemplateElement = alias('templateElement');
 var TemplateLiteral = alias('templateLiteral');
 var YieldExpression = alias('yieldExpression');
 var AwaitExpression = alias('awaitExpression');
+var ImportExpression = alias('importExpression');
 var Import = alias('import');
 var BigIntLiteral = alias('bigIntLiteral');
 var ExportNamespaceSpecifier = alias('exportNamespaceSpecifier');
@@ -14949,6 +14997,7 @@ var MixedTypeAnnotation = alias('mixedTypeAnnotation');
 var EmptyTypeAnnotation = alias('emptyTypeAnnotation');
 var NullableTypeAnnotation = alias('nullableTypeAnnotation');
 var NumberLiteralTypeAnnotation = alias('numberLiteralTypeAnnotation');
+var BigIntLiteralTypeAnnotation = alias('bigIntLiteralTypeAnnotation');
 var NumberTypeAnnotation = alias('numberTypeAnnotation');
 var ObjectTypeAnnotation = alias('objectTypeAnnotation');
 var ObjectTypeInternalSlot = alias('objectTypeInternalSlot');
@@ -15423,10 +15472,6 @@ function assertImportSpecifier(node, opts) {
     assert('ImportSpecifier', node, opts);
 }
 
-function assertImportExpression(node, opts) {
-    assert('ImportExpression', node, opts);
-}
-
 function assertMetaProperty(node, opts) {
     assert('MetaProperty', node, opts);
 }
@@ -15467,6 +15512,10 @@ function assertAwaitExpression(node, opts) {
     assert('AwaitExpression', node, opts);
 }
 
+function assertImportExpression(node, opts) {
+    assert('ImportExpression', node, opts);
+}
+
 function assertImport(node, opts) {
     assert('Import', node, opts);
 }
@@ -15631,6 +15680,10 @@ function assertNumberLiteralTypeAnnotation(node, opts) {
     assert('NumberLiteralTypeAnnotation', node, opts);
 }
 
+function assertBigIntLiteralTypeAnnotation(node, opts) {
+    assert('BigIntLiteralTypeAnnotation', node, opts);
+}
+
 function assertNumberTypeAnnotation(node, opts) {
     assert('NumberTypeAnnotation', node, opts);
 }
@@ -17794,13 +17847,18 @@ var react = {
 
 // ../babel-babel/packages/babel-parser/lib/index.js
 var Position = class {
-    line;
-    column;
-    index;
     constructor(line, col, index3) {
+        this.line = void 0;
+        this.column = void 0;
+        
+        if (index3 !== void 0)
+            this.index = void 0;
+        
         this.line = line;
         this.column = col;
-        this.index = index3;
+        
+        if (index3 !== void 0)
+            this.index = index3;
     }
 };
 
@@ -18059,13 +18117,13 @@ function defineHidden(obj, key, value) {
 function toParseErrorConstructor({toMessage, code: code2, reasonCode, syntaxPlugin}) {
     const hasMissingPlugin = reasonCode === 'MissingPlugin' || reasonCode === 'MissingOneOfPlugins';
     
-    return function constructor(loc, details) {
+    return function constructor(loc, pos, details) {
         const error = new SyntaxError();
         
         error.code = code2;
         error.reasonCode = reasonCode;
         error.loc = loc;
-        error.pos = loc.index;
+        error.pos = pos;
         error.syntaxPlugin = syntaxPlugin;
         
         if (hasMissingPlugin) {
@@ -18076,10 +18134,10 @@ function toParseErrorConstructor({toMessage, code: code2, reasonCode, syntaxPlug
             const {
                 line,
                 column,
-                index: index3,
+                index: index3 = pos,
             } = overrides.loc ?? loc;
             
-            return constructor(new Position(line, column, index3), {
+            return constructor(new Position(line, column), index3, {
                 ...details,
                 ...overrides.details,
             });
@@ -18160,6 +18218,7 @@ function createDefaultOptions() {
         plugins: [],
         strictMode: void 0,
         ranges: false,
+        locations: true,
         tokens: false,
         createImportExpressions: true,
         createParenthesizedExpressions: false,
@@ -18212,32 +18271,27 @@ function getOptions(opts) {
     return options;
 }
 
-var {defineProperty} = Object;
-
-var toUnenumerable = (object, key) => {
-    if (object) {
-        defineProperty(object, key, {
-            enumerable: false,
-            value: object[key],
-        });
-    }
-};
-
 function toESTreeLocation(node) {
-    toUnenumerable(node.loc.start, 'index');
-    toUnenumerable(node.loc.end, 'index');
+    const {start, end} = node.loc;
+    
+    node.loc.start = new Position(start.line, start.column);
+    node.loc.end = new Position(end.line, end.column);
     return node;
 }
 
 var estree = (superClass) => class ESTreeParserMixin extends superClass {
+    createPosition(loc) {
+        return new Position(loc.line, loc.column);
+    }
+    
     parse() {
-        const file2 = toESTreeLocation(super.parse());
+        const file2 = super.parse();
         
-        if (this.optionFlags & 256) {
+        if (this.optionFlags & 512) {
             file2.tokens = file2.tokens.map(toESTreeLocation);
         }
         
-        return file2;
+        return toESTreeLocation(file2);
     }
     
     parseRegExpLiteral({pattern, flags}) {
@@ -18291,11 +18345,11 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
         return this.estreeParseLiteral(value);
     }
     
-    estreeParseChainExpression(node, endLoc) {
+    estreeParseChainExpression(node, endNode) {
         const chain2 = this.startNodeAtNode(node);
         
         chain2.expression = node;
-        return this.finishNodeAt(chain2, 'ChainExpression', endLoc);
+        return this.finishNodeAtNode(chain2, 'ChainExpression', endNode);
     }
     
     directiveToStmt(directive2) {
@@ -18521,7 +18575,7 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
             const {key, value} = node;
             
             if (this.isPrivateName(key)) {
-                this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+                this.classScope.usePrivateName(this.getPrivateNameSV(key), key.start);
             }
             
             this.toAssignable(value, isLHS);
@@ -18592,7 +18646,7 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
         const node = super.stopParseSubscript(base, state);
         
         if (state.optionalChainMember) {
-            return this.estreeParseChainExpression(node, base.loc.end);
+            return this.estreeParseChainExpression(node, base);
         }
         
         return node;
@@ -18661,6 +18715,10 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
         return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
     }
     
+    finishNodeAtNode(node, type, endNode) {
+        return toESTreeLocation(super.finishNodeAtNode(node, type, endNode));
+    }
+    
     finishNode(node, type) {
         const result = super.finishNode(node, type);
         this.fillOptionalPropertiesForTSESLint(result);
@@ -20550,7 +20608,7 @@ var ScopeHandler = class {
         const topLevelScope = this.scopeStack[0];
         
         if (!topLevelScope.names.has(name)) {
-            this.undefinedExports.set(name, id.loc.start);
+            this.undefinedExports.set(name, id.start);
         }
     }
     
@@ -21189,31 +21247,33 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
     }
     
     jsxParseAttribute() {
-        const node = this.startNode();
-        
         if (this.match(2)) {
+            const node2 = this.startNode();
             this.setContext(types.brace);
             this.next();
             this.expect(17);
-            node.argument = this.parseMaybeAssignAllowIn();
+            node2.argument = this.parseMaybeAssignAllowIn();
             this.setContext(types.j_oTag);
             this.state.canStartJSXElement = true;
             this.expect(4);
-            return this.finishNode(node, 'JSXSpreadAttribute');
+            return this.finishNode(node2, 'JSXSpreadAttribute');
         }
         
+        const node = this.startNode();
+        
         node.name = this.jsxParseNamespacedName();
         node.value = this.eat(25) ? this.jsxParseAttributeValue() : null;
         return this.finishNode(node, 'JSXAttribute');
     }
     
     jsxParseOpeningElementAt(startLoc) {
-        const node = this.startNodeAt(startLoc);
-        
         if (this.eat(139)) {
-            return this.finishNode(node, 'JSXOpeningFragment');
+            const node2 = this.startNodeAt(startLoc);
+            return this.finishNode(node2, 'JSXOpeningFragment');
         }
         
+        const node = this.startNodeAt(startLoc);
+        
         node.name = this.jsxParseElementName();
         return this.jsxParseOpeningElementAfterName(node);
     }
@@ -21232,12 +21292,13 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
     }
     
     jsxParseClosingElementAt(startLoc) {
-        const node = this.startNodeAt(startLoc);
-        
         if (this.eat(139)) {
-            return this.finishNode(node, 'JSXClosingFragment');
+            const node2 = this.startNodeAt(startLoc);
+            return this.finishNode(node2, 'JSXClosingFragment');
         }
         
+        const node = this.startNodeAt(startLoc);
+        
         node.name = this.jsxParseElementName();
         this.expect(139);
         return this.finishNode(node, 'JSXClosingElement');
@@ -21257,6 +21318,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
                     this.next();
                     
                     if (this.eat(52)) {
+                        this.setLoc(startLoc);
                         closingElement = this.jsxParseClosingElementAt(startLoc);
                         break contents;
                     }
@@ -21701,7 +21763,7 @@ var CommentsParser = class extends BaseParser {
             i--;
         }
         
-        const {start: nodeStart} = node;
+        const nodeStart = node.start;
         
         for (; i >= 0; i--) {
             const commentWS = commentStack[i];
@@ -22444,6 +22506,15 @@ var Token = class {
     }
 };
 
+var locDataCache;
+
+function resetLocData() {
+    const data = locDataCache;
+    
+    locDataCache = void 0;
+    return data;
+}
+
 var Tokenizer = class extends CommentsParser {
     isLookahead;
     tokens = [];
@@ -22455,6 +22526,26 @@ var Tokenizer = class extends CommentsParser {
         this.length = input.length;
         this.comments = [];
         this.isLookahead = false;
+        
+        if (!locDataCache || locDataCache.length < (this.length + 1) * 2 || options.locations === 'packed') {
+            locDataCache = new Uint32Array((this.length + 1) * 2);
+        }
+        
+        this.locData = locDataCache;
+    }
+    
+    setLoc(loc) {
+        const dataIndex = this.offsetToSourcePos(loc.index);
+        
+        this.locData[dataIndex * 2] = loc.line;
+        this.locData[dataIndex * 2 + 1] = loc.column;
+    }
+    
+    getLoc(locIndex) {
+        const dataIndex = this.offsetToSourcePos(locIndex);
+        const loc = new Position(this.locData[dataIndex * 2], this.locData[dataIndex * 2 + 1], locIndex);
+        
+        return loc;
     }
     
     pushToken(token) {
@@ -22466,7 +22557,7 @@ var Tokenizer = class extends CommentsParser {
     next() {
         this.checkKeywordEscapes();
         
-        if (this.optionFlags & 256) {
+        if (this.optionFlags & 512) {
             this.pushToken(new Token(this.state));
         }
         
@@ -22621,7 +22712,7 @@ var Tokenizer = class extends CommentsParser {
             loc: new SourceLocation(startLoc, this.state.curPosition()),
         };
         
-        if (this.optionFlags & 256)
+        if (this.optionFlags & 512)
             this.pushToken(comment);
         
         return comment;
@@ -22656,7 +22747,7 @@ var Tokenizer = class extends CommentsParser {
             loc: new SourceLocation(startLoc, this.state.curPosition()),
         };
         
-        if (this.optionFlags & 256)
+        if (this.optionFlags & 512)
             this.pushToken(comment);
         
         return comment;
@@ -22664,7 +22755,7 @@ var Tokenizer = class extends CommentsParser {
     
     skipSpace() {
         const spaceStart = this.state.pos;
-        const comments = this.optionFlags & 4096 ? [] : null;
+        const comments = this.optionFlags & 8192 ? [] : null;
         
         loop:         while (this.state.pos < this.length) {
             const ch = this.input.charCodeAt(this.state.pos);
@@ -22722,7 +22813,7 @@ var Tokenizer = class extends CommentsParser {
             default:
                 if (isWhitespace(ch)) {
                     ++this.state.pos;
-                } else if (ch === 45 && !this.inModule && this.optionFlags & 8192) {
+                } else if (ch === 45 && !this.inModule && this.optionFlags & 16384) {
                     const pos = this.state.pos;
                     
                     if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
@@ -22735,7 +22826,7 @@ var Tokenizer = class extends CommentsParser {
                     } else {
                         break loop;
                     }
-                } else if (ch === 60 && !this.inModule && this.optionFlags & 8192) {
+                } else if (ch === 60 && !this.inModule && this.optionFlags & 16384) {
                     const pos = this.state.pos;
                     
                     if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
@@ -23540,10 +23631,11 @@ var Tokenizer = class extends CommentsParser {
     }
     
     raise(toParseError, at, details = {}) {
-        const loc = at instanceof Position ? at : at.loc.start;
-        const error = toParseError(loc, details);
+        const loc = at instanceof Position ? at : typeof at === 'number' ? this.getLoc(at) : this.optionFlags & 256 ? at.loc.start : this.getLoc(at.start);
+        const pos = at instanceof Position ? loc.index : typeof at === 'number' ? at : at.start;
+        const error = toParseError(loc, pos, details);
         
-        if (!(this.optionFlags & 2048))
+        if (!(this.optionFlags & 4096))
             throw error;
         
         if (!this.isLookahead)
@@ -23553,22 +23645,22 @@ var Tokenizer = class extends CommentsParser {
     }
     
     raiseOverwrite(toParseError, at, details = {}) {
-        const loc = at instanceof Position ? at : at.loc.start;
-        const pos = loc.index;
+        const loc = at instanceof Position ? at : this.optionFlags & 256 ? at.loc.start : this.getLoc(at.start);
+        const pos = at instanceof Position ? loc.index : at.start;
         const errors = this.state.errors;
         
         for (let i = errors.length - 1; i >= 0; i--) {
             const error = errors[i];
             
-            if (error.loc.index === pos) {
-                return errors[i] = toParseError(loc, details);
+            if (error.pos === pos) {
+                return errors[i] = toParseError(loc, pos, details);
             }
             
-            if (error.loc.index < pos)
+            if (error.pos < pos)
                 break;
         }
         
-        return this.raise(toParseError, at, details);
+        return this.raise(toParseError, loc, details);
     }
     
     updateContext() {}
@@ -23605,7 +23697,7 @@ var Tokenizer = class extends CommentsParser {
     
     errorHandlers_readInt = {
         invalidDigit: (pos, lineStart, curLine, radix) => {
-            if (!(this.optionFlags & 2048))
+            if (!(this.optionFlags & 4096))
                 return false;
             
             this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), {
@@ -23648,7 +23740,6 @@ var ClassScope = class {
 var ClassScopeHandler = class {
     parser;
     stack = [];
-    undefinedPrivateNames =     /* @__PURE__ */new Map();
     constructor(parser) {
         this.parser = parser;
     }
@@ -23753,9 +23844,8 @@ var ArrowHeadParsingScope = class extends ExpressionScope {
         super(type);
     }
     
-    recordDeclarationError(ParsingErrorClass, at) {
-        const index3 = at.index;
-        this.declarationErrors.set(index3, [ParsingErrorClass, at]);
+    recordDeclarationError(ParsingErrorClass, index3) {
+        this.declarationErrors.set(index3, ParsingErrorClass);
     }
     
     clearDeclarationError(index3) {
@@ -23784,8 +23874,7 @@ var ExpressionScopeHandler = class {
         this.stack.pop();
     }
     
-    recordParameterInitializerError(toParseError, node) {
-        const origin = node.loc.start;
+    recordParameterInitializerError(toParseError, loc) {
         const {stack} = this;
         
         let i = stack.length - 1;
@@ -23793,7 +23882,7 @@ var ExpressionScopeHandler = class {
         
         while (!scope2.isCertainlyParameterDeclaration()) {
             if (scope2.canBeArrowParameterDeclaration()) {
-                scope2.recordDeclarationError(toParseError, origin);
+                scope2.recordDeclarationError(toParseError, loc);
             } else {
                 return;
             }
@@ -23801,14 +23890,14 @@ var ExpressionScopeHandler = class {
             scope2 = stack[--i];
         }
         
-        this.parser.raise(toParseError, origin);
+        this.parser.raise(toParseError, loc);
     }
     
     recordArrowParameterBindingError(error, node) {
         const {stack} = this;
         
         const scope2 = stack[stack.length - 1];
-        const origin = node.loc.start;
+        const origin = node.start;
         
         if (scope2.isCertainlyParameterDeclaration()) {
             this.parser.raise(error, origin);
@@ -23842,13 +23931,13 @@ var ExpressionScopeHandler = class {
         if (!currentScope.canBeArrowParameterDeclaration())
             return;
         
-        currentScope.iterateErrors(([toParseError, loc]) => {
-            this.parser.raise(toParseError, loc);
+        currentScope.iterateErrors((toParseError, key) => {
+            this.parser.raise(toParseError, key);
             let i = stack.length - 2;
             let scope2 = stack[i];
             
             while (scope2.canBeArrowParameterDeclaration()) {
-                scope2.clearDeclarationError(loc.index);
+                scope2.clearDeclarationError(key);
                 scope2 = stack[--i];
             }
         });
@@ -24170,17 +24259,18 @@ var ExpressionErrors = class {
 };
 
 var Node = class {
-    constructor(parser, pos, loc) {
+    constructor(optionFlags, filename, pos, loc) {
         this.start = pos;
         this.end = 0;
-        this.loc = new SourceLocation(loc);
         
-        if (parser != null) {
-            if (parser.optionFlags & 128)
-                this.range = [pos, 0];
-            
-            if (parser.filename)
-                this.loc.filename = parser.filename;
+        if (loc !== void 0)
+            this.loc = new SourceLocation(loc);
+        
+        if (optionFlags & 128)
+            this.range = [pos, 0];
+        
+        if (loc !== void 0 && filename) {
+            this.loc.filename = filename;
         }
     }
     
@@ -24190,17 +24280,35 @@ var Node = class {
 var NodePrototype = Node.prototype;
 
 var NodeUtils = class extends UtilParser {
+    createPosition(loc) {
+        return loc;
+    }
+    
     startNode() {
-        const loc = this.state.startLoc;
-        return new Node(this, loc.index, loc);
+        const {startLoc} = this.state;
+        
+        this.setLoc(startLoc);
+        return this.startNodeAt(startLoc);
     }
     
     startNodeAt(loc) {
-        return new Node(this, loc.index, loc);
+        const {optionFlags, filename} = this;
+        
+        if (!(optionFlags & 256)) {
+            return new Node(optionFlags, filename, loc.index);
+        }
+        
+        return new Node(optionFlags, filename, loc.index, this.createPosition(loc));
     }
     
     startNodeAtNode(type) {
-        return this.startNodeAt(type.loc.start);
+        const {optionFlags, filename} = this;
+        
+        if (!(optionFlags & 256)) {
+            return new Node(optionFlags, filename, type.start);
+        }
+        
+        return new Node(optionFlags, filename, type.start, type.loc.start);
     }
     
     finishNode(node, type) {
@@ -24210,36 +24318,85 @@ var NodeUtils = class extends UtilParser {
     finishNodeAt(node, type, endLoc) {
         node.type = type;
         node.end = endLoc.index;
-        node.loc.end = endLoc;
+        const {optionFlags} = this;
         
-        if (this.optionFlags & 128)
+        if (optionFlags & 256) {
+            node.loc.end = this.createPosition(endLoc);
+        }
+        
+        if (optionFlags & 128)
             node.range[1] = endLoc.index;
         
-        if (this.optionFlags & 4096) {
+        if (optionFlags & 8192)
             this.processComment(node);
+        
+        return node;
+    }
+    
+    finishNodeAtNode(node, type, endNode) {
+        node.type = type;
+        node.end = endNode.end;
+        const {optionFlags} = this;
+        
+        if (optionFlags & 256) {
+            node.loc.end = endNode.loc.end;
         }
         
+        if (optionFlags & 128)
+            node.range[1] = node.end;
+        
+        if (optionFlags & 8192)
+            this.processComment(node);
+        
         return node;
     }
     
     resetStartLocation(node, startLoc) {
         node.start = startLoc.index;
-        node.loc.start = startLoc;
+        const {optionFlags} = this;
+        
+        if (optionFlags & 256) {
+            node.loc.start = this.createPosition(startLoc);
+        }
         
-        if (this.optionFlags & 128)
+        if (optionFlags & 128)
             node.range[0] = startLoc.index;
     }
     
     resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
         node.end = endLoc.index;
-        node.loc.end = endLoc;
+        const {optionFlags} = this;
+        
+        if (optionFlags & 256) {
+            node.loc.end = this.createPosition(endLoc);
+        }
         
-        if (this.optionFlags & 128)
+        if (optionFlags & 128)
             node.range[1] = endLoc.index;
     }
     
     resetStartLocationFromNode(node, locationNode) {
-        this.resetStartLocation(node, locationNode.loc.start);
+        node.start = locationNode.start;
+        const {optionFlags} = this;
+        
+        if (optionFlags & 256) {
+            node.loc.start = locationNode.loc.start;
+        }
+        
+        if (optionFlags & 128)
+            node.range[0] = locationNode.start;
+    }
+    
+    resetEndLocationFromNode(node, locationNode) {
+        node.end = locationNode.end;
+        const {optionFlags} = this;
+        
+        if (optionFlags & 256) {
+            node.loc.end = locationNode.loc.end;
+        }
+        
+        if (optionFlags & 128)
+            node.range[1] = locationNode.end;
     }
     
     castNodeTo(node, type) {
@@ -24344,7 +24501,7 @@ var LValParser = class extends NodeUtils {
             const {key, value} = node;
             
             if (this.isPrivateName(key)) {
-                this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+                this.classScope.usePrivateName(this.getPrivateNameSV(key), key.start);
             }
             
             this.toAssignable(value, isLHS);
@@ -24361,7 +24518,7 @@ var LValParser = class extends NodeUtils {
         
         case 'AssignmentExpression':
             if (node.operator !== '=') {
-                this.raise(Errors.MissingEqInAssignment, node.left.loc.end);
+                this.raise(Errors.MissingEqInAssignment, this.optionFlags & 256 ? node.left.loc.end : node.left);
             }
             
             this.castNodeTo(node, 'AssignmentPattern');
@@ -24605,6 +24762,8 @@ var LValParser = class extends NodeUtils {
     }
     
     parseBindingElement(flags, decorators) {
+        const {startLoc} = this.state;
+        
         const left = this.parseMaybeDefault();
         
         if (flags & 2) {
@@ -24616,7 +24775,7 @@ var LValParser = class extends NodeUtils {
             this.resetStartLocationFromNode(left, decorators[0]);
         }
         
-        const elt = this.parseMaybeDefault(left.loc.start, left);
+        const elt = this.parseMaybeDefault(startLoc, left);
         
         return elt;
     }
@@ -24667,7 +24826,7 @@ var LValParser = class extends NodeUtils {
             return true;
         
         case 'CallExpression':
-            if (!disallowCallExpression && !this.state.strict && this.optionFlags & 8192) {
+            if (!disallowCallExpression && !this.state.strict && this.optionFlags & 16384) {
                 return true;
             }
         }
@@ -24689,7 +24848,7 @@ var LValParser = class extends NodeUtils {
         
         if (isOptionalMemberExpression3 || type === 'MemberExpression') {
             if (isOptionalMemberExpression3) {
-                this.expectPlugin('optionalChainingAssign', expression2.loc.start);
+                this.expectPlugin('optionalChainingAssign', expression2.start);
                 
                 if (ancestor.type !== 'AssignmentExpression') {
                     this.raise(Errors.InvalidLhsOptionalChaining, expression2, {
@@ -24788,7 +24947,7 @@ var LValParser = class extends NodeUtils {
     }
     
     declareNameFromIdentifier(identifier4, binding) {
-        this.scope.declareName(identifier4.name, binding, identifier4.loc.start);
+        this.scope.declareName(identifier4.name, binding, identifier4.start);
     }
     
     checkToRestConversion(node, allowPattern) {
@@ -25923,7 +26082,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             return this.tsParseTupleType();
         
         case 6:
-            if (!(this.optionFlags & 1024)) {
+            if (!(this.optionFlags & 2048)) {
                 const startLoc = this.state.startLoc;
                 this.next();
                 const type = this.tsParseType();
@@ -26290,7 +26449,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
             const expression2 = (this.state.canStartArrow = false, super.parseExprSubscripts());
             
             if (!tsIsEntityName(expression2)) {
-                this.raise(TSErrors.InvalidHeritageClauseType, expression2.loc.start, {
+                this.raise(TSErrors.InvalidHeritageClauseType, expression2.start, {
                     token,
                 });
             }
@@ -26773,7 +26932,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     }
     
     parseBindingElement(flags, decorators) {
-        const startLoc = decorators.length ? decorators[0].loc.start : this.state.startLoc;
+        const startLoc = decorators.length ? null : this.state.startLoc;
         const modified = {};
         
         this.tsParseModifiers({
@@ -26790,19 +26949,20 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         const readonly = modified.readonly;
         
         if (!(flags & 4) && (accessibility || readonly || override)) {
-            this.raise(TSErrors.UnexpectedParameterModifier, startLoc);
+            this.raise(TSErrors.UnexpectedParameterModifier, startLoc || decorators[0]);
         }
         
-        const left = this.parseMaybeDefault();
+        const startLoc2 = this.state.startLoc;
+        const left = this.parseMaybeDefault(startLoc2);
         
         if (flags & 2) {
             this.parseFunctionParamType(left);
         }
         
-        const elt = this.parseMaybeDefault(left.loc.start, left);
+        const elt = this.parseMaybeDefault(startLoc2, left);
         
         if (accessibility || readonly || override) {
-            const pp = this.startNodeAt(startLoc);
+            const pp = startLoc ? this.startNodeAt(startLoc) : this.startNodeAtNode(decorators[0]);
             
             if (decorators.length) {
                 pp.decorators = decorators;
@@ -26818,7 +26978,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 pp.override = override;
             
             if (elt.type !== 'Identifier' && elt.type !== 'AssignmentPattern') {
-                this.raise(TSErrors.UnsupportedParameterPropertyKind, pp);
+                this.raise(TSErrors.UnsupportedParameterPropertyKind, startLoc || decorators[0]);
             }
             
             pp.parameter = elt;
@@ -27222,7 +27382,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                         
                         return declaration;
                     } else {
-                        node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 121 ? 'declare' : 'abstract');
+                        node.expression = this.createIdentifier(this.startNodeAtNode(node), token === 121 ? 'declare' : 'abstract');
                         this.semicolon(false);
                         return this.finishNode(node, 'ExpressionStatement');
                     }
@@ -27708,7 +27868,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 const parameter = expr.typeParameters.params[0];
                 
                 if (!parameter.constraint) {
-                    this.raise(TSErrors.SingleTypeParameterWithoutTrailingComma, createPositionWithColumnOffset(parameter.loc.end, 1), {
+                    this.raise(TSErrors.SingleTypeParameterWithoutTrailingComma, this.optionFlags & 256 ? createPositionWithColumnOffset(parameter.loc.end, 1) : parameter, {
                         typeParameterName: parameter.name.name,
                     });
                 }
@@ -28006,7 +28166,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
     
     typeCastToParameter(node) {
         node.expression.typeAnnotation = node.typeAnnotation;
-        this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
+        this.resetEndLocationFromNode(node.expression, node.typeAnnotation);
         return node.expression;
     }
     
@@ -28190,7 +28350,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
         let rightOfAs;
         let hasTypeSpecifier = false;
         let canParseAsKeyword = true;
-        const loc = leftOfAs.loc.start;
+        const loc = leftOfAs.start;
         
         if (this.isContextual(89)) {
             const firstAs = this.parseIdentifier();
@@ -28221,7 +28381,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
                 leftOfAs = this.parseIdentifier(true);
                 
                 if (!this.isContextual(89)) {
-                    this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
+                    this.checkReservedWord(leftOfAs.name, leftOfAs.start, true, true);
                 }
             } else {
                 leftOfAs = this.parseModuleExportName();
@@ -28906,7 +29066,7 @@ var ExpressionParser = class extends LValParser {
             if (sawProto) {
                 if (refExpressionErrors) {
                     if (refExpressionErrors.doubleProtoLoc === null) {
-                        refExpressionErrors.doubleProtoLoc = key.loc.start;
+                        refExpressionErrors.doubleProtoLoc = this.getLoc(key.start);
                     }
                 } else {
                     this.raise(Errors.DuplicateProto, key);
@@ -28943,10 +29103,14 @@ var ExpressionParser = class extends LValParser {
         expr.comments = this.comments;
         expr.errors = this.state.errors;
         
-        if (this.optionFlags & 256) {
+        if (this.optionFlags & 512) {
             expr.tokens = createExportedTokens(this.tokens);
         }
         
+        if (this.options.locations === 'packed') {
+            expr.locData = resetLocData();
+        }
+        
         return expr;
     }
     
@@ -29121,12 +29285,12 @@ var ExpressionParser = class extends LValParser {
             const value = this.getPrivateNameSV(left);
             
             if (minPrec >= tokenOperatorPrecedence(54) || !this.prodParam.hasIn || !this.match(54)) {
-                this.raise(Errors.PrivateInExpectedIn, left, {
+                this.raise(Errors.PrivateInExpectedIn, leftStartLoc, {
                     identifierName: value,
                 });
             }
             
-            this.classScope.usePrivateName(value, left.loc.start);
+            this.classScope.usePrivateName(value, leftStartLoc);
         }
         
         const op = this.state.type;
@@ -29312,6 +29476,7 @@ var ExpressionParser = class extends LValParser {
     
     parseExprSubscripts(refExpressionErrors) {
         const startLoc = this.state.startLoc;
+        this.setLoc(startLoc);
         const expr = this.parseExprAtom(refExpressionErrors);
         
         if (this.shouldExitDescending(expr)) {
@@ -29575,7 +29740,7 @@ var ExpressionParser = class extends LValParser {
             }
             
             if (this.match(6)) {
-                if (this.optionFlags & 512) {
+                if (this.optionFlags & 1024) {
                     return this.parseImportCall(node);
                 } else {
                     return this.finishNode(node, 'Import');
@@ -30055,7 +30220,7 @@ var ExpressionParser = class extends LValParser {
     }
     
     wrapParenthesis(startLoc, expression2) {
-        if (!(this.optionFlags & 1024)) {
+        if (!(this.optionFlags & 2048)) {
             this.addExtra(expression2, 'parenthesized', true);
             this.addExtra(expression2, 'parenStart', startLoc.index);
             this.takeSurroundingComments(expression2, startLoc.index, this.state.lastTokEndLoc.index);
@@ -30350,7 +30515,7 @@ var ExpressionParser = class extends LValParser {
         }
         
         if (!prop.computed && prop.key.type === 'Identifier') {
-            this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
+            this.checkReservedWord(prop.key.name, prop.key.start, true, false);
             
             if (isPattern3) {
                 prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));
@@ -30515,7 +30680,7 @@ var ExpressionParser = class extends LValParser {
                 const nonSimple = !this.isSimpleParamList(node.params);
                 
                 if (hasStrictModeDirective && nonSimple) {
-                    this.raise(Errors.IllegalLanguageModeDirective, (node.kind === 'method' || node.kind === 'constructor') && !!node.key ? node.key.loc.end : node);
+                    this.raise(Errors.IllegalLanguageModeDirective, (node.kind === 'method' || node.kind === 'constructor') && !!node.key ? this.optionFlags & 256 ? node.key.loc.end : node.key : node);
                 }
                 
                 const strictModeChanged = !oldStrict && this.state.strict;
@@ -30626,19 +30791,27 @@ var ExpressionParser = class extends LValParser {
     
     createIdentifier(node, name) {
         node.name = name;
-        node.loc.identifierName = name;
+        
+        if (this.optionFlags & 256) {
+            node.loc.identifierName = name;
+        }
+        
         return this.finishNode(node, 'Identifier');
     }
     
     createIdentifierAt(node, name, endLoc) {
         node.name = name;
-        node.loc.identifierName = name;
+        
+        if (this.optionFlags & 256) {
+            node.loc.identifierName = name;
+        }
+        
         return this.finishNodeAt(node, 'Identifier', endLoc);
     }
     
     parseIdentifierName(liberal) {
         let name;
-        const {startLoc, type} = this.state;
+        const {start, type} = this.state;
         
         if (tokenIsKeywordOrIdentifier(type)) {
             name = this.state.value;
@@ -30653,7 +30826,7 @@ var ExpressionParser = class extends LValParser {
                 this.replaceToken(128);
             }
         } else {
-            this.checkReservedWord(name, startLoc, tokenIsKeyword2, false);
+            this.checkReservedWord(name, this.sourceToOffsetPos(start), tokenIsKeyword2, false);
         }
         
         this.next();
@@ -30721,11 +30894,13 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseAwait(startLoc, soloAwait) {
+        const startIndex = startLoc.index;
+        this.setLoc(startLoc);
         const node = this.startNodeAt(startLoc);
-        this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);
+        this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, startIndex);
         
         if (this.eat(51)) {
-            this.raise(Errors.ObsoleteAwaitStar, node);
+            this.raise(Errors.ObsoleteAwaitStar, startLoc);
         }
         
         if (!this.scope.inFunction && !(this.optionFlags & 1)) {
@@ -30761,8 +30936,9 @@ var ExpressionParser = class extends LValParser {
     }
     
     parseYield(startLoc) {
+        this.setLoc(startLoc);
         const node = this.startNodeAt(startLoc);
-        this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node);
+        this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, startLoc.index);
         let delegating = false;
         let argument = null;
         
@@ -30855,7 +31031,7 @@ var ExpressionParser = class extends LValParser {
         const prodParamToSet = 16 & ~flags;
         
         if (prodParamToClear || prodParamToSet) {
-            this.prodParam.enter(flags & ~8 | 16);
+            this.prodParam.enter(flags & -9 | 16);
             try {
                 return callback();
             } finally {
@@ -30880,7 +31056,7 @@ var ExpressionParser = class extends LValParser {
     
     parseFSharpPipelineBody(prec) {
         const startLoc = this.state.startLoc;
-        this.prodParam.enter(this.prodParam.currentFlags() & ~16);
+        this.prodParam.enter(this.prodParam.currentFlags() & -17);
         let ret;
         
         if (this.isContextual(92) && this.recordAwaitIfAllowed()) {
@@ -30978,7 +31154,7 @@ var StatementParser = class extends ExpressionParser {
         file2.program = this.parseProgram(program3, 135, this.options.sourceType === 'module' ? 'module' : 'script');
         file2.comments = this.comments;
         
-        if (this.optionFlags & 256) {
+        if (this.optionFlags & 512) {
             file2.tokens = createExportedTokens(this.tokens);
         }
         
@@ -31978,11 +32154,11 @@ var StatementParser = class extends ExpressionParser {
         
         if (kind === 'using' || kind === 'await using') {
             if (id.type === 'ArrayPattern' || id.type === 'ObjectPattern') {
-                this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start);
+                this.raise(Errors.UsingDeclarationHasBindingPattern, id);
             }
         } else {
             if (id.type === 'VoidPattern') {
-                this.raise(Errors.UnexpectedVoidPattern, id.loc.start);
+                this.raise(Errors.UnexpectedVoidPattern, id);
             }
         }
         
@@ -32051,7 +32227,7 @@ var StatementParser = class extends ExpressionParser {
         if (!node.id)
             return;
         
-        this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start);
+        this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.start);
     }
     
     parseClass(node, isStatement5, optionalId) {
@@ -32366,7 +32542,7 @@ var StatementParser = class extends ExpressionParser {
     pushClassPrivateProperty(classBody2, prop) {
         const node = this.parseClassPrivateProperty(prop);
         classBody2.body.push(node);
-        this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
+        this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.start);
     }
     
     pushClassAccessorProperty(classBody2, prop, isPrivate2) {
@@ -32378,7 +32554,7 @@ var StatementParser = class extends ExpressionParser {
         classBody2.body.push(node);
         
         if (isPrivate2) {
-            this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
+            this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.start);
         }
     }
     
@@ -32402,7 +32578,7 @@ var StatementParser = class extends ExpressionParser {
     }
     
     declareClassPrivateMethodInScope(node, kind) {
-        this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
+        this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.start);
     }
     
     parsePostMemberNameModifiers() {}
@@ -32546,7 +32722,7 @@ var StatementParser = class extends ExpressionParser {
     
     maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
         if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
-            this.expectPlugin('exportDefaultFrom', maybeDefaultIdentifier?.loc.start);
+            this.expectPlugin('exportDefaultFrom', maybeDefaultIdentifier?.start);
             const id = maybeDefaultIdentifier || this.parseIdentifier(true);
             const specifier = this.startNodeAtNode(id);
             
@@ -32755,7 +32931,7 @@ var StatementParser = class extends ExpressionParser {
                                 exportName,
                             });
                         } else {
-                            this.checkReservedWord(local.name, local.loc.start, true, false);
+                            this.checkReservedWord(local.name, local.start, true, false);
                             this.scope.checkLocalExport(local);
                         }
                     }
@@ -32886,11 +33062,11 @@ var StatementParser = class extends ExpressionParser {
         
         if (node.phase === 'source') {
             if (singleBindingType !== 'ImportDefaultSpecifier') {
-                this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0].loc.start);
+                this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0]);
             }
         } else if (node.phase === 'defer') {
             if (singleBindingType !== 'ImportNamespaceSpecifier') {
-                this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);
+                this.raise(Errors.DeferImportRequiresNamespace, specifiers[0]);
             }
         }
     }
@@ -32933,7 +33109,7 @@ var StatementParser = class extends ExpressionParser {
         const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 94 || this.lookaheadCharCode() === 102 : type !== 8;
         
         if (isImportPhase) {
-            this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start);
+            this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.start);
             return null;
         } else {
             this.applyImportPhase(node, isExport, null);
@@ -33120,7 +33296,7 @@ var StatementParser = class extends ExpressionParser {
                 });
             }
             
-            this.checkReservedWord(imported.name, specifier.loc.start, true, true);
+            this.checkReservedWord(imported.name, specifier.start, true, true);
             
             if (!specifier.local) {
                 specifier.local = this.cloneIdentifier(imported);
@@ -33178,30 +33354,34 @@ var Parser = class extends StatementParser {
             optionFlags |= 128;
         }
         
-        if (normalizedOptions.tokens) {
+        if (normalizedOptions.locations === true) {
             optionFlags |= 256;
         }
         
-        if (normalizedOptions.createImportExpressions) {
+        if (normalizedOptions.tokens) {
             optionFlags |= 512;
         }
         
-        if (normalizedOptions.createParenthesizedExpressions) {
+        if (normalizedOptions.createImportExpressions) {
             optionFlags |= 1024;
         }
         
-        if (normalizedOptions.errorRecovery) {
+        if (normalizedOptions.createParenthesizedExpressions) {
             optionFlags |= 2048;
         }
         
-        if (normalizedOptions.attachComment) {
+        if (normalizedOptions.errorRecovery) {
             optionFlags |= 4096;
         }
         
-        if (normalizedOptions.annexB) {
+        if (normalizedOptions.attachComment) {
             optionFlags |= 8192;
         }
         
+        if (normalizedOptions.annexB) {
+            optionFlags |= 16384;
+        }
+        
         this.optionFlags = optionFlags;
     }
     
@@ -33220,6 +33400,11 @@ var Parser = class extends StatementParser {
         
         result.errors = this.state.errors;
         result.comments.length = this.state.commentsLen;
+        
+        if (this.options.locations === 'packed') {
+            result.locData = resetLocData();
+        }
+        
         return result;
     }
 };
@@ -33335,6 +33520,22 @@ function getParserClass(pluginsMap) {
     return cls;
 }
 
+function getLine(locData, pos) {
+    if (pos < 0 || pos * 2 >= locData.length) {
+        throw new Error(`Position ${pos} is out of bounds for location data.`);
+    }
+    
+    return locData[pos * 2];
+}
+
+function getColumn(locData, pos) {
+    if (pos < 0 || pos * 2 + 1 >= locData.length) {
+        throw new Error(`Position ${pos} is out of bounds for location data.`);
+    }
+    
+    return locData[pos * 2 + 1];
+}
+
 // ../babel-babel/packages/babel-code-frame/lib/common-BO7XIBW3.js
 var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 
@@ -36259,28 +36460,28 @@ var PRECEDENCE = /* @__PURE__ */new Map([
 ]);
 
 function isTSTypeExpression(nodeId) {
-    return nodeId === 153 || nodeId === 198 || nodeId === 206;
+    return nodeId === 154 || nodeId === 199 || nodeId === 207;
 }
 
 var isClassExtendsClause = (node, parent, parentId) => {
-    return (parentId === 21 || parentId === 22) && parent.superClass === node;
+    return (parentId === 22 || parentId === 23) && parent.superClass === node;
 };
 
 var hasPostfixPart = (node, parent, parentId) => {
     switch(parentId) {
-    case 108:    
-    case 132:
+    case 109:    
+    case 133:
         return parent.object === node;
     
-    case 17:    
-    case 130:    
-    case 112:
+    case 18:    
+    case 131:    
+    case 113:
         return parent.callee === node;
     
-    case 219:
+    case 220:
         return parent.tag === node;
     
-    case 188:
+    case 189:
         return true;
     }
     
@@ -36292,8 +36493,8 @@ function NullableTypeAnnotation$1(node, parent, parentId) {
 }
 
 function FunctionTypeAnnotation$1(node, parent, parentId, tokenContext) {
-    return parentId === 236
-        || parentId === 90
+    return parentId === 237
+        || parentId === 91
         || parentId === 4
         || (tokenContext & 8) > 0;
 }
@@ -36319,20 +36520,20 @@ function BinaryLike(node, parent, parentId, nodeType) {
         return true;
     }
     
-    if (hasPostfixPart(node, parent, parentId) || parentId === 235 || parentId === 142 || parentId === 8) {
+    if (hasPostfixPart(node, parent, parentId) || parentId === 236 || parentId === 143 || parentId === 8) {
         return true;
     }
     
     let parentPos;
     
     switch(parentId) {
-    case 10:    
-    case 107:
+    case 11:    
+    case 108:
         parentPos = PRECEDENCE.get(parent.operator);
         break;
     
-    case 153:    
-    case 198:
+    case 154:    
+    case 199:
         parentPos = 7;
     }
     
@@ -36342,11 +36543,11 @@ function BinaryLike(node, parent, parentId, nodeType) {
         if (parentPos > nodePos)
             return true;
         
-        if (parentPos === nodePos && parentId === 10 && (nodePos === 11 ? parent.left === node : parent.right === node)) {
+        if (parentPos === nodePos && parentId === 11 && (nodePos === 11 ? parent.left === node : parent.right === node)) {
             return true;
         }
         
-        if (nodeType === 1 && parentId === 107 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) {
+        if (nodeType === 1 && parentId === 108 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) {
             return true;
         }
     }
@@ -36357,9 +36558,9 @@ function BinaryLike(node, parent, parentId, nodeType) {
 function UnionTypeAnnotation$1(node, parent, parentId) {
     switch(parentId) {
     case 4:    
-    case 115:    
-    case 90:    
-    case 236:
+    case 116:    
+    case 91:    
+    case 237:
         return true;
     }
     
@@ -36367,7 +36568,7 @@ function UnionTypeAnnotation$1(node, parent, parentId) {
 }
 
 function OptionalIndexedAccessType$1(node, parent, parentId) {
-    return parentId === 84 && parent.objectType === node;
+    return parentId === 85 && parent.objectType === node;
 }
 
 function TSAsExpression$1(node, parent, parentId) {
@@ -36375,7 +36576,7 @@ function TSAsExpression$1(node, parent, parentId) {
         return true;
     }
     
-    if (parentId === 10 && (parent.operator === '|' || parent.operator === '&') && node === parent.left) {
+    if (parentId === 11 && (parent.operator === '|' || parent.operator === '&') && node === parent.left) {
         return true;
     }
     
@@ -36384,18 +36585,18 @@ function TSAsExpression$1(node, parent, parentId) {
 
 function TSConditionalType$1(node, parent, parentId) {
     switch(parentId) {
-    case 152:    
-    case 192:    
-    case 208:    
+    case 153:    
+    case 193:    
     case 209:    
-    case 178:    
-    case 216:
+    case 210:    
+    case 179:    
+    case 217:
         return true;
     
-    case 172:
+    case 173:
         return parent.objectType === node;
     
-    case 158:
+    case 159:
         return parent.checkType === node || parent.extendsType === node;
     }
     
@@ -36404,13 +36605,13 @@ function TSConditionalType$1(node, parent, parentId) {
 
 function TSUnionType$1(node, parent, parentId) {
     switch(parentId) {
-    case 178:    
-    case 208:    
-    case 152:    
-    case 192:
+    case 179:    
+    case 209:    
+    case 153:    
+    case 193:
         return true;
     
-    case 172:
+    case 173:
         return parent.objectType === node;
     }
     
@@ -36418,7 +36619,7 @@ function TSUnionType$1(node, parent, parentId) {
 }
 
 function TSIntersectionType$1(node, parent, parentId) {
-    return parentId === 208 || TSTypeOperator$1(node, parent, parentId);
+    return parentId === 209 || TSTypeOperator$1(node, parent, parentId);
 }
 
 function TSInferType$1(node, parent, parentId) {
@@ -36426,7 +36627,7 @@ function TSInferType$1(node, parent, parentId) {
         return true;
     }
     
-    if ((parentId === 178 || parentId === 216) && node.typeParameter.constraint != null) {
+    if ((parentId === 179 || parentId === 217) && node.typeParameter.constraint != null) {
         return true;
     }
     
@@ -36435,11 +36636,11 @@ function TSInferType$1(node, parent, parentId) {
 
 function TSTypeOperator$1(node, parent, parentId) {
     switch(parentId) {
-    case 152:    
-    case 192:
+    case 153:    
+    case 193:
         return true;
     
-    case 172:
+    case 173:
         if (parent.objectType === node) {
             return true;
         }
@@ -36450,10 +36651,10 @@ function TSTypeOperator$1(node, parent, parentId) {
 
 function TSInstantiationExpression$1(node, parent, parentId) {
     switch(parentId) {
-    case 17:    
-    case 130:    
-    case 112:    
-    case 174:
+    case 18:    
+    case 131:    
+    case 113:    
+    case 175:
         return parent.typeArguments != null;
     }
     
@@ -36464,8 +36665,8 @@ function TSFunctionType$1(node, parent, parentId) {
     if (TSUnionType$1(node, parent, parentId))
         return true;
     
-    return parentId === 216
-        || parentId === 158
+    return parentId === 217
+        || parentId === 159
         && (parent.checkType === node
         || parent.extendsType === node);
 }
@@ -36482,19 +36683,19 @@ function LogicalExpression2(node, parent, parentId) {
 }
 
 function SequenceExpression$1(node, parent, parentId) {
-    if (parentId === 141 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 221) {
+    if (parentId === 142 || parentId === 134 || parentId === 109 && parent.property === node || parentId === 133 && parent.property === node || parentId === 222) {
         return false;
     }
     
-    if (parentId === 21) {
+    if (parentId === 22) {
         return true;
     }
     
-    if (parentId === 68) {
+    if (parentId === 69) {
         return parent.right === node;
     }
     
-    if (parentId === 60) {
+    if (parentId === 61) {
         return true;
     }
     
@@ -36502,14 +36703,14 @@ function SequenceExpression$1(node, parent, parentId) {
 }
 
 function YieldExpression$1(node, parent, parentId) {
-    return parentId === 10
-        || parentId === 107
-        || parentId === 235
-        || parentId === 142
+    return parentId === 11
+        || parentId === 108
+        || parentId === 236
+        || parentId === 143
         || hasPostfixPart(node, parent, parentId)
         || parentId === 8
         && isYieldExpression2(node)
-        || parentId === 28
+        || parentId === 29
         && node === parent.test
         || isClassExtendsClause(node, parent, parentId)
         || isTSTypeExpression(parentId);
@@ -36521,7 +36722,7 @@ function ClassExpression2(node, parent, parentId, tokenContext) {
 
 function UnaryLike(node, parent, parentId) {
     return hasPostfixPart(node, parent, parentId)
-        || parentId === 10
+        || parentId === 11
         && parent.operator === '**'
         && parent.left === node
         || isClassExtendsClause(node, parent, parentId);
@@ -36533,14 +36734,14 @@ function FunctionExpression$1(node, parent, parentId, tokenContext) {
 
 function ConditionalExpression$1(node, parent, parentId) {
     switch(parentId) {
-    case 235:    
-    case 142:    
-    case 10:    
-    case 107:    
+    case 236:    
+    case 143:    
+    case 11:    
+    case 108:    
     case 8:
         return true;
     
-    case 28:
+    case 29:
         if (parent.test === node) {
             return true;
         }
@@ -36555,10 +36756,10 @@ function ConditionalExpression$1(node, parent, parentId) {
 
 function OptionalMemberExpression$1(node, parent, parentId) {
     switch(parentId) {
-    case 17:
+    case 18:
         return parent.callee === node;
     
-    case 108:
+    case 109:
         return parent.object === node;
     }
     
@@ -36586,7 +36787,7 @@ function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
         }
     }
     
-    if (tokenContext & 64 || (parentId === 108 || parentId === 132) && tokenContext & (1 | 16 | 32)) {
+    if (tokenContext & 64 || (parentId === 109 || parentId === 133) && tokenContext & (1 | 16 | 32)) {
         if (node.name === 'let') {
             const isFollowedByBracket = isMemberExpression$1(parent, {
                 object: node,
@@ -36605,7 +36806,7 @@ function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
         }
     }
     
-    return parentId === 68
+    return parentId === 69
         && parent.left === node
         && node.name === 'async'
         && !parent.await;
@@ -39934,6 +40135,7 @@ var generatorFunctions = /* @__PURE__ */Object.freeze({
     AssignmentPattern: AssignmentPattern2,
     AwaitExpression: AwaitExpression2,
     BigIntLiteral: BigIntLiteral2,
+    BigIntLiteralTypeAnnotation: BigIntLiteral2,
     BinaryExpression: BinaryExpression2,
     BindExpression: BindExpression2,
     BlockStatement: BlockStatement2,
@@ -40224,7 +40426,7 @@ function isOrHasCallExpression(node) {
 
 function parentNeedsParens(node, parent, parentId) {
     switch(parentId) {
-    case 112:
+    case 113:
         if (parent.callee === node) {
             if (isOrHasCallExpression(node))
                 return true;
@@ -40232,7 +40434,7 @@ function parentNeedsParens(node, parent, parentId) {
         
         break;
     
-    case 42:
+    case 43:
         return !isDecoratorMemberExpression(node) && !(node.type === 'CallExpression' && isDecoratorMemberExpression(node.callee)) && node.type !== 'ParenthesizedExpression';
     }
     
@@ -41036,7 +41238,7 @@ var Printer = class {
             && flags & 1
             || parenthesized
             && flags & 16
-            && nodeId === 71
+            && nodeId === 72
             || parent
             && (parentNeedsParens(node, parent, parentId)
             || needsParens != null
@@ -41044,15 +41246,15 @@ var Printer = class {
         
         if (!shouldPrintParens && parenthesized && node.leadingComments?.length && node.leadingComments[0].type === 'CommentBlock') {
             switch(parentId) {
-            case 65:            
-            case 240:            
+            case 66:            
+            case 241:            
             case 6:            
-            case 140:
+            case 141:
                 break;
             
-            case 17:            
-            case 130:            
-            case 112:
+            case 18:            
+            case 131:            
+            case 113:
                 if (parent.callee !== node)
                     break;
             
@@ -41105,7 +41307,7 @@ var Printer = class {
         }
         
         this._printLeadingComments(node, parent);
-        this.exactSource(nodeId === 136 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
+        this.exactSource(nodeId === 137 || nodeId === 67 ? null : loc, printMethod.bind(this, node, parent));
         
         if (shouldPrintParens) {
             this._printTrailingComments(node, parent);
@@ -41344,7 +41546,7 @@ var Printer = class {
     }
     
     noIndentInnerCommentsHere() {
-        this._innerCommentsState &= ~4;
+        this._innerCommentsState &= -5;
     }
     
     printSequence(nodes, indent, resetTokenContext, trailingCommentsLineOffset) {
@@ -48340,6 +48542,8 @@ traverse3.cache = cache;
 export {
     codeFrameColumns,
     generate,
+    getColumn,
+    getLine,
     parse,
     parseExpression,
     index as template,