houdini-svelte 2.1.19 → 2.1.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -803,11 +803,11 @@ var require_types4 = __commonJS({
803
803
  }();
804
804
  exports.Def = Def;
805
805
  var Field = function() {
806
- function Field2(name, type, defaultFn, hidden7) {
806
+ function Field2(name, type, defaultFn, hidden8) {
807
807
  this.name = name;
808
808
  this.type = type;
809
809
  this.defaultFn = defaultFn;
810
- this.hidden = !!hidden7;
810
+ this.hidden = !!hidden8;
811
811
  }
812
812
  Field2.prototype.toString = function() {
813
813
  return JSON.stringify(this.name) + ": " + this.type;
@@ -1056,12 +1056,12 @@ var require_types4 = __commonJS({
1056
1056
  });
1057
1057
  return this;
1058
1058
  };
1059
- DefImpl2.prototype.field = function(name, type, defaultFn, hidden7) {
1059
+ DefImpl2.prototype.field = function(name, type, defaultFn, hidden8) {
1060
1060
  if (this.finalized) {
1061
1061
  console.error("Ignoring attempt to redefine field " + JSON.stringify(name) + " of finalized type " + JSON.stringify(this.typeName));
1062
1062
  return this;
1063
1063
  }
1064
- this.ownFields[name] = new Field(name, Type.from(type), defaultFn, hidden7);
1064
+ this.ownFields[name] = new Field(name, Type.from(type), defaultFn, hidden8);
1065
1065
  return this;
1066
1066
  };
1067
1067
  DefImpl2.prototype.finalize = function() {
@@ -1662,13 +1662,13 @@ var require_scope4 = __commonJS({
1662
1662
  var name = prefix + index;
1663
1663
  return this.bindings[name] = types14.builders.identifier(name);
1664
1664
  };
1665
- Sp.injectTemporary = function(identifier, init) {
1665
+ Sp.injectTemporary = function(identifier, init2) {
1666
1666
  identifier || (identifier = this.declareTemporary());
1667
1667
  var bodyPath = this.path.get("body");
1668
1668
  if (namedTypes.BlockStatement.check(bodyPath.value)) {
1669
1669
  bodyPath = bodyPath.get("body");
1670
1670
  }
1671
- bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
1671
+ bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init2 || null)]));
1672
1672
  return identifier;
1673
1673
  };
1674
1674
  Sp.scan = function(force) {
@@ -2441,7 +2441,7 @@ var require_path_visitor4 = __commonJS({
2441
2441
  return Context;
2442
2442
  }
2443
2443
  var sharedContextProtoMethods = /* @__PURE__ */ Object.create(null);
2444
- sharedContextProtoMethods.reset = function reset7(path7) {
2444
+ sharedContextProtoMethods.reset = function reset8(path7) {
2445
2445
  if (!(this instanceof this.Context)) {
2446
2446
  throw new Error("");
2447
2447
  }
@@ -7228,9 +7228,9 @@ var require_esprima7 = __commonJS({
7228
7228
  }();
7229
7229
  exports2.ForOfStatement = ForOfStatement;
7230
7230
  var ForStatement = function() {
7231
- function ForStatement2(init, test, update, body) {
7231
+ function ForStatement2(init2, test, update, body) {
7232
7232
  this.type = syntax_1.Syntax.ForStatement;
7233
- this.init = init;
7233
+ this.init = init2;
7234
7234
  this.test = test;
7235
7235
  this.update = update;
7236
7236
  this.body = body;
@@ -7570,10 +7570,10 @@ var require_esprima7 = __commonJS({
7570
7570
  }();
7571
7571
  exports2.VariableDeclaration = VariableDeclaration;
7572
7572
  var VariableDeclarator = function() {
7573
- function VariableDeclarator2(id, init) {
7573
+ function VariableDeclarator2(id, init2) {
7574
7574
  this.type = syntax_1.Syntax.VariableDeclarator;
7575
7575
  this.id = id;
7576
- this.init = init;
7576
+ this.init = init2;
7577
7577
  }
7578
7578
  return VariableDeclarator2;
7579
7579
  }();
@@ -8278,8 +8278,8 @@ var require_esprima7 = __commonJS({
8278
8278
  this.context.firstCoverInitializedNameError = this.lookahead;
8279
8279
  this.nextToken();
8280
8280
  shorthand = true;
8281
- var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
8282
- value = this.finalize(node, new Node.AssignmentPattern(id, init));
8281
+ var init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
8282
+ value = this.finalize(node, new Node.AssignmentPattern(id, init2));
8283
8283
  } else {
8284
8284
  shorthand = true;
8285
8285
  value = id;
@@ -9057,21 +9057,21 @@ var require_esprima7 = __commonJS({
9057
9057
  this.tolerateError(messages_1.Messages.StrictVarName);
9058
9058
  }
9059
9059
  }
9060
- var init = null;
9060
+ var init2 = null;
9061
9061
  if (kind === "const") {
9062
9062
  if (!this.matchKeyword("in") && !this.matchContextualKeyword("of")) {
9063
9063
  if (this.match("=")) {
9064
9064
  this.nextToken();
9065
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
9065
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
9066
9066
  } else {
9067
9067
  this.throwError(messages_1.Messages.DeclarationMissingInitializer, "const");
9068
9068
  }
9069
9069
  }
9070
9070
  } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match("=")) {
9071
9071
  this.expect("=");
9072
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
9072
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
9073
9073
  }
9074
- return this.finalize(node, new Node.VariableDeclarator(id, init));
9074
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
9075
9075
  };
9076
9076
  Parser2.prototype.parseBindingList = function(kind, options) {
9077
9077
  var list = [this.parseLexicalBinding(kind, options)];
@@ -9135,17 +9135,17 @@ var require_esprima7 = __commonJS({
9135
9135
  if (this.lookahead.type === 3) {
9136
9136
  var keyToken = this.lookahead;
9137
9137
  key = this.parseVariableIdentifier();
9138
- var init = this.finalize(node, new Node.Identifier(keyToken.value));
9138
+ var init2 = this.finalize(node, new Node.Identifier(keyToken.value));
9139
9139
  if (this.match("=")) {
9140
9140
  params.push(keyToken);
9141
9141
  shorthand = true;
9142
9142
  this.nextToken();
9143
9143
  var expr = this.parseAssignmentExpression();
9144
- value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
9144
+ value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init2, expr));
9145
9145
  } else if (!this.match(":")) {
9146
9146
  params.push(keyToken);
9147
9147
  shorthand = true;
9148
- value = init;
9148
+ value = init2;
9149
9149
  } else {
9150
9150
  this.expect(":");
9151
9151
  value = this.parsePatternWithDefault(params, kind);
@@ -9230,14 +9230,14 @@ var require_esprima7 = __commonJS({
9230
9230
  this.tolerateError(messages_1.Messages.StrictVarName);
9231
9231
  }
9232
9232
  }
9233
- var init = null;
9233
+ var init2 = null;
9234
9234
  if (this.match("=")) {
9235
9235
  this.nextToken();
9236
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
9236
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
9237
9237
  } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
9238
9238
  this.expect("=");
9239
9239
  }
9240
- return this.finalize(node, new Node.VariableDeclarator(id, init));
9240
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
9241
9241
  };
9242
9242
  Parser2.prototype.parseVariableDeclarationList = function(options) {
9243
9243
  var opt = { inFor: options.inFor };
@@ -9332,7 +9332,7 @@ var require_esprima7 = __commonJS({
9332
9332
  return this.finalize(node, new Node.WhileStatement(test, body));
9333
9333
  };
9334
9334
  Parser2.prototype.parseForStatement = function() {
9335
- var init = null;
9335
+ var init2 = null;
9336
9336
  var test = null;
9337
9337
  var update = null;
9338
9338
  var forIn = true;
@@ -9344,7 +9344,7 @@ var require_esprima7 = __commonJS({
9344
9344
  this.nextToken();
9345
9345
  } else {
9346
9346
  if (this.matchKeyword("var")) {
9347
- init = this.createNode();
9347
+ init2 = this.createNode();
9348
9348
  this.nextToken();
9349
9349
  var previousAllowIn = this.context.allowIn;
9350
9350
  this.context.allowIn = false;
@@ -9355,87 +9355,87 @@ var require_esprima7 = __commonJS({
9355
9355
  if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
9356
9356
  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, "for-in");
9357
9357
  }
9358
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
9358
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
9359
9359
  this.nextToken();
9360
- left = init;
9360
+ left = init2;
9361
9361
  right = this.parseExpression();
9362
- init = null;
9362
+ init2 = null;
9363
9363
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
9364
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
9364
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
9365
9365
  this.nextToken();
9366
- left = init;
9366
+ left = init2;
9367
9367
  right = this.parseAssignmentExpression();
9368
- init = null;
9368
+ init2 = null;
9369
9369
  forIn = false;
9370
9370
  } else {
9371
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
9371
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
9372
9372
  this.expect(";");
9373
9373
  }
9374
9374
  } else if (this.matchKeyword("const") || this.matchKeyword("let")) {
9375
- init = this.createNode();
9375
+ init2 = this.createNode();
9376
9376
  var kind = this.nextToken().value;
9377
9377
  if (!this.context.strict && this.lookahead.value === "in") {
9378
- init = this.finalize(init, new Node.Identifier(kind));
9378
+ init2 = this.finalize(init2, new Node.Identifier(kind));
9379
9379
  this.nextToken();
9380
- left = init;
9380
+ left = init2;
9381
9381
  right = this.parseExpression();
9382
- init = null;
9382
+ init2 = null;
9383
9383
  } else {
9384
9384
  var previousAllowIn = this.context.allowIn;
9385
9385
  this.context.allowIn = false;
9386
9386
  var declarations = this.parseBindingList(kind, { inFor: true });
9387
9387
  this.context.allowIn = previousAllowIn;
9388
9388
  if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword("in")) {
9389
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
9389
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
9390
9390
  this.nextToken();
9391
- left = init;
9391
+ left = init2;
9392
9392
  right = this.parseExpression();
9393
- init = null;
9393
+ init2 = null;
9394
9394
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
9395
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
9395
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
9396
9396
  this.nextToken();
9397
- left = init;
9397
+ left = init2;
9398
9398
  right = this.parseAssignmentExpression();
9399
- init = null;
9399
+ init2 = null;
9400
9400
  forIn = false;
9401
9401
  } else {
9402
9402
  this.consumeSemicolon();
9403
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
9403
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
9404
9404
  }
9405
9405
  }
9406
9406
  } else {
9407
9407
  var initStartToken = this.lookahead;
9408
9408
  var previousAllowIn = this.context.allowIn;
9409
9409
  this.context.allowIn = false;
9410
- init = this.inheritCoverGrammar(this.parseAssignmentExpression);
9410
+ init2 = this.inheritCoverGrammar(this.parseAssignmentExpression);
9411
9411
  this.context.allowIn = previousAllowIn;
9412
9412
  if (this.matchKeyword("in")) {
9413
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
9413
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
9414
9414
  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
9415
9415
  }
9416
9416
  this.nextToken();
9417
- this.reinterpretExpressionAsPattern(init);
9418
- left = init;
9417
+ this.reinterpretExpressionAsPattern(init2);
9418
+ left = init2;
9419
9419
  right = this.parseExpression();
9420
- init = null;
9420
+ init2 = null;
9421
9421
  } else if (this.matchContextualKeyword("of")) {
9422
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
9422
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
9423
9423
  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
9424
9424
  }
9425
9425
  this.nextToken();
9426
- this.reinterpretExpressionAsPattern(init);
9427
- left = init;
9426
+ this.reinterpretExpressionAsPattern(init2);
9427
+ left = init2;
9428
9428
  right = this.parseAssignmentExpression();
9429
- init = null;
9429
+ init2 = null;
9430
9430
  forIn = false;
9431
9431
  } else {
9432
9432
  if (this.match(",")) {
9433
- var initSeq = [init];
9433
+ var initSeq = [init2];
9434
9434
  while (this.match(",")) {
9435
9435
  this.nextToken();
9436
9436
  initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
9437
9437
  }
9438
- init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
9438
+ init2 = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
9439
9439
  }
9440
9440
  this.expect(";");
9441
9441
  }
@@ -9461,7 +9461,7 @@ var require_esprima7 = __commonJS({
9461
9461
  body = this.isolateCoverGrammar(this.parseStatement);
9462
9462
  this.context.inIteration = previousInIteration;
9463
9463
  }
9464
- return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
9464
+ return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init2, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
9465
9465
  };
9466
9466
  Parser2.prototype.parseContinueStatement = function() {
9467
9467
  var node = this.createNode();
@@ -14852,10 +14852,10 @@ var require_printer4 = __commonJS({
14852
14852
  return (0, lines_1.concat)(parts);
14853
14853
  }
14854
14854
  case "ForStatement": {
14855
- var init = path7.call(print26, "init");
14856
- var sep6 = init.length > 1 ? ";\n" : "; ";
14855
+ var init2 = path7.call(print26, "init");
14856
+ var sep6 = init2.length > 1 ? ";\n" : "; ";
14857
14857
  var forParen = "for (";
14858
- var indented = (0, lines_1.fromString)(sep6).join([init, path7.call(print26, "test"), path7.call(print26, "update")]).indentTail(forParen.length);
14858
+ var indented = (0, lines_1.fromString)(sep6).join([init2, path7.call(print26, "test"), path7.call(print26, "update")]).indentTail(forParen.length);
14859
14859
  var head = (0, lines_1.concat)([forParen, indented, ")"]);
14860
14860
  var clause = adjustClause(path7.call(print26, "body"), options);
14861
14861
  parts.push(head);
@@ -24575,10 +24575,10 @@ var require_ponyfill_es2018 = __commonJS2({
24575
24575
  }
24576
24576
  return size;
24577
24577
  }
24578
- function convertQueuingStrategy(init, context) {
24579
- assertDictionary(init, context);
24580
- const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
24581
- const size = init === null || init === void 0 ? void 0 : init.size;
24578
+ function convertQueuingStrategy(init2, context) {
24579
+ assertDictionary(init2, context);
24580
+ const highWaterMark = init2 === null || init2 === void 0 ? void 0 : init2.highWaterMark;
24581
+ const size = init2 === null || init2 === void 0 ? void 0 : init2.size;
24582
24582
  return {
24583
24583
  highWaterMark: highWaterMark === void 0 ? void 0 : convertUnrestrictedDouble(highWaterMark),
24584
24584
  size: size === void 0 ? void 0 : convertQueuingStrategySize(size, `${context} has member 'size' that`)
@@ -26430,9 +26430,9 @@ var require_ponyfill_es2018 = __commonJS2({
26430
26430
  function streamBrandCheckException$1(name) {
26431
26431
  return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);
26432
26432
  }
26433
- function convertQueuingStrategyInit(init, context) {
26434
- assertDictionary(init, context);
26435
- const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
26433
+ function convertQueuingStrategyInit(init2, context) {
26434
+ assertDictionary(init2, context);
26435
+ const highWaterMark = init2 === null || init2 === void 0 ? void 0 : init2.highWaterMark;
26436
26436
  assertRequiredField(highWaterMark, "highWaterMark", "QueuingStrategyInit");
26437
26437
  return {
26438
26438
  highWaterMark: convertUnrestrictedDouble(highWaterMark)
@@ -35600,10 +35600,10 @@ var require_generated2 = __commonJS2({
35600
35600
  body
35601
35601
  });
35602
35602
  }
35603
- function forStatement(init = null, test = null, update = null, body) {
35603
+ function forStatement(init2 = null, test = null, update = null, body) {
35604
35604
  return (0, _validateNode.default)({
35605
35605
  type: "ForStatement",
35606
- init,
35606
+ init: init2,
35607
35607
  test,
35608
35608
  update,
35609
35609
  body
@@ -35821,11 +35821,11 @@ var require_generated2 = __commonJS2({
35821
35821
  declarations
35822
35822
  });
35823
35823
  }
35824
- function variableDeclarator(id, init = null) {
35824
+ function variableDeclarator(id, init2 = null) {
35825
35825
  return (0, _validateNode.default)({
35826
35826
  type: "VariableDeclarator",
35827
35827
  id,
35828
- init
35828
+ init: init2
35829
35829
  });
35830
35830
  }
35831
35831
  function whileStatement(test, body) {
@@ -36527,18 +36527,18 @@ var require_generated2 = __commonJS2({
36527
36527
  init: null
36528
36528
  });
36529
36529
  }
36530
- function enumNumberMember(id, init) {
36530
+ function enumNumberMember(id, init2) {
36531
36531
  return (0, _validateNode.default)({
36532
36532
  type: "EnumNumberMember",
36533
36533
  id,
36534
- init
36534
+ init: init2
36535
36535
  });
36536
36536
  }
36537
- function enumStringMember(id, init) {
36537
+ function enumStringMember(id, init2) {
36538
36538
  return (0, _validateNode.default)({
36539
36539
  type: "EnumStringMember",
36540
36540
  id,
36541
- init
36541
+ init: init2
36542
36542
  });
36543
36543
  }
36544
36544
  function enumDefaultedMember(id) {
@@ -48244,13 +48244,13 @@ var require_lib6 = __commonJS2({
48244
48244
  flowEnumMemberRaw() {
48245
48245
  const loc = this.state.startLoc;
48246
48246
  const id = this.parseIdentifier(true);
48247
- const init = this.eat(29) ? this.flowEnumMemberInit() : {
48247
+ const init2 = this.eat(29) ? this.flowEnumMemberInit() : {
48248
48248
  type: "none",
48249
48249
  loc
48250
48250
  };
48251
48251
  return {
48252
48252
  id,
48253
- init
48253
+ init: init2
48254
48254
  };
48255
48255
  }
48256
48256
  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
@@ -48284,7 +48284,7 @@ var require_lib6 = __commonJS2({
48284
48284
  const memberNode = this.startNode();
48285
48285
  const {
48286
48286
  id,
48287
- init
48287
+ init: init2
48288
48288
  } = this.flowEnumMemberRaw();
48289
48289
  const memberName = id.name;
48290
48290
  if (memberName === "") {
@@ -48310,35 +48310,35 @@ var require_lib6 = __commonJS2({
48310
48310
  memberName
48311
48311
  };
48312
48312
  memberNode.id = id;
48313
- switch (init.type) {
48313
+ switch (init2.type) {
48314
48314
  case "boolean": {
48315
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
48316
- memberNode.init = init.value;
48315
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "boolean");
48316
+ memberNode.init = init2.value;
48317
48317
  members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
48318
48318
  break;
48319
48319
  }
48320
48320
  case "number": {
48321
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
48322
- memberNode.init = init.value;
48321
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "number");
48322
+ memberNode.init = init2.value;
48323
48323
  members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
48324
48324
  break;
48325
48325
  }
48326
48326
  case "string": {
48327
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
48328
- memberNode.init = init.value;
48327
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "string");
48328
+ memberNode.init = init2.value;
48329
48329
  members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
48330
48330
  break;
48331
48331
  }
48332
48332
  case "invalid": {
48333
- throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
48333
+ throw this.flowEnumErrorInvalidMemberInitializer(init2.loc, context);
48334
48334
  }
48335
48335
  case "none": {
48336
48336
  switch (explicitType) {
48337
48337
  case "boolean":
48338
- this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
48338
+ this.flowEnumErrorBooleanMemberNotInitialized(init2.loc, context);
48339
48339
  break;
48340
48340
  case "number":
48341
- this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
48341
+ this.flowEnumErrorNumberMemberNotInitialized(init2.loc, context);
48342
48342
  break;
48343
48343
  default:
48344
48344
  members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
@@ -51439,14 +51439,14 @@ var require_lib6 = __commonJS2({
51439
51439
  return declaration;
51440
51440
  for (const {
51441
51441
  id,
51442
- init
51442
+ init: init2
51443
51443
  } of declaration.declarations) {
51444
- if (!init)
51444
+ if (!init2)
51445
51445
  continue;
51446
51446
  if (kind !== "const" || !!id.typeAnnotation) {
51447
- this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
51448
- } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
51449
- this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
51447
+ this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init2);
51448
+ } else if (!isValidAmbientConstInitializer(init2, this.hasPlugin("estree"))) {
51449
+ this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init2);
51450
51450
  }
51451
51451
  }
51452
51452
  return declaration;
@@ -54926,49 +54926,49 @@ var require_lib6 = __commonJS2({
54926
54926
  }
54927
54927
  this.next();
54928
54928
  this.parseVar(initNode, true, kind);
54929
- const init2 = this.finishNode(initNode, "VariableDeclaration");
54929
+ const init22 = this.finishNode(initNode, "VariableDeclaration");
54930
54930
  const isForIn = this.match(58);
54931
54931
  if (isForIn && starsWithUsingDeclaration) {
54932
- this.raise(Errors.ForInUsing, init2);
54932
+ this.raise(Errors.ForInUsing, init22);
54933
54933
  }
54934
- if ((isForIn || this.isContextual(102)) && init2.declarations.length === 1) {
54935
- return this.parseForIn(node, init2, awaitAt);
54934
+ if ((isForIn || this.isContextual(102)) && init22.declarations.length === 1) {
54935
+ return this.parseForIn(node, init22, awaitAt);
54936
54936
  }
54937
54937
  if (awaitAt !== null) {
54938
54938
  this.unexpected(awaitAt);
54939
54939
  }
54940
- return this.parseFor(node, init2);
54940
+ return this.parseFor(node, init22);
54941
54941
  }
54942
54942
  }
54943
54943
  const startsWithAsync = this.isContextual(95);
54944
54944
  const refExpressionErrors = new ExpressionErrors();
54945
- const init = this.parseExpression(true, refExpressionErrors);
54945
+ const init2 = this.parseExpression(true, refExpressionErrors);
54946
54946
  const isForOf = this.isContextual(102);
54947
54947
  if (isForOf) {
54948
54948
  if (startsWithLet) {
54949
- this.raise(Errors.ForOfLet, init);
54949
+ this.raise(Errors.ForOfLet, init2);
54950
54950
  }
54951
- if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
54952
- this.raise(Errors.ForOfAsync, init);
54951
+ if (awaitAt === null && startsWithAsync && init2.type === "Identifier") {
54952
+ this.raise(Errors.ForOfAsync, init2);
54953
54953
  }
54954
54954
  }
54955
54955
  if (isForOf || this.match(58)) {
54956
54956
  this.checkDestructuringPrivate(refExpressionErrors);
54957
- this.toAssignable(init, true);
54957
+ this.toAssignable(init2, true);
54958
54958
  const type = isForOf ? "ForOfStatement" : "ForInStatement";
54959
- this.checkLVal(init, {
54959
+ this.checkLVal(init2, {
54960
54960
  in: {
54961
54961
  type
54962
54962
  }
54963
54963
  });
54964
- return this.parseForIn(node, init, awaitAt);
54964
+ return this.parseForIn(node, init2, awaitAt);
54965
54965
  } else {
54966
54966
  this.checkExpressionErrors(refExpressionErrors, true);
54967
54967
  }
54968
54968
  if (awaitAt !== null) {
54969
54969
  this.unexpected(awaitAt);
54970
54970
  }
54971
- return this.parseFor(node, init);
54971
+ return this.parseFor(node, init2);
54972
54972
  }
54973
54973
  parseFunctionStatement(node, isAsync, isHangingDeclaration) {
54974
54974
  this.next();
@@ -55190,8 +55190,8 @@ var require_lib6 = __commonJS2({
55190
55190
  }
55191
55191
  this.next();
55192
55192
  }
55193
- parseFor(node, init) {
55194
- node.init = init;
55193
+ parseFor(node, init2) {
55194
+ node.init = init2;
55195
55195
  this.semicolon(false);
55196
55196
  node.test = this.match(13) ? null : this.parseExpression();
55197
55197
  this.semicolon(false);
@@ -55202,7 +55202,7 @@ var require_lib6 = __commonJS2({
55202
55202
  this.state.labels.pop();
55203
55203
  return this.finishNode(node, "ForStatement");
55204
55204
  }
55205
- parseForIn(node, init, awaitAt) {
55205
+ parseForIn(node, init2, awaitAt) {
55206
55206
  const isForIn = this.match(58);
55207
55207
  this.next();
55208
55208
  if (isForIn) {
@@ -55211,19 +55211,19 @@ var require_lib6 = __commonJS2({
55211
55211
  } else {
55212
55212
  node.await = awaitAt !== null;
55213
55213
  }
55214
- if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
55215
- this.raise(Errors.ForInOfLoopInitializer, init, {
55214
+ if (init2.type === "VariableDeclaration" && init2.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init2.kind !== "var" || init2.declarations[0].id.type !== "Identifier")) {
55215
+ this.raise(Errors.ForInOfLoopInitializer, init2, {
55216
55216
  type: isForIn ? "ForInStatement" : "ForOfStatement"
55217
55217
  });
55218
55218
  }
55219
- if (init.type === "AssignmentPattern") {
55220
- this.raise(Errors.InvalidLhs, init, {
55219
+ if (init2.type === "AssignmentPattern") {
55220
+ this.raise(Errors.InvalidLhs, init2, {
55221
55221
  ancestor: {
55222
55222
  type: "ForStatement"
55223
55223
  }
55224
55224
  });
55225
55225
  }
55226
- node.left = init;
55226
+ node.left = init2;
55227
55227
  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
55228
55228
  this.expect(11);
55229
55229
  node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
@@ -58022,13 +58022,13 @@ var require_scope = __commonJS2({
58022
58022
  var name = prefix + index;
58023
58023
  return this.bindings[name] = types62.builders.identifier(name);
58024
58024
  };
58025
- Sp.injectTemporary = function(identifier, init) {
58025
+ Sp.injectTemporary = function(identifier, init2) {
58026
58026
  identifier || (identifier = this.declareTemporary());
58027
58027
  var bodyPath = this.path.get("body");
58028
58028
  if (namedTypes.BlockStatement.check(bodyPath.value)) {
58029
58029
  bodyPath = bodyPath.get("body");
58030
58030
  }
58031
- bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
58031
+ bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init2 || null)]));
58032
58032
  return identifier;
58033
58033
  };
58034
58034
  Sp.scan = function(force) {
@@ -63508,9 +63508,9 @@ var require_esprima2 = __commonJS2({
63508
63508
  }();
63509
63509
  exports2.ForOfStatement = ForOfStatement;
63510
63510
  var ForStatement = function() {
63511
- function ForStatement2(init, test, update, body) {
63511
+ function ForStatement2(init2, test, update, body) {
63512
63512
  this.type = syntax_1.Syntax.ForStatement;
63513
- this.init = init;
63513
+ this.init = init2;
63514
63514
  this.test = test;
63515
63515
  this.update = update;
63516
63516
  this.body = body;
@@ -63850,10 +63850,10 @@ var require_esprima2 = __commonJS2({
63850
63850
  }();
63851
63851
  exports2.VariableDeclaration = VariableDeclaration;
63852
63852
  var VariableDeclarator = function() {
63853
- function VariableDeclarator2(id, init) {
63853
+ function VariableDeclarator2(id, init2) {
63854
63854
  this.type = syntax_1.Syntax.VariableDeclarator;
63855
63855
  this.id = id;
63856
- this.init = init;
63856
+ this.init = init2;
63857
63857
  }
63858
63858
  return VariableDeclarator2;
63859
63859
  }();
@@ -64558,8 +64558,8 @@ var require_esprima2 = __commonJS2({
64558
64558
  this.context.firstCoverInitializedNameError = this.lookahead;
64559
64559
  this.nextToken();
64560
64560
  shorthand = true;
64561
- var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
64562
- value = this.finalize(node, new Node.AssignmentPattern(id, init));
64561
+ var init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
64562
+ value = this.finalize(node, new Node.AssignmentPattern(id, init2));
64563
64563
  } else {
64564
64564
  shorthand = true;
64565
64565
  value = id;
@@ -65337,21 +65337,21 @@ var require_esprima2 = __commonJS2({
65337
65337
  this.tolerateError(messages_1.Messages.StrictVarName);
65338
65338
  }
65339
65339
  }
65340
- var init = null;
65340
+ var init2 = null;
65341
65341
  if (kind === "const") {
65342
65342
  if (!this.matchKeyword("in") && !this.matchContextualKeyword("of")) {
65343
65343
  if (this.match("=")) {
65344
65344
  this.nextToken();
65345
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
65345
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
65346
65346
  } else {
65347
65347
  this.throwError(messages_1.Messages.DeclarationMissingInitializer, "const");
65348
65348
  }
65349
65349
  }
65350
65350
  } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match("=")) {
65351
65351
  this.expect("=");
65352
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
65352
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
65353
65353
  }
65354
- return this.finalize(node, new Node.VariableDeclarator(id, init));
65354
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
65355
65355
  };
65356
65356
  Parser2.prototype.parseBindingList = function(kind, options) {
65357
65357
  var list = [this.parseLexicalBinding(kind, options)];
@@ -65415,17 +65415,17 @@ var require_esprima2 = __commonJS2({
65415
65415
  if (this.lookahead.type === 3) {
65416
65416
  var keyToken = this.lookahead;
65417
65417
  key = this.parseVariableIdentifier();
65418
- var init = this.finalize(node, new Node.Identifier(keyToken.value));
65418
+ var init2 = this.finalize(node, new Node.Identifier(keyToken.value));
65419
65419
  if (this.match("=")) {
65420
65420
  params.push(keyToken);
65421
65421
  shorthand = true;
65422
65422
  this.nextToken();
65423
65423
  var expr = this.parseAssignmentExpression();
65424
- value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
65424
+ value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init2, expr));
65425
65425
  } else if (!this.match(":")) {
65426
65426
  params.push(keyToken);
65427
65427
  shorthand = true;
65428
- value = init;
65428
+ value = init2;
65429
65429
  } else {
65430
65430
  this.expect(":");
65431
65431
  value = this.parsePatternWithDefault(params, kind);
@@ -65510,14 +65510,14 @@ var require_esprima2 = __commonJS2({
65510
65510
  this.tolerateError(messages_1.Messages.StrictVarName);
65511
65511
  }
65512
65512
  }
65513
- var init = null;
65513
+ var init2 = null;
65514
65514
  if (this.match("=")) {
65515
65515
  this.nextToken();
65516
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
65516
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
65517
65517
  } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
65518
65518
  this.expect("=");
65519
65519
  }
65520
- return this.finalize(node, new Node.VariableDeclarator(id, init));
65520
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
65521
65521
  };
65522
65522
  Parser2.prototype.parseVariableDeclarationList = function(options) {
65523
65523
  var opt = { inFor: options.inFor };
@@ -65612,7 +65612,7 @@ var require_esprima2 = __commonJS2({
65612
65612
  return this.finalize(node, new Node.WhileStatement(test, body));
65613
65613
  };
65614
65614
  Parser2.prototype.parseForStatement = function() {
65615
- var init = null;
65615
+ var init2 = null;
65616
65616
  var test = null;
65617
65617
  var update = null;
65618
65618
  var forIn = true;
@@ -65624,7 +65624,7 @@ var require_esprima2 = __commonJS2({
65624
65624
  this.nextToken();
65625
65625
  } else {
65626
65626
  if (this.matchKeyword("var")) {
65627
- init = this.createNode();
65627
+ init2 = this.createNode();
65628
65628
  this.nextToken();
65629
65629
  var previousAllowIn = this.context.allowIn;
65630
65630
  this.context.allowIn = false;
@@ -65635,87 +65635,87 @@ var require_esprima2 = __commonJS2({
65635
65635
  if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
65636
65636
  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, "for-in");
65637
65637
  }
65638
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
65638
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
65639
65639
  this.nextToken();
65640
- left = init;
65640
+ left = init2;
65641
65641
  right = this.parseExpression();
65642
- init = null;
65642
+ init2 = null;
65643
65643
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
65644
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
65644
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
65645
65645
  this.nextToken();
65646
- left = init;
65646
+ left = init2;
65647
65647
  right = this.parseAssignmentExpression();
65648
- init = null;
65648
+ init2 = null;
65649
65649
  forIn = false;
65650
65650
  } else {
65651
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
65651
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
65652
65652
  this.expect(";");
65653
65653
  }
65654
65654
  } else if (this.matchKeyword("const") || this.matchKeyword("let")) {
65655
- init = this.createNode();
65655
+ init2 = this.createNode();
65656
65656
  var kind = this.nextToken().value;
65657
65657
  if (!this.context.strict && this.lookahead.value === "in") {
65658
- init = this.finalize(init, new Node.Identifier(kind));
65658
+ init2 = this.finalize(init2, new Node.Identifier(kind));
65659
65659
  this.nextToken();
65660
- left = init;
65660
+ left = init2;
65661
65661
  right = this.parseExpression();
65662
- init = null;
65662
+ init2 = null;
65663
65663
  } else {
65664
65664
  var previousAllowIn = this.context.allowIn;
65665
65665
  this.context.allowIn = false;
65666
65666
  var declarations = this.parseBindingList(kind, { inFor: true });
65667
65667
  this.context.allowIn = previousAllowIn;
65668
65668
  if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword("in")) {
65669
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
65669
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
65670
65670
  this.nextToken();
65671
- left = init;
65671
+ left = init2;
65672
65672
  right = this.parseExpression();
65673
- init = null;
65673
+ init2 = null;
65674
65674
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
65675
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
65675
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
65676
65676
  this.nextToken();
65677
- left = init;
65677
+ left = init2;
65678
65678
  right = this.parseAssignmentExpression();
65679
- init = null;
65679
+ init2 = null;
65680
65680
  forIn = false;
65681
65681
  } else {
65682
65682
  this.consumeSemicolon();
65683
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
65683
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
65684
65684
  }
65685
65685
  }
65686
65686
  } else {
65687
65687
  var initStartToken = this.lookahead;
65688
65688
  var previousAllowIn = this.context.allowIn;
65689
65689
  this.context.allowIn = false;
65690
- init = this.inheritCoverGrammar(this.parseAssignmentExpression);
65690
+ init2 = this.inheritCoverGrammar(this.parseAssignmentExpression);
65691
65691
  this.context.allowIn = previousAllowIn;
65692
65692
  if (this.matchKeyword("in")) {
65693
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
65693
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
65694
65694
  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
65695
65695
  }
65696
65696
  this.nextToken();
65697
- this.reinterpretExpressionAsPattern(init);
65698
- left = init;
65697
+ this.reinterpretExpressionAsPattern(init2);
65698
+ left = init2;
65699
65699
  right = this.parseExpression();
65700
- init = null;
65700
+ init2 = null;
65701
65701
  } else if (this.matchContextualKeyword("of")) {
65702
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
65702
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
65703
65703
  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
65704
65704
  }
65705
65705
  this.nextToken();
65706
- this.reinterpretExpressionAsPattern(init);
65707
- left = init;
65706
+ this.reinterpretExpressionAsPattern(init2);
65707
+ left = init2;
65708
65708
  right = this.parseAssignmentExpression();
65709
- init = null;
65709
+ init2 = null;
65710
65710
  forIn = false;
65711
65711
  } else {
65712
65712
  if (this.match(",")) {
65713
- var initSeq = [init];
65713
+ var initSeq = [init2];
65714
65714
  while (this.match(",")) {
65715
65715
  this.nextToken();
65716
65716
  initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
65717
65717
  }
65718
- init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
65718
+ init2 = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
65719
65719
  }
65720
65720
  this.expect(";");
65721
65721
  }
@@ -65741,7 +65741,7 @@ var require_esprima2 = __commonJS2({
65741
65741
  body = this.isolateCoverGrammar(this.parseStatement);
65742
65742
  this.context.inIteration = previousInIteration;
65743
65743
  }
65744
- return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
65744
+ return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init2, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
65745
65745
  };
65746
65746
  Parser2.prototype.parseContinueStatement = function() {
65747
65747
  var node = this.createNode();
@@ -71114,10 +71114,10 @@ var require_printer = __commonJS2({
71114
71114
  return (0, lines_1.concat)(parts);
71115
71115
  }
71116
71116
  case "ForStatement": {
71117
- var init = path42.call(print62, "init");
71118
- var sep32 = init.length > 1 ? ";\n" : "; ";
71117
+ var init2 = path42.call(print62, "init");
71118
+ var sep32 = init2.length > 1 ? ";\n" : "; ";
71119
71119
  var forParen = "for (";
71120
- var indented = (0, lines_1.fromString)(sep32).join([init, path42.call(print62, "test"), path42.call(print62, "update")]).indentTail(forParen.length);
71120
+ var indented = (0, lines_1.fromString)(sep32).join([init2, path42.call(print62, "test"), path42.call(print62, "update")]).indentTail(forParen.length);
71121
71121
  var head = (0, lines_1.concat)([forParen, indented, ")"]);
71122
71122
  var clause = adjustClause(path42.call(print62, "body"), options);
71123
71123
  parts.push(head);
@@ -79009,23 +79009,23 @@ var validateHeaderValue = typeof import_node_http.default.validateHeaderValue ==
79009
79009
  }
79010
79010
  };
79011
79011
  var Headers = class extends URLSearchParams {
79012
- constructor(init) {
79012
+ constructor(init2) {
79013
79013
  let result = [];
79014
- if (init instanceof Headers) {
79015
- const raw = init.raw();
79014
+ if (init2 instanceof Headers) {
79015
+ const raw = init2.raw();
79016
79016
  for (const [name, values] of Object.entries(raw)) {
79017
79017
  result.push(...values.map((value) => [name, value]));
79018
79018
  }
79019
- } else if (init == null) {
79020
- } else if (typeof init === "object" && !import_node_util3.types.isBoxedPrimitive(init)) {
79021
- const method = init[Symbol.iterator];
79019
+ } else if (init2 == null) {
79020
+ } else if (typeof init2 === "object" && !import_node_util3.types.isBoxedPrimitive(init2)) {
79021
+ const method = init2[Symbol.iterator];
79022
79022
  if (method == null) {
79023
- result.push(...Object.entries(init));
79023
+ result.push(...Object.entries(init2));
79024
79024
  } else {
79025
79025
  if (typeof method !== "function") {
79026
79026
  throw new TypeError("Header pairs must be iterable");
79027
79027
  }
79028
- result = [...init].map((pair) => {
79028
+ result = [...init2].map((pair) => {
79029
79029
  if (typeof pair !== "object" || import_node_util3.types.isBoxedPrimitive(pair)) {
79030
79030
  throw new TypeError("Each header pair must be an iterable object");
79031
79031
  }
@@ -79220,17 +79220,17 @@ var Response2 = class extends Body {
79220
79220
  response[INTERNALS2].type = "error";
79221
79221
  return response;
79222
79222
  }
79223
- static json(data = void 0, init = {}) {
79223
+ static json(data = void 0, init2 = {}) {
79224
79224
  const body = JSON.stringify(data);
79225
79225
  if (body === void 0) {
79226
79226
  throw new TypeError("data is not JSON serializable");
79227
79227
  }
79228
- const headers = new Headers(init && init.headers);
79228
+ const headers = new Headers(init2 && init2.headers);
79229
79229
  if (!headers.has("content-type")) {
79230
79230
  headers.set("content-type", "application/json");
79231
79231
  }
79232
79232
  return new Response2(body, {
79233
- ...init,
79233
+ ...init2,
79234
79234
  headers
79235
79235
  });
79236
79236
  }
@@ -79276,7 +79276,7 @@ var doBadDataWarn = (0, import_node_util4.deprecate)(
79276
79276
  "https://github.com/node-fetch/node-fetch/issues/1000 (request)"
79277
79277
  );
79278
79278
  var Request2 = class extends Body {
79279
- constructor(input, init = {}) {
79279
+ constructor(input, init2 = {}) {
79280
79280
  let parsedURL;
79281
79281
  if (isRequest(input)) {
79282
79282
  parsedURL = new URL(input.url);
@@ -79287,21 +79287,21 @@ var Request2 = class extends Body {
79287
79287
  if (parsedURL.username !== "" || parsedURL.password !== "") {
79288
79288
  throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
79289
79289
  }
79290
- let method = init.method || input.method || "GET";
79290
+ let method = init2.method || input.method || "GET";
79291
79291
  if (/^(delete|get|head|options|post|put)$/i.test(method)) {
79292
79292
  method = method.toUpperCase();
79293
79293
  }
79294
- if (!isRequest(init) && "data" in init) {
79294
+ if (!isRequest(init2) && "data" in init2) {
79295
79295
  doBadDataWarn();
79296
79296
  }
79297
- if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
79297
+ if ((init2.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
79298
79298
  throw new TypeError("Request with GET/HEAD method cannot have body");
79299
79299
  }
79300
- const inputBody = init.body ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
79300
+ const inputBody = init2.body ? init2.body : isRequest(input) && input.body !== null ? clone(input) : null;
79301
79301
  super(inputBody, {
79302
- size: init.size || input.size || 0
79302
+ size: init2.size || input.size || 0
79303
79303
  });
79304
- const headers = new Headers(init.headers || input.headers || {});
79304
+ const headers = new Headers(init2.headers || input.headers || {});
79305
79305
  if (inputBody !== null && !headers.has("Content-Type")) {
79306
79306
  const contentType = extractContentType(inputBody, this);
79307
79307
  if (contentType) {
@@ -79309,13 +79309,13 @@ var Request2 = class extends Body {
79309
79309
  }
79310
79310
  }
79311
79311
  let signal = isRequest(input) ? input.signal : null;
79312
- if ("signal" in init) {
79313
- signal = init.signal;
79312
+ if ("signal" in init2) {
79313
+ signal = init2.signal;
79314
79314
  }
79315
79315
  if (signal != null && !isAbortSignal(signal)) {
79316
79316
  throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
79317
79317
  }
79318
- let referrer = init.referrer == null ? input.referrer : init.referrer;
79318
+ let referrer = init2.referrer == null ? input.referrer : init2.referrer;
79319
79319
  if (referrer === "") {
79320
79320
  referrer = "no-referrer";
79321
79321
  } else if (referrer) {
@@ -79326,19 +79326,19 @@ var Request2 = class extends Body {
79326
79326
  }
79327
79327
  this[INTERNALS3] = {
79328
79328
  method,
79329
- redirect: init.redirect || input.redirect || "follow",
79329
+ redirect: init2.redirect || input.redirect || "follow",
79330
79330
  headers,
79331
79331
  parsedURL,
79332
79332
  signal,
79333
79333
  referrer
79334
79334
  };
79335
- this.follow = init.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init.follow;
79336
- this.compress = init.compress === void 0 ? input.compress === void 0 ? true : input.compress : init.compress;
79337
- this.counter = init.counter || input.counter || 0;
79338
- this.agent = init.agent || input.agent;
79339
- this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
79340
- this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
79341
- this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
79335
+ this.follow = init2.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init2.follow;
79336
+ this.compress = init2.compress === void 0 ? input.compress === void 0 ? true : input.compress : init2.compress;
79337
+ this.counter = init2.counter || input.counter || 0;
79338
+ this.agent = init2.agent || input.agent;
79339
+ this.highWaterMark = init2.highWaterMark || input.highWaterMark || 16384;
79340
+ this.insecureHTTPParser = init2.insecureHTTPParser || input.insecureHTTPParser || false;
79341
+ this.referrerPolicy = init2.referrerPolicy || input.referrerPolicy || "";
79342
79342
  }
79343
79343
  get method() {
79344
79344
  return this[INTERNALS3].method;
@@ -97225,10 +97225,10 @@ var require_generated22 = __commonJS3({
97225
97225
  body
97226
97226
  });
97227
97227
  }
97228
- function forStatement(init = null, test = null, update = null, body) {
97228
+ function forStatement(init2 = null, test = null, update = null, body) {
97229
97229
  return (0, _validateNode.default)({
97230
97230
  type: "ForStatement",
97231
- init,
97231
+ init: init2,
97232
97232
  test,
97233
97233
  update,
97234
97234
  body
@@ -97446,11 +97446,11 @@ var require_generated22 = __commonJS3({
97446
97446
  declarations
97447
97447
  });
97448
97448
  }
97449
- function variableDeclarator(id, init = null) {
97449
+ function variableDeclarator(id, init2 = null) {
97450
97450
  return (0, _validateNode.default)({
97451
97451
  type: "VariableDeclarator",
97452
97452
  id,
97453
- init
97453
+ init: init2
97454
97454
  });
97455
97455
  }
97456
97456
  function whileStatement(test, body) {
@@ -98152,18 +98152,18 @@ var require_generated22 = __commonJS3({
98152
98152
  init: null
98153
98153
  });
98154
98154
  }
98155
- function enumNumberMember(id, init) {
98155
+ function enumNumberMember(id, init2) {
98156
98156
  return (0, _validateNode.default)({
98157
98157
  type: "EnumNumberMember",
98158
98158
  id,
98159
- init
98159
+ init: init2
98160
98160
  });
98161
98161
  }
98162
- function enumStringMember(id, init) {
98162
+ function enumStringMember(id, init2) {
98163
98163
  return (0, _validateNode.default)({
98164
98164
  type: "EnumStringMember",
98165
98165
  id,
98166
- init
98166
+ init: init2
98167
98167
  });
98168
98168
  }
98169
98169
  function enumDefaultedMember(id) {
@@ -109869,13 +109869,13 @@ var require_lib62 = __commonJS3({
109869
109869
  flowEnumMemberRaw() {
109870
109870
  const loc = this.state.startLoc;
109871
109871
  const id = this.parseIdentifier(true);
109872
- const init = this.eat(29) ? this.flowEnumMemberInit() : {
109872
+ const init2 = this.eat(29) ? this.flowEnumMemberInit() : {
109873
109873
  type: "none",
109874
109874
  loc
109875
109875
  };
109876
109876
  return {
109877
109877
  id,
109878
- init
109878
+ init: init2
109879
109879
  };
109880
109880
  }
109881
109881
  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
@@ -109909,7 +109909,7 @@ var require_lib62 = __commonJS3({
109909
109909
  const memberNode = this.startNode();
109910
109910
  const {
109911
109911
  id,
109912
- init
109912
+ init: init2
109913
109913
  } = this.flowEnumMemberRaw();
109914
109914
  const memberName = id.name;
109915
109915
  if (memberName === "") {
@@ -109935,35 +109935,35 @@ var require_lib62 = __commonJS3({
109935
109935
  memberName
109936
109936
  };
109937
109937
  memberNode.id = id;
109938
- switch (init.type) {
109938
+ switch (init2.type) {
109939
109939
  case "boolean": {
109940
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
109941
- memberNode.init = init.value;
109940
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "boolean");
109941
+ memberNode.init = init2.value;
109942
109942
  members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
109943
109943
  break;
109944
109944
  }
109945
109945
  case "number": {
109946
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
109947
- memberNode.init = init.value;
109946
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "number");
109947
+ memberNode.init = init2.value;
109948
109948
  members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
109949
109949
  break;
109950
109950
  }
109951
109951
  case "string": {
109952
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
109953
- memberNode.init = init.value;
109952
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "string");
109953
+ memberNode.init = init2.value;
109954
109954
  members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
109955
109955
  break;
109956
109956
  }
109957
109957
  case "invalid": {
109958
- throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
109958
+ throw this.flowEnumErrorInvalidMemberInitializer(init2.loc, context);
109959
109959
  }
109960
109960
  case "none": {
109961
109961
  switch (explicitType) {
109962
109962
  case "boolean":
109963
- this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
109963
+ this.flowEnumErrorBooleanMemberNotInitialized(init2.loc, context);
109964
109964
  break;
109965
109965
  case "number":
109966
- this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
109966
+ this.flowEnumErrorNumberMemberNotInitialized(init2.loc, context);
109967
109967
  break;
109968
109968
  default:
109969
109969
  members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
@@ -113064,14 +113064,14 @@ var require_lib62 = __commonJS3({
113064
113064
  return declaration;
113065
113065
  for (const {
113066
113066
  id,
113067
- init
113067
+ init: init2
113068
113068
  } of declaration.declarations) {
113069
- if (!init)
113069
+ if (!init2)
113070
113070
  continue;
113071
113071
  if (kind !== "const" || !!id.typeAnnotation) {
113072
- this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
113073
- } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
113074
- this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
113072
+ this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init2);
113073
+ } else if (!isValidAmbientConstInitializer(init2, this.hasPlugin("estree"))) {
113074
+ this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init2);
113075
113075
  }
113076
113076
  }
113077
113077
  return declaration;
@@ -116551,49 +116551,49 @@ var require_lib62 = __commonJS3({
116551
116551
  }
116552
116552
  this.next();
116553
116553
  this.parseVar(initNode, true, kind);
116554
- const init2 = this.finishNode(initNode, "VariableDeclaration");
116554
+ const init22 = this.finishNode(initNode, "VariableDeclaration");
116555
116555
  const isForIn = this.match(58);
116556
116556
  if (isForIn && starsWithUsingDeclaration) {
116557
- this.raise(Errors.ForInUsing, init2);
116557
+ this.raise(Errors.ForInUsing, init22);
116558
116558
  }
116559
- if ((isForIn || this.isContextual(102)) && init2.declarations.length === 1) {
116560
- return this.parseForIn(node, init2, awaitAt);
116559
+ if ((isForIn || this.isContextual(102)) && init22.declarations.length === 1) {
116560
+ return this.parseForIn(node, init22, awaitAt);
116561
116561
  }
116562
116562
  if (awaitAt !== null) {
116563
116563
  this.unexpected(awaitAt);
116564
116564
  }
116565
- return this.parseFor(node, init2);
116565
+ return this.parseFor(node, init22);
116566
116566
  }
116567
116567
  }
116568
116568
  const startsWithAsync = this.isContextual(95);
116569
116569
  const refExpressionErrors = new ExpressionErrors();
116570
- const init = this.parseExpression(true, refExpressionErrors);
116570
+ const init2 = this.parseExpression(true, refExpressionErrors);
116571
116571
  const isForOf = this.isContextual(102);
116572
116572
  if (isForOf) {
116573
116573
  if (startsWithLet) {
116574
- this.raise(Errors.ForOfLet, init);
116574
+ this.raise(Errors.ForOfLet, init2);
116575
116575
  }
116576
- if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
116577
- this.raise(Errors.ForOfAsync, init);
116576
+ if (awaitAt === null && startsWithAsync && init2.type === "Identifier") {
116577
+ this.raise(Errors.ForOfAsync, init2);
116578
116578
  }
116579
116579
  }
116580
116580
  if (isForOf || this.match(58)) {
116581
116581
  this.checkDestructuringPrivate(refExpressionErrors);
116582
- this.toAssignable(init, true);
116582
+ this.toAssignable(init2, true);
116583
116583
  const type = isForOf ? "ForOfStatement" : "ForInStatement";
116584
- this.checkLVal(init, {
116584
+ this.checkLVal(init2, {
116585
116585
  in: {
116586
116586
  type
116587
116587
  }
116588
116588
  });
116589
- return this.parseForIn(node, init, awaitAt);
116589
+ return this.parseForIn(node, init2, awaitAt);
116590
116590
  } else {
116591
116591
  this.checkExpressionErrors(refExpressionErrors, true);
116592
116592
  }
116593
116593
  if (awaitAt !== null) {
116594
116594
  this.unexpected(awaitAt);
116595
116595
  }
116596
- return this.parseFor(node, init);
116596
+ return this.parseFor(node, init2);
116597
116597
  }
116598
116598
  parseFunctionStatement(node, isAsync, isHangingDeclaration) {
116599
116599
  this.next();
@@ -116815,8 +116815,8 @@ var require_lib62 = __commonJS3({
116815
116815
  }
116816
116816
  this.next();
116817
116817
  }
116818
- parseFor(node, init) {
116819
- node.init = init;
116818
+ parseFor(node, init2) {
116819
+ node.init = init2;
116820
116820
  this.semicolon(false);
116821
116821
  node.test = this.match(13) ? null : this.parseExpression();
116822
116822
  this.semicolon(false);
@@ -116827,7 +116827,7 @@ var require_lib62 = __commonJS3({
116827
116827
  this.state.labels.pop();
116828
116828
  return this.finishNode(node, "ForStatement");
116829
116829
  }
116830
- parseForIn(node, init, awaitAt) {
116830
+ parseForIn(node, init2, awaitAt) {
116831
116831
  const isForIn = this.match(58);
116832
116832
  this.next();
116833
116833
  if (isForIn) {
@@ -116836,19 +116836,19 @@ var require_lib62 = __commonJS3({
116836
116836
  } else {
116837
116837
  node.await = awaitAt !== null;
116838
116838
  }
116839
- if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
116840
- this.raise(Errors.ForInOfLoopInitializer, init, {
116839
+ if (init2.type === "VariableDeclaration" && init2.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init2.kind !== "var" || init2.declarations[0].id.type !== "Identifier")) {
116840
+ this.raise(Errors.ForInOfLoopInitializer, init2, {
116841
116841
  type: isForIn ? "ForInStatement" : "ForOfStatement"
116842
116842
  });
116843
116843
  }
116844
- if (init.type === "AssignmentPattern") {
116845
- this.raise(Errors.InvalidLhs, init, {
116844
+ if (init2.type === "AssignmentPattern") {
116845
+ this.raise(Errors.InvalidLhs, init2, {
116846
116846
  ancestor: {
116847
116847
  type: "ForStatement"
116848
116848
  }
116849
116849
  });
116850
116850
  }
116851
- node.left = init;
116851
+ node.left = init2;
116852
116852
  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
116853
116853
  this.expect(11);
116854
116854
  node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
@@ -119647,13 +119647,13 @@ var require_scope2 = __commonJS3({
119647
119647
  var name = prefix + index;
119648
119648
  return this.bindings[name] = types15.builders.identifier(name);
119649
119649
  };
119650
- Sp.injectTemporary = function(identifier, init) {
119650
+ Sp.injectTemporary = function(identifier, init2) {
119651
119651
  identifier || (identifier = this.declareTemporary());
119652
119652
  var bodyPath = this.path.get("body");
119653
119653
  if (namedTypes.BlockStatement.check(bodyPath.value)) {
119654
119654
  bodyPath = bodyPath.get("body");
119655
119655
  }
119656
- bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
119656
+ bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init2 || null)]));
119657
119657
  return identifier;
119658
119658
  };
119659
119659
  Sp.scan = function(force) {
@@ -125133,9 +125133,9 @@ var require_esprima22 = __commonJS3({
125133
125133
  }();
125134
125134
  exports2.ForOfStatement = ForOfStatement;
125135
125135
  var ForStatement = function() {
125136
- function ForStatement2(init, test, update, body) {
125136
+ function ForStatement2(init2, test, update, body) {
125137
125137
  this.type = syntax_1.Syntax.ForStatement;
125138
- this.init = init;
125138
+ this.init = init2;
125139
125139
  this.test = test;
125140
125140
  this.update = update;
125141
125141
  this.body = body;
@@ -125475,10 +125475,10 @@ var require_esprima22 = __commonJS3({
125475
125475
  }();
125476
125476
  exports2.VariableDeclaration = VariableDeclaration;
125477
125477
  var VariableDeclarator = function() {
125478
- function VariableDeclarator2(id, init) {
125478
+ function VariableDeclarator2(id, init2) {
125479
125479
  this.type = syntax_1.Syntax.VariableDeclarator;
125480
125480
  this.id = id;
125481
- this.init = init;
125481
+ this.init = init2;
125482
125482
  }
125483
125483
  return VariableDeclarator2;
125484
125484
  }();
@@ -126183,8 +126183,8 @@ var require_esprima22 = __commonJS3({
126183
126183
  this.context.firstCoverInitializedNameError = this.lookahead;
126184
126184
  this.nextToken();
126185
126185
  shorthand = true;
126186
- var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
126187
- value = this.finalize(node, new Node.AssignmentPattern(id, init));
126186
+ var init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
126187
+ value = this.finalize(node, new Node.AssignmentPattern(id, init2));
126188
126188
  } else {
126189
126189
  shorthand = true;
126190
126190
  value = id;
@@ -126962,21 +126962,21 @@ var require_esprima22 = __commonJS3({
126962
126962
  this.tolerateError(messages_1.Messages.StrictVarName);
126963
126963
  }
126964
126964
  }
126965
- var init = null;
126965
+ var init2 = null;
126966
126966
  if (kind === "const") {
126967
126967
  if (!this.matchKeyword("in") && !this.matchContextualKeyword("of")) {
126968
126968
  if (this.match("=")) {
126969
126969
  this.nextToken();
126970
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
126970
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
126971
126971
  } else {
126972
126972
  this.throwError(messages_1.Messages.DeclarationMissingInitializer, "const");
126973
126973
  }
126974
126974
  }
126975
126975
  } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match("=")) {
126976
126976
  this.expect("=");
126977
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
126977
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
126978
126978
  }
126979
- return this.finalize(node, new Node.VariableDeclarator(id, init));
126979
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
126980
126980
  };
126981
126981
  Parser2.prototype.parseBindingList = function(kind, options) {
126982
126982
  var list = [this.parseLexicalBinding(kind, options)];
@@ -127040,17 +127040,17 @@ var require_esprima22 = __commonJS3({
127040
127040
  if (this.lookahead.type === 3) {
127041
127041
  var keyToken = this.lookahead;
127042
127042
  key = this.parseVariableIdentifier();
127043
- var init = this.finalize(node, new Node.Identifier(keyToken.value));
127043
+ var init2 = this.finalize(node, new Node.Identifier(keyToken.value));
127044
127044
  if (this.match("=")) {
127045
127045
  params.push(keyToken);
127046
127046
  shorthand = true;
127047
127047
  this.nextToken();
127048
127048
  var expr = this.parseAssignmentExpression();
127049
- value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
127049
+ value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init2, expr));
127050
127050
  } else if (!this.match(":")) {
127051
127051
  params.push(keyToken);
127052
127052
  shorthand = true;
127053
- value = init;
127053
+ value = init2;
127054
127054
  } else {
127055
127055
  this.expect(":");
127056
127056
  value = this.parsePatternWithDefault(params, kind);
@@ -127135,14 +127135,14 @@ var require_esprima22 = __commonJS3({
127135
127135
  this.tolerateError(messages_1.Messages.StrictVarName);
127136
127136
  }
127137
127137
  }
127138
- var init = null;
127138
+ var init2 = null;
127139
127139
  if (this.match("=")) {
127140
127140
  this.nextToken();
127141
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
127141
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
127142
127142
  } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
127143
127143
  this.expect("=");
127144
127144
  }
127145
- return this.finalize(node, new Node.VariableDeclarator(id, init));
127145
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
127146
127146
  };
127147
127147
  Parser2.prototype.parseVariableDeclarationList = function(options) {
127148
127148
  var opt = { inFor: options.inFor };
@@ -127237,7 +127237,7 @@ var require_esprima22 = __commonJS3({
127237
127237
  return this.finalize(node, new Node.WhileStatement(test, body));
127238
127238
  };
127239
127239
  Parser2.prototype.parseForStatement = function() {
127240
- var init = null;
127240
+ var init2 = null;
127241
127241
  var test = null;
127242
127242
  var update = null;
127243
127243
  var forIn = true;
@@ -127249,7 +127249,7 @@ var require_esprima22 = __commonJS3({
127249
127249
  this.nextToken();
127250
127250
  } else {
127251
127251
  if (this.matchKeyword("var")) {
127252
- init = this.createNode();
127252
+ init2 = this.createNode();
127253
127253
  this.nextToken();
127254
127254
  var previousAllowIn = this.context.allowIn;
127255
127255
  this.context.allowIn = false;
@@ -127260,87 +127260,87 @@ var require_esprima22 = __commonJS3({
127260
127260
  if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
127261
127261
  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, "for-in");
127262
127262
  }
127263
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
127263
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
127264
127264
  this.nextToken();
127265
- left = init;
127265
+ left = init2;
127266
127266
  right = this.parseExpression();
127267
- init = null;
127267
+ init2 = null;
127268
127268
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
127269
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
127269
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
127270
127270
  this.nextToken();
127271
- left = init;
127271
+ left = init2;
127272
127272
  right = this.parseAssignmentExpression();
127273
- init = null;
127273
+ init2 = null;
127274
127274
  forIn = false;
127275
127275
  } else {
127276
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
127276
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
127277
127277
  this.expect(";");
127278
127278
  }
127279
127279
  } else if (this.matchKeyword("const") || this.matchKeyword("let")) {
127280
- init = this.createNode();
127280
+ init2 = this.createNode();
127281
127281
  var kind = this.nextToken().value;
127282
127282
  if (!this.context.strict && this.lookahead.value === "in") {
127283
- init = this.finalize(init, new Node.Identifier(kind));
127283
+ init2 = this.finalize(init2, new Node.Identifier(kind));
127284
127284
  this.nextToken();
127285
- left = init;
127285
+ left = init2;
127286
127286
  right = this.parseExpression();
127287
- init = null;
127287
+ init2 = null;
127288
127288
  } else {
127289
127289
  var previousAllowIn = this.context.allowIn;
127290
127290
  this.context.allowIn = false;
127291
127291
  var declarations = this.parseBindingList(kind, { inFor: true });
127292
127292
  this.context.allowIn = previousAllowIn;
127293
127293
  if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword("in")) {
127294
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
127294
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
127295
127295
  this.nextToken();
127296
- left = init;
127296
+ left = init2;
127297
127297
  right = this.parseExpression();
127298
- init = null;
127298
+ init2 = null;
127299
127299
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
127300
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
127300
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
127301
127301
  this.nextToken();
127302
- left = init;
127302
+ left = init2;
127303
127303
  right = this.parseAssignmentExpression();
127304
- init = null;
127304
+ init2 = null;
127305
127305
  forIn = false;
127306
127306
  } else {
127307
127307
  this.consumeSemicolon();
127308
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
127308
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
127309
127309
  }
127310
127310
  }
127311
127311
  } else {
127312
127312
  var initStartToken = this.lookahead;
127313
127313
  var previousAllowIn = this.context.allowIn;
127314
127314
  this.context.allowIn = false;
127315
- init = this.inheritCoverGrammar(this.parseAssignmentExpression);
127315
+ init2 = this.inheritCoverGrammar(this.parseAssignmentExpression);
127316
127316
  this.context.allowIn = previousAllowIn;
127317
127317
  if (this.matchKeyword("in")) {
127318
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
127318
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
127319
127319
  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
127320
127320
  }
127321
127321
  this.nextToken();
127322
- this.reinterpretExpressionAsPattern(init);
127323
- left = init;
127322
+ this.reinterpretExpressionAsPattern(init2);
127323
+ left = init2;
127324
127324
  right = this.parseExpression();
127325
- init = null;
127325
+ init2 = null;
127326
127326
  } else if (this.matchContextualKeyword("of")) {
127327
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
127327
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
127328
127328
  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
127329
127329
  }
127330
127330
  this.nextToken();
127331
- this.reinterpretExpressionAsPattern(init);
127332
- left = init;
127331
+ this.reinterpretExpressionAsPattern(init2);
127332
+ left = init2;
127333
127333
  right = this.parseAssignmentExpression();
127334
- init = null;
127334
+ init2 = null;
127335
127335
  forIn = false;
127336
127336
  } else {
127337
127337
  if (this.match(",")) {
127338
- var initSeq = [init];
127338
+ var initSeq = [init2];
127339
127339
  while (this.match(",")) {
127340
127340
  this.nextToken();
127341
127341
  initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
127342
127342
  }
127343
- init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
127343
+ init2 = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
127344
127344
  }
127345
127345
  this.expect(";");
127346
127346
  }
@@ -127366,7 +127366,7 @@ var require_esprima22 = __commonJS3({
127366
127366
  body = this.isolateCoverGrammar(this.parseStatement);
127367
127367
  this.context.inIteration = previousInIteration;
127368
127368
  }
127369
- return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
127369
+ return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init2, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
127370
127370
  };
127371
127371
  Parser2.prototype.parseContinueStatement = function() {
127372
127372
  var node = this.createNode();
@@ -132739,10 +132739,10 @@ var require_printer2 = __commonJS3({
132739
132739
  return (0, lines_1.concat)(parts);
132740
132740
  }
132741
132741
  case "ForStatement": {
132742
- var init = path32.call(print113, "init");
132743
- var sep32 = init.length > 1 ? ";\n" : "; ";
132742
+ var init2 = path32.call(print113, "init");
132743
+ var sep32 = init2.length > 1 ? ";\n" : "; ";
132744
132744
  var forParen = "for (";
132745
- var indented = (0, lines_1.fromString)(sep32).join([init, path32.call(print113, "test"), path32.call(print113, "update")]).indentTail(forParen.length);
132745
+ var indented = (0, lines_1.fromString)(sep32).join([init2, path32.call(print113, "test"), path32.call(print113, "update")]).indentTail(forParen.length);
132746
132746
  var head = (0, lines_1.concat)([forParen, indented, ")"]);
132747
132747
  var clause = adjustClause(path32.call(print113, "body"), options);
132748
132748
  parts.push(head);
@@ -143220,14 +143220,14 @@ var SET = 6;
143220
143220
  var ERROR22 = 7;
143221
143221
  var BIGINT = 8;
143222
143222
  var env = typeof self === "object" ? self : globalThis;
143223
- var deserializer = ($, _) => {
143223
+ var deserializer = ($2, _) => {
143224
143224
  const as = (out, index) => {
143225
- $.set(index, out);
143225
+ $2.set(index, out);
143226
143226
  return out;
143227
143227
  };
143228
143228
  const unpair = (index) => {
143229
- if ($.has(index))
143230
- return $.get(index);
143229
+ if ($2.has(index))
143230
+ return $2.get(index);
143231
143231
  const [type, value] = _[index];
143232
143232
  switch (type) {
143233
143233
  case PRIMITIVE:
@@ -143306,15 +143306,15 @@ var typeOf = (value) => {
143306
143306
  return [OBJECT, asString];
143307
143307
  };
143308
143308
  var shouldSkip = ([TYPE22, type]) => TYPE22 === PRIMITIVE && (type === "function" || type === "symbol");
143309
- var serializer = (strict, json, $, _) => {
143309
+ var serializer = (strict, json, $2, _) => {
143310
143310
  const as = (out, value) => {
143311
143311
  const index = _.push(out) - 1;
143312
- $.set(value, index);
143312
+ $2.set(value, index);
143313
143313
  return index;
143314
143314
  };
143315
143315
  const pair = (value) => {
143316
- if ($.has(value))
143317
- return $.get(value);
143316
+ if ($2.has(value))
143317
+ return $2.get(value);
143318
143318
  let [TYPE22, type] = typeOf(value);
143319
143319
  switch (TYPE22) {
143320
143320
  case PRIMITIVE: {
@@ -146098,6 +146098,11 @@ export * from "${module2}"
146098
146098
  module: "./" + path_exports2.relative(config.rootDir, config.pluginRuntimeDirectory(plugin2.name))
146099
146099
  });
146100
146100
  }
146101
+ if (plugin2.staticRuntime) {
146102
+ indexContent += exportStarFrom2({
146103
+ module: "./" + path_exports2.relative(config.rootDir, config.pluginStaticRuntimeDirectory(plugin2.name))
146104
+ });
146105
+ }
146101
146106
  }
146102
146107
  await fs_exports2.writeFile(config.typeIndexPath, indexContent);
146103
146108
  const missingScalarNames = [...missingScalars].filter(
@@ -165595,10 +165600,10 @@ var require_generated23 = __commonJS4({
165595
165600
  body
165596
165601
  });
165597
165602
  }
165598
- function forStatement(init = null, test = null, update = null, body) {
165603
+ function forStatement(init2 = null, test = null, update = null, body) {
165599
165604
  return (0, _validateNode.default)({
165600
165605
  type: "ForStatement",
165601
- init,
165606
+ init: init2,
165602
165607
  test,
165603
165608
  update,
165604
165609
  body
@@ -165816,11 +165821,11 @@ var require_generated23 = __commonJS4({
165816
165821
  declarations
165817
165822
  });
165818
165823
  }
165819
- function variableDeclarator(id, init = null) {
165824
+ function variableDeclarator(id, init2 = null) {
165820
165825
  return (0, _validateNode.default)({
165821
165826
  type: "VariableDeclarator",
165822
165827
  id,
165823
- init
165828
+ init: init2
165824
165829
  });
165825
165830
  }
165826
165831
  function whileStatement(test, body) {
@@ -166522,18 +166527,18 @@ var require_generated23 = __commonJS4({
166522
166527
  init: null
166523
166528
  });
166524
166529
  }
166525
- function enumNumberMember(id, init) {
166530
+ function enumNumberMember(id, init2) {
166526
166531
  return (0, _validateNode.default)({
166527
166532
  type: "EnumNumberMember",
166528
166533
  id,
166529
- init
166534
+ init: init2
166530
166535
  });
166531
166536
  }
166532
- function enumStringMember(id, init) {
166537
+ function enumStringMember(id, init2) {
166533
166538
  return (0, _validateNode.default)({
166534
166539
  type: "EnumStringMember",
166535
166540
  id,
166536
- init
166541
+ init: init2
166537
166542
  });
166538
166543
  }
166539
166544
  function enumDefaultedMember(id) {
@@ -178239,13 +178244,13 @@ var require_lib63 = __commonJS4({
178239
178244
  flowEnumMemberRaw() {
178240
178245
  const loc = this.state.startLoc;
178241
178246
  const id = this.parseIdentifier(true);
178242
- const init = this.eat(29) ? this.flowEnumMemberInit() : {
178247
+ const init2 = this.eat(29) ? this.flowEnumMemberInit() : {
178243
178248
  type: "none",
178244
178249
  loc
178245
178250
  };
178246
178251
  return {
178247
178252
  id,
178248
- init
178253
+ init: init2
178249
178254
  };
178250
178255
  }
178251
178256
  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
@@ -178279,7 +178284,7 @@ var require_lib63 = __commonJS4({
178279
178284
  const memberNode = this.startNode();
178280
178285
  const {
178281
178286
  id,
178282
- init
178287
+ init: init2
178283
178288
  } = this.flowEnumMemberRaw();
178284
178289
  const memberName = id.name;
178285
178290
  if (memberName === "") {
@@ -178305,35 +178310,35 @@ var require_lib63 = __commonJS4({
178305
178310
  memberName
178306
178311
  };
178307
178312
  memberNode.id = id;
178308
- switch (init.type) {
178313
+ switch (init2.type) {
178309
178314
  case "boolean": {
178310
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
178311
- memberNode.init = init.value;
178315
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "boolean");
178316
+ memberNode.init = init2.value;
178312
178317
  members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
178313
178318
  break;
178314
178319
  }
178315
178320
  case "number": {
178316
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
178317
- memberNode.init = init.value;
178321
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "number");
178322
+ memberNode.init = init2.value;
178318
178323
  members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
178319
178324
  break;
178320
178325
  }
178321
178326
  case "string": {
178322
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
178323
- memberNode.init = init.value;
178327
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "string");
178328
+ memberNode.init = init2.value;
178324
178329
  members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
178325
178330
  break;
178326
178331
  }
178327
178332
  case "invalid": {
178328
- throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
178333
+ throw this.flowEnumErrorInvalidMemberInitializer(init2.loc, context);
178329
178334
  }
178330
178335
  case "none": {
178331
178336
  switch (explicitType) {
178332
178337
  case "boolean":
178333
- this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
178338
+ this.flowEnumErrorBooleanMemberNotInitialized(init2.loc, context);
178334
178339
  break;
178335
178340
  case "number":
178336
- this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
178341
+ this.flowEnumErrorNumberMemberNotInitialized(init2.loc, context);
178337
178342
  break;
178338
178343
  default:
178339
178344
  members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
@@ -181434,14 +181439,14 @@ var require_lib63 = __commonJS4({
181434
181439
  return declaration;
181435
181440
  for (const {
181436
181441
  id,
181437
- init
181442
+ init: init2
181438
181443
  } of declaration.declarations) {
181439
- if (!init)
181444
+ if (!init2)
181440
181445
  continue;
181441
181446
  if (kind !== "const" || !!id.typeAnnotation) {
181442
- this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
181443
- } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
181444
- this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
181447
+ this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init2);
181448
+ } else if (!isValidAmbientConstInitializer(init2, this.hasPlugin("estree"))) {
181449
+ this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init2);
181445
181450
  }
181446
181451
  }
181447
181452
  return declaration;
@@ -184921,49 +184926,49 @@ var require_lib63 = __commonJS4({
184921
184926
  }
184922
184927
  this.next();
184923
184928
  this.parseVar(initNode, true, kind);
184924
- const init2 = this.finishNode(initNode, "VariableDeclaration");
184929
+ const init22 = this.finishNode(initNode, "VariableDeclaration");
184925
184930
  const isForIn = this.match(58);
184926
184931
  if (isForIn && starsWithUsingDeclaration) {
184927
- this.raise(Errors.ForInUsing, init2);
184932
+ this.raise(Errors.ForInUsing, init22);
184928
184933
  }
184929
- if ((isForIn || this.isContextual(102)) && init2.declarations.length === 1) {
184930
- return this.parseForIn(node, init2, awaitAt);
184934
+ if ((isForIn || this.isContextual(102)) && init22.declarations.length === 1) {
184935
+ return this.parseForIn(node, init22, awaitAt);
184931
184936
  }
184932
184937
  if (awaitAt !== null) {
184933
184938
  this.unexpected(awaitAt);
184934
184939
  }
184935
- return this.parseFor(node, init2);
184940
+ return this.parseFor(node, init22);
184936
184941
  }
184937
184942
  }
184938
184943
  const startsWithAsync = this.isContextual(95);
184939
184944
  const refExpressionErrors = new ExpressionErrors();
184940
- const init = this.parseExpression(true, refExpressionErrors);
184945
+ const init2 = this.parseExpression(true, refExpressionErrors);
184941
184946
  const isForOf = this.isContextual(102);
184942
184947
  if (isForOf) {
184943
184948
  if (startsWithLet) {
184944
- this.raise(Errors.ForOfLet, init);
184949
+ this.raise(Errors.ForOfLet, init2);
184945
184950
  }
184946
- if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
184947
- this.raise(Errors.ForOfAsync, init);
184951
+ if (awaitAt === null && startsWithAsync && init2.type === "Identifier") {
184952
+ this.raise(Errors.ForOfAsync, init2);
184948
184953
  }
184949
184954
  }
184950
184955
  if (isForOf || this.match(58)) {
184951
184956
  this.checkDestructuringPrivate(refExpressionErrors);
184952
- this.toAssignable(init, true);
184957
+ this.toAssignable(init2, true);
184953
184958
  const type = isForOf ? "ForOfStatement" : "ForInStatement";
184954
- this.checkLVal(init, {
184959
+ this.checkLVal(init2, {
184955
184960
  in: {
184956
184961
  type
184957
184962
  }
184958
184963
  });
184959
- return this.parseForIn(node, init, awaitAt);
184964
+ return this.parseForIn(node, init2, awaitAt);
184960
184965
  } else {
184961
184966
  this.checkExpressionErrors(refExpressionErrors, true);
184962
184967
  }
184963
184968
  if (awaitAt !== null) {
184964
184969
  this.unexpected(awaitAt);
184965
184970
  }
184966
- return this.parseFor(node, init);
184971
+ return this.parseFor(node, init2);
184967
184972
  }
184968
184973
  parseFunctionStatement(node, isAsync, isHangingDeclaration) {
184969
184974
  this.next();
@@ -185185,8 +185190,8 @@ var require_lib63 = __commonJS4({
185185
185190
  }
185186
185191
  this.next();
185187
185192
  }
185188
- parseFor(node, init) {
185189
- node.init = init;
185193
+ parseFor(node, init2) {
185194
+ node.init = init2;
185190
185195
  this.semicolon(false);
185191
185196
  node.test = this.match(13) ? null : this.parseExpression();
185192
185197
  this.semicolon(false);
@@ -185197,7 +185202,7 @@ var require_lib63 = __commonJS4({
185197
185202
  this.state.labels.pop();
185198
185203
  return this.finishNode(node, "ForStatement");
185199
185204
  }
185200
- parseForIn(node, init, awaitAt) {
185205
+ parseForIn(node, init2, awaitAt) {
185201
185206
  const isForIn = this.match(58);
185202
185207
  this.next();
185203
185208
  if (isForIn) {
@@ -185206,19 +185211,19 @@ var require_lib63 = __commonJS4({
185206
185211
  } else {
185207
185212
  node.await = awaitAt !== null;
185208
185213
  }
185209
- if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
185210
- this.raise(Errors.ForInOfLoopInitializer, init, {
185214
+ if (init2.type === "VariableDeclaration" && init2.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init2.kind !== "var" || init2.declarations[0].id.type !== "Identifier")) {
185215
+ this.raise(Errors.ForInOfLoopInitializer, init2, {
185211
185216
  type: isForIn ? "ForInStatement" : "ForOfStatement"
185212
185217
  });
185213
185218
  }
185214
- if (init.type === "AssignmentPattern") {
185215
- this.raise(Errors.InvalidLhs, init, {
185219
+ if (init2.type === "AssignmentPattern") {
185220
+ this.raise(Errors.InvalidLhs, init2, {
185216
185221
  ancestor: {
185217
185222
  type: "ForStatement"
185218
185223
  }
185219
185224
  });
185220
185225
  }
185221
- node.left = init;
185226
+ node.left = init2;
185222
185227
  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
185223
185228
  this.expect(11);
185224
185229
  node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
@@ -188017,13 +188022,13 @@ var require_scope3 = __commonJS4({
188017
188022
  var name = prefix + index;
188018
188023
  return this.bindings[name] = types15.builders.identifier(name);
188019
188024
  };
188020
- Sp.injectTemporary = function(identifier, init) {
188025
+ Sp.injectTemporary = function(identifier, init2) {
188021
188026
  identifier || (identifier = this.declareTemporary());
188022
188027
  var bodyPath = this.path.get("body");
188023
188028
  if (namedTypes.BlockStatement.check(bodyPath.value)) {
188024
188029
  bodyPath = bodyPath.get("body");
188025
188030
  }
188026
- bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
188031
+ bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init2 || null)]));
188027
188032
  return identifier;
188028
188033
  };
188029
188034
  Sp.scan = function(force) {
@@ -193503,9 +193508,9 @@ var require_esprima23 = __commonJS4({
193503
193508
  }();
193504
193509
  exports2.ForOfStatement = ForOfStatement;
193505
193510
  var ForStatement = function() {
193506
- function ForStatement2(init, test, update, body) {
193511
+ function ForStatement2(init2, test, update, body) {
193507
193512
  this.type = syntax_1.Syntax.ForStatement;
193508
- this.init = init;
193513
+ this.init = init2;
193509
193514
  this.test = test;
193510
193515
  this.update = update;
193511
193516
  this.body = body;
@@ -193845,10 +193850,10 @@ var require_esprima23 = __commonJS4({
193845
193850
  }();
193846
193851
  exports2.VariableDeclaration = VariableDeclaration;
193847
193852
  var VariableDeclarator = function() {
193848
- function VariableDeclarator2(id, init) {
193853
+ function VariableDeclarator2(id, init2) {
193849
193854
  this.type = syntax_1.Syntax.VariableDeclarator;
193850
193855
  this.id = id;
193851
- this.init = init;
193856
+ this.init = init2;
193852
193857
  }
193853
193858
  return VariableDeclarator2;
193854
193859
  }();
@@ -194553,8 +194558,8 @@ var require_esprima23 = __commonJS4({
194553
194558
  this.context.firstCoverInitializedNameError = this.lookahead;
194554
194559
  this.nextToken();
194555
194560
  shorthand = true;
194556
- var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
194557
- value = this.finalize(node, new Node.AssignmentPattern(id, init));
194561
+ var init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
194562
+ value = this.finalize(node, new Node.AssignmentPattern(id, init2));
194558
194563
  } else {
194559
194564
  shorthand = true;
194560
194565
  value = id;
@@ -195332,21 +195337,21 @@ var require_esprima23 = __commonJS4({
195332
195337
  this.tolerateError(messages_1.Messages.StrictVarName);
195333
195338
  }
195334
195339
  }
195335
- var init = null;
195340
+ var init2 = null;
195336
195341
  if (kind === "const") {
195337
195342
  if (!this.matchKeyword("in") && !this.matchContextualKeyword("of")) {
195338
195343
  if (this.match("=")) {
195339
195344
  this.nextToken();
195340
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
195345
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
195341
195346
  } else {
195342
195347
  this.throwError(messages_1.Messages.DeclarationMissingInitializer, "const");
195343
195348
  }
195344
195349
  }
195345
195350
  } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match("=")) {
195346
195351
  this.expect("=");
195347
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
195352
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
195348
195353
  }
195349
- return this.finalize(node, new Node.VariableDeclarator(id, init));
195354
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
195350
195355
  };
195351
195356
  Parser2.prototype.parseBindingList = function(kind, options) {
195352
195357
  var list = [this.parseLexicalBinding(kind, options)];
@@ -195410,17 +195415,17 @@ var require_esprima23 = __commonJS4({
195410
195415
  if (this.lookahead.type === 3) {
195411
195416
  var keyToken = this.lookahead;
195412
195417
  key = this.parseVariableIdentifier();
195413
- var init = this.finalize(node, new Node.Identifier(keyToken.value));
195418
+ var init2 = this.finalize(node, new Node.Identifier(keyToken.value));
195414
195419
  if (this.match("=")) {
195415
195420
  params.push(keyToken);
195416
195421
  shorthand = true;
195417
195422
  this.nextToken();
195418
195423
  var expr = this.parseAssignmentExpression();
195419
- value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
195424
+ value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init2, expr));
195420
195425
  } else if (!this.match(":")) {
195421
195426
  params.push(keyToken);
195422
195427
  shorthand = true;
195423
- value = init;
195428
+ value = init2;
195424
195429
  } else {
195425
195430
  this.expect(":");
195426
195431
  value = this.parsePatternWithDefault(params, kind);
@@ -195505,14 +195510,14 @@ var require_esprima23 = __commonJS4({
195505
195510
  this.tolerateError(messages_1.Messages.StrictVarName);
195506
195511
  }
195507
195512
  }
195508
- var init = null;
195513
+ var init2 = null;
195509
195514
  if (this.match("=")) {
195510
195515
  this.nextToken();
195511
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
195516
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
195512
195517
  } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
195513
195518
  this.expect("=");
195514
195519
  }
195515
- return this.finalize(node, new Node.VariableDeclarator(id, init));
195520
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
195516
195521
  };
195517
195522
  Parser2.prototype.parseVariableDeclarationList = function(options) {
195518
195523
  var opt = { inFor: options.inFor };
@@ -195607,7 +195612,7 @@ var require_esprima23 = __commonJS4({
195607
195612
  return this.finalize(node, new Node.WhileStatement(test, body));
195608
195613
  };
195609
195614
  Parser2.prototype.parseForStatement = function() {
195610
- var init = null;
195615
+ var init2 = null;
195611
195616
  var test = null;
195612
195617
  var update = null;
195613
195618
  var forIn = true;
@@ -195619,7 +195624,7 @@ var require_esprima23 = __commonJS4({
195619
195624
  this.nextToken();
195620
195625
  } else {
195621
195626
  if (this.matchKeyword("var")) {
195622
- init = this.createNode();
195627
+ init2 = this.createNode();
195623
195628
  this.nextToken();
195624
195629
  var previousAllowIn = this.context.allowIn;
195625
195630
  this.context.allowIn = false;
@@ -195630,87 +195635,87 @@ var require_esprima23 = __commonJS4({
195630
195635
  if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
195631
195636
  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, "for-in");
195632
195637
  }
195633
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
195638
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
195634
195639
  this.nextToken();
195635
- left = init;
195640
+ left = init2;
195636
195641
  right = this.parseExpression();
195637
- init = null;
195642
+ init2 = null;
195638
195643
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
195639
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
195644
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
195640
195645
  this.nextToken();
195641
- left = init;
195646
+ left = init2;
195642
195647
  right = this.parseAssignmentExpression();
195643
- init = null;
195648
+ init2 = null;
195644
195649
  forIn = false;
195645
195650
  } else {
195646
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
195651
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
195647
195652
  this.expect(";");
195648
195653
  }
195649
195654
  } else if (this.matchKeyword("const") || this.matchKeyword("let")) {
195650
- init = this.createNode();
195655
+ init2 = this.createNode();
195651
195656
  var kind = this.nextToken().value;
195652
195657
  if (!this.context.strict && this.lookahead.value === "in") {
195653
- init = this.finalize(init, new Node.Identifier(kind));
195658
+ init2 = this.finalize(init2, new Node.Identifier(kind));
195654
195659
  this.nextToken();
195655
- left = init;
195660
+ left = init2;
195656
195661
  right = this.parseExpression();
195657
- init = null;
195662
+ init2 = null;
195658
195663
  } else {
195659
195664
  var previousAllowIn = this.context.allowIn;
195660
195665
  this.context.allowIn = false;
195661
195666
  var declarations = this.parseBindingList(kind, { inFor: true });
195662
195667
  this.context.allowIn = previousAllowIn;
195663
195668
  if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword("in")) {
195664
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
195669
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
195665
195670
  this.nextToken();
195666
- left = init;
195671
+ left = init2;
195667
195672
  right = this.parseExpression();
195668
- init = null;
195673
+ init2 = null;
195669
195674
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
195670
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
195675
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
195671
195676
  this.nextToken();
195672
- left = init;
195677
+ left = init2;
195673
195678
  right = this.parseAssignmentExpression();
195674
- init = null;
195679
+ init2 = null;
195675
195680
  forIn = false;
195676
195681
  } else {
195677
195682
  this.consumeSemicolon();
195678
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
195683
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
195679
195684
  }
195680
195685
  }
195681
195686
  } else {
195682
195687
  var initStartToken = this.lookahead;
195683
195688
  var previousAllowIn = this.context.allowIn;
195684
195689
  this.context.allowIn = false;
195685
- init = this.inheritCoverGrammar(this.parseAssignmentExpression);
195690
+ init2 = this.inheritCoverGrammar(this.parseAssignmentExpression);
195686
195691
  this.context.allowIn = previousAllowIn;
195687
195692
  if (this.matchKeyword("in")) {
195688
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
195693
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
195689
195694
  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
195690
195695
  }
195691
195696
  this.nextToken();
195692
- this.reinterpretExpressionAsPattern(init);
195693
- left = init;
195697
+ this.reinterpretExpressionAsPattern(init2);
195698
+ left = init2;
195694
195699
  right = this.parseExpression();
195695
- init = null;
195700
+ init2 = null;
195696
195701
  } else if (this.matchContextualKeyword("of")) {
195697
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
195702
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
195698
195703
  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
195699
195704
  }
195700
195705
  this.nextToken();
195701
- this.reinterpretExpressionAsPattern(init);
195702
- left = init;
195706
+ this.reinterpretExpressionAsPattern(init2);
195707
+ left = init2;
195703
195708
  right = this.parseAssignmentExpression();
195704
- init = null;
195709
+ init2 = null;
195705
195710
  forIn = false;
195706
195711
  } else {
195707
195712
  if (this.match(",")) {
195708
- var initSeq = [init];
195713
+ var initSeq = [init2];
195709
195714
  while (this.match(",")) {
195710
195715
  this.nextToken();
195711
195716
  initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
195712
195717
  }
195713
- init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
195718
+ init2 = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
195714
195719
  }
195715
195720
  this.expect(";");
195716
195721
  }
@@ -195736,7 +195741,7 @@ var require_esprima23 = __commonJS4({
195736
195741
  body = this.isolateCoverGrammar(this.parseStatement);
195737
195742
  this.context.inIteration = previousInIteration;
195738
195743
  }
195739
- return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
195744
+ return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init2, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
195740
195745
  };
195741
195746
  Parser2.prototype.parseContinueStatement = function() {
195742
195747
  var node = this.createNode();
@@ -201109,10 +201114,10 @@ var require_printer3 = __commonJS4({
201109
201114
  return (0, lines_1.concat)(parts);
201110
201115
  }
201111
201116
  case "ForStatement": {
201112
- var init = path32.call(print113, "init");
201113
- var sep32 = init.length > 1 ? ";\n" : "; ";
201117
+ var init2 = path32.call(print113, "init");
201118
+ var sep32 = init2.length > 1 ? ";\n" : "; ";
201114
201119
  var forParen = "for (";
201115
- var indented = (0, lines_1.fromString)(sep32).join([init, path32.call(print113, "test"), path32.call(print113, "update")]).indentTail(forParen.length);
201120
+ var indented = (0, lines_1.fromString)(sep32).join([init2, path32.call(print113, "test"), path32.call(print113, "update")]).indentTail(forParen.length);
201116
201121
  var head = (0, lines_1.concat)([forParen, indented, ")"]);
201117
201122
  var clause = adjustClause(path32.call(print113, "body"), options);
201118
201123
  parts.push(head);
@@ -223447,10 +223452,10 @@ var require_ponyfill_es20182 = __commonJS5({
223447
223452
  }
223448
223453
  return size;
223449
223454
  }
223450
- function convertQueuingStrategy(init, context) {
223451
- assertDictionary(init, context);
223452
- const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
223453
- const size = init === null || init === void 0 ? void 0 : init.size;
223455
+ function convertQueuingStrategy(init2, context) {
223456
+ assertDictionary(init2, context);
223457
+ const highWaterMark = init2 === null || init2 === void 0 ? void 0 : init2.highWaterMark;
223458
+ const size = init2 === null || init2 === void 0 ? void 0 : init2.size;
223454
223459
  return {
223455
223460
  highWaterMark: highWaterMark === void 0 ? void 0 : convertUnrestrictedDouble(highWaterMark),
223456
223461
  size: size === void 0 ? void 0 : convertQueuingStrategySize(size, `${context} has member 'size' that`)
@@ -225302,9 +225307,9 @@ var require_ponyfill_es20182 = __commonJS5({
225302
225307
  function streamBrandCheckException$1(name) {
225303
225308
  return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);
225304
225309
  }
225305
- function convertQueuingStrategyInit(init, context) {
225306
- assertDictionary(init, context);
225307
- const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
225310
+ function convertQueuingStrategyInit(init2, context) {
225311
+ assertDictionary(init2, context);
225312
+ const highWaterMark = init2 === null || init2 === void 0 ? void 0 : init2.highWaterMark;
225308
225313
  assertRequiredField(highWaterMark, "highWaterMark", "QueuingStrategyInit");
225309
225314
  return {
225310
225315
  highWaterMark: convertUnrestrictedDouble(highWaterMark)
@@ -234472,10 +234477,10 @@ var require_generated24 = __commonJS5({
234472
234477
  body
234473
234478
  });
234474
234479
  }
234475
- function forStatement(init = null, test = null, update = null, body) {
234480
+ function forStatement(init2 = null, test = null, update = null, body) {
234476
234481
  return (0, _validateNode.default)({
234477
234482
  type: "ForStatement",
234478
- init,
234483
+ init: init2,
234479
234484
  test,
234480
234485
  update,
234481
234486
  body
@@ -234693,11 +234698,11 @@ var require_generated24 = __commonJS5({
234693
234698
  declarations
234694
234699
  });
234695
234700
  }
234696
- function variableDeclarator(id, init = null) {
234701
+ function variableDeclarator(id, init2 = null) {
234697
234702
  return (0, _validateNode.default)({
234698
234703
  type: "VariableDeclarator",
234699
234704
  id,
234700
- init
234705
+ init: init2
234701
234706
  });
234702
234707
  }
234703
234708
  function whileStatement(test, body) {
@@ -235399,18 +235404,18 @@ var require_generated24 = __commonJS5({
235399
235404
  init: null
235400
235405
  });
235401
235406
  }
235402
- function enumNumberMember(id, init) {
235407
+ function enumNumberMember(id, init2) {
235403
235408
  return (0, _validateNode.default)({
235404
235409
  type: "EnumNumberMember",
235405
235410
  id,
235406
- init
235411
+ init: init2
235407
235412
  });
235408
235413
  }
235409
- function enumStringMember(id, init) {
235414
+ function enumStringMember(id, init2) {
235410
235415
  return (0, _validateNode.default)({
235411
235416
  type: "EnumStringMember",
235412
235417
  id,
235413
- init
235418
+ init: init2
235414
235419
  });
235415
235420
  }
235416
235421
  function enumDefaultedMember(id) {
@@ -247116,13 +247121,13 @@ var require_lib64 = __commonJS5({
247116
247121
  flowEnumMemberRaw() {
247117
247122
  const loc = this.state.startLoc;
247118
247123
  const id = this.parseIdentifier(true);
247119
- const init = this.eat(29) ? this.flowEnumMemberInit() : {
247124
+ const init2 = this.eat(29) ? this.flowEnumMemberInit() : {
247120
247125
  type: "none",
247121
247126
  loc
247122
247127
  };
247123
247128
  return {
247124
247129
  id,
247125
- init
247130
+ init: init2
247126
247131
  };
247127
247132
  }
247128
247133
  flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
@@ -247156,7 +247161,7 @@ var require_lib64 = __commonJS5({
247156
247161
  const memberNode = this.startNode();
247157
247162
  const {
247158
247163
  id,
247159
- init
247164
+ init: init2
247160
247165
  } = this.flowEnumMemberRaw();
247161
247166
  const memberName = id.name;
247162
247167
  if (memberName === "") {
@@ -247182,35 +247187,35 @@ var require_lib64 = __commonJS5({
247182
247187
  memberName
247183
247188
  };
247184
247189
  memberNode.id = id;
247185
- switch (init.type) {
247190
+ switch (init2.type) {
247186
247191
  case "boolean": {
247187
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
247188
- memberNode.init = init.value;
247192
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "boolean");
247193
+ memberNode.init = init2.value;
247189
247194
  members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
247190
247195
  break;
247191
247196
  }
247192
247197
  case "number": {
247193
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
247194
- memberNode.init = init.value;
247198
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "number");
247199
+ memberNode.init = init2.value;
247195
247200
  members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
247196
247201
  break;
247197
247202
  }
247198
247203
  case "string": {
247199
- this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
247200
- memberNode.init = init.value;
247204
+ this.flowEnumCheckExplicitTypeMismatch(init2.loc, context, "string");
247205
+ memberNode.init = init2.value;
247201
247206
  members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
247202
247207
  break;
247203
247208
  }
247204
247209
  case "invalid": {
247205
- throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
247210
+ throw this.flowEnumErrorInvalidMemberInitializer(init2.loc, context);
247206
247211
  }
247207
247212
  case "none": {
247208
247213
  switch (explicitType) {
247209
247214
  case "boolean":
247210
- this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
247215
+ this.flowEnumErrorBooleanMemberNotInitialized(init2.loc, context);
247211
247216
  break;
247212
247217
  case "number":
247213
- this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
247218
+ this.flowEnumErrorNumberMemberNotInitialized(init2.loc, context);
247214
247219
  break;
247215
247220
  default:
247216
247221
  members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
@@ -250311,14 +250316,14 @@ var require_lib64 = __commonJS5({
250311
250316
  return declaration;
250312
250317
  for (const {
250313
250318
  id,
250314
- init
250319
+ init: init2
250315
250320
  } of declaration.declarations) {
250316
- if (!init)
250321
+ if (!init2)
250317
250322
  continue;
250318
250323
  if (kind !== "const" || !!id.typeAnnotation) {
250319
- this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
250320
- } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
250321
- this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
250324
+ this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init2);
250325
+ } else if (!isValidAmbientConstInitializer(init2, this.hasPlugin("estree"))) {
250326
+ this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, init2);
250322
250327
  }
250323
250328
  }
250324
250329
  return declaration;
@@ -253798,49 +253803,49 @@ var require_lib64 = __commonJS5({
253798
253803
  }
253799
253804
  this.next();
253800
253805
  this.parseVar(initNode, true, kind);
253801
- const init2 = this.finishNode(initNode, "VariableDeclaration");
253806
+ const init3 = this.finishNode(initNode, "VariableDeclaration");
253802
253807
  const isForIn = this.match(58);
253803
253808
  if (isForIn && starsWithUsingDeclaration) {
253804
- this.raise(Errors.ForInUsing, init2);
253809
+ this.raise(Errors.ForInUsing, init3);
253805
253810
  }
253806
- if ((isForIn || this.isContextual(102)) && init2.declarations.length === 1) {
253807
- return this.parseForIn(node, init2, awaitAt);
253811
+ if ((isForIn || this.isContextual(102)) && init3.declarations.length === 1) {
253812
+ return this.parseForIn(node, init3, awaitAt);
253808
253813
  }
253809
253814
  if (awaitAt !== null) {
253810
253815
  this.unexpected(awaitAt);
253811
253816
  }
253812
- return this.parseFor(node, init2);
253817
+ return this.parseFor(node, init3);
253813
253818
  }
253814
253819
  }
253815
253820
  const startsWithAsync = this.isContextual(95);
253816
253821
  const refExpressionErrors = new ExpressionErrors();
253817
- const init = this.parseExpression(true, refExpressionErrors);
253822
+ const init2 = this.parseExpression(true, refExpressionErrors);
253818
253823
  const isForOf = this.isContextual(102);
253819
253824
  if (isForOf) {
253820
253825
  if (startsWithLet) {
253821
- this.raise(Errors.ForOfLet, init);
253826
+ this.raise(Errors.ForOfLet, init2);
253822
253827
  }
253823
- if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
253824
- this.raise(Errors.ForOfAsync, init);
253828
+ if (awaitAt === null && startsWithAsync && init2.type === "Identifier") {
253829
+ this.raise(Errors.ForOfAsync, init2);
253825
253830
  }
253826
253831
  }
253827
253832
  if (isForOf || this.match(58)) {
253828
253833
  this.checkDestructuringPrivate(refExpressionErrors);
253829
- this.toAssignable(init, true);
253834
+ this.toAssignable(init2, true);
253830
253835
  const type = isForOf ? "ForOfStatement" : "ForInStatement";
253831
- this.checkLVal(init, {
253836
+ this.checkLVal(init2, {
253832
253837
  in: {
253833
253838
  type
253834
253839
  }
253835
253840
  });
253836
- return this.parseForIn(node, init, awaitAt);
253841
+ return this.parseForIn(node, init2, awaitAt);
253837
253842
  } else {
253838
253843
  this.checkExpressionErrors(refExpressionErrors, true);
253839
253844
  }
253840
253845
  if (awaitAt !== null) {
253841
253846
  this.unexpected(awaitAt);
253842
253847
  }
253843
- return this.parseFor(node, init);
253848
+ return this.parseFor(node, init2);
253844
253849
  }
253845
253850
  parseFunctionStatement(node, isAsync, isHangingDeclaration) {
253846
253851
  this.next();
@@ -254062,8 +254067,8 @@ var require_lib64 = __commonJS5({
254062
254067
  }
254063
254068
  this.next();
254064
254069
  }
254065
- parseFor(node, init) {
254066
- node.init = init;
254070
+ parseFor(node, init2) {
254071
+ node.init = init2;
254067
254072
  this.semicolon(false);
254068
254073
  node.test = this.match(13) ? null : this.parseExpression();
254069
254074
  this.semicolon(false);
@@ -254074,7 +254079,7 @@ var require_lib64 = __commonJS5({
254074
254079
  this.state.labels.pop();
254075
254080
  return this.finishNode(node, "ForStatement");
254076
254081
  }
254077
- parseForIn(node, init, awaitAt) {
254082
+ parseForIn(node, init2, awaitAt) {
254078
254083
  const isForIn = this.match(58);
254079
254084
  this.next();
254080
254085
  if (isForIn) {
@@ -254083,19 +254088,19 @@ var require_lib64 = __commonJS5({
254083
254088
  } else {
254084
254089
  node.await = awaitAt !== null;
254085
254090
  }
254086
- if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
254087
- this.raise(Errors.ForInOfLoopInitializer, init, {
254091
+ if (init2.type === "VariableDeclaration" && init2.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init2.kind !== "var" || init2.declarations[0].id.type !== "Identifier")) {
254092
+ this.raise(Errors.ForInOfLoopInitializer, init2, {
254088
254093
  type: isForIn ? "ForInStatement" : "ForOfStatement"
254089
254094
  });
254090
254095
  }
254091
- if (init.type === "AssignmentPattern") {
254092
- this.raise(Errors.InvalidLhs, init, {
254096
+ if (init2.type === "AssignmentPattern") {
254097
+ this.raise(Errors.InvalidLhs, init2, {
254093
254098
  ancestor: {
254094
254099
  type: "ForStatement"
254095
254100
  }
254096
254101
  });
254097
254102
  }
254098
- node.left = init;
254103
+ node.left = init2;
254099
254104
  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
254100
254105
  this.expect(11);
254101
254106
  node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
@@ -256039,11 +256044,11 @@ var require_types5 = __commonJS5({
256039
256044
  }();
256040
256045
  exports.Def = Def;
256041
256046
  var Field = function() {
256042
- function Field2(name, type, defaultFn, hidden62) {
256047
+ function Field2(name, type, defaultFn, hidden72) {
256043
256048
  this.name = name;
256044
256049
  this.type = type;
256045
256050
  this.defaultFn = defaultFn;
256046
- this.hidden = !!hidden62;
256051
+ this.hidden = !!hidden72;
256047
256052
  }
256048
256053
  Field2.prototype.toString = function() {
256049
256054
  return JSON.stringify(this.name) + ": " + this.type;
@@ -256292,12 +256297,12 @@ var require_types5 = __commonJS5({
256292
256297
  });
256293
256298
  return this;
256294
256299
  };
256295
- DefImpl2.prototype.field = function(name, type, defaultFn, hidden62) {
256300
+ DefImpl2.prototype.field = function(name, type, defaultFn, hidden72) {
256296
256301
  if (this.finalized) {
256297
256302
  console.error("Ignoring attempt to redefine field " + JSON.stringify(name) + " of finalized type " + JSON.stringify(this.typeName));
256298
256303
  return this;
256299
256304
  }
256300
- this.ownFields[name] = new Field(name, Type.from(type), defaultFn, hidden62);
256305
+ this.ownFields[name] = new Field(name, Type.from(type), defaultFn, hidden72);
256301
256306
  return this;
256302
256307
  };
256303
256308
  DefImpl2.prototype.finalize = function() {
@@ -256894,13 +256899,13 @@ var require_scope5 = __commonJS5({
256894
256899
  var name = prefix + index;
256895
256900
  return this.bindings[name] = types19.builders.identifier(name);
256896
256901
  };
256897
- Sp.injectTemporary = function(identifier, init) {
256902
+ Sp.injectTemporary = function(identifier, init2) {
256898
256903
  identifier || (identifier = this.declareTemporary());
256899
256904
  var bodyPath = this.path.get("body");
256900
256905
  if (namedTypes.BlockStatement.check(bodyPath.value)) {
256901
256906
  bodyPath = bodyPath.get("body");
256902
256907
  }
256903
- bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
256908
+ bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init2 || null)]));
256904
256909
  return identifier;
256905
256910
  };
256906
256911
  Sp.scan = function(force) {
@@ -257669,7 +257674,7 @@ var require_path_visitor5 = __commonJS5({
257669
257674
  return Context;
257670
257675
  }
257671
257676
  var sharedContextProtoMethods = /* @__PURE__ */ Object.create(null);
257672
- sharedContextProtoMethods.reset = function reset62(path42) {
257677
+ sharedContextProtoMethods.reset = function reset72(path42) {
257673
257678
  if (!(this instanceof this.Context)) {
257674
257679
  throw new Error("");
257675
257680
  }
@@ -262380,9 +262385,9 @@ var require_esprima24 = __commonJS5({
262380
262385
  }();
262381
262386
  exports2.ForOfStatement = ForOfStatement;
262382
262387
  var ForStatement = function() {
262383
- function ForStatement2(init, test, update, body) {
262388
+ function ForStatement2(init2, test, update, body) {
262384
262389
  this.type = syntax_1.Syntax.ForStatement;
262385
- this.init = init;
262390
+ this.init = init2;
262386
262391
  this.test = test;
262387
262392
  this.update = update;
262388
262393
  this.body = body;
@@ -262722,10 +262727,10 @@ var require_esprima24 = __commonJS5({
262722
262727
  }();
262723
262728
  exports2.VariableDeclaration = VariableDeclaration;
262724
262729
  var VariableDeclarator = function() {
262725
- function VariableDeclarator2(id, init) {
262730
+ function VariableDeclarator2(id, init2) {
262726
262731
  this.type = syntax_1.Syntax.VariableDeclarator;
262727
262732
  this.id = id;
262728
- this.init = init;
262733
+ this.init = init2;
262729
262734
  }
262730
262735
  return VariableDeclarator2;
262731
262736
  }();
@@ -263430,8 +263435,8 @@ var require_esprima24 = __commonJS5({
263430
263435
  this.context.firstCoverInitializedNameError = this.lookahead;
263431
263436
  this.nextToken();
263432
263437
  shorthand = true;
263433
- var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
263434
- value = this.finalize(node, new Node.AssignmentPattern(id, init));
263438
+ var init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
263439
+ value = this.finalize(node, new Node.AssignmentPattern(id, init2));
263435
263440
  } else {
263436
263441
  shorthand = true;
263437
263442
  value = id;
@@ -264209,21 +264214,21 @@ var require_esprima24 = __commonJS5({
264209
264214
  this.tolerateError(messages_1.Messages.StrictVarName);
264210
264215
  }
264211
264216
  }
264212
- var init = null;
264217
+ var init2 = null;
264213
264218
  if (kind === "const") {
264214
264219
  if (!this.matchKeyword("in") && !this.matchContextualKeyword("of")) {
264215
264220
  if (this.match("=")) {
264216
264221
  this.nextToken();
264217
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
264222
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
264218
264223
  } else {
264219
264224
  this.throwError(messages_1.Messages.DeclarationMissingInitializer, "const");
264220
264225
  }
264221
264226
  }
264222
264227
  } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match("=")) {
264223
264228
  this.expect("=");
264224
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
264229
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
264225
264230
  }
264226
- return this.finalize(node, new Node.VariableDeclarator(id, init));
264231
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
264227
264232
  };
264228
264233
  Parser2.prototype.parseBindingList = function(kind, options) {
264229
264234
  var list = [this.parseLexicalBinding(kind, options)];
@@ -264287,17 +264292,17 @@ var require_esprima24 = __commonJS5({
264287
264292
  if (this.lookahead.type === 3) {
264288
264293
  var keyToken = this.lookahead;
264289
264294
  key = this.parseVariableIdentifier();
264290
- var init = this.finalize(node, new Node.Identifier(keyToken.value));
264295
+ var init2 = this.finalize(node, new Node.Identifier(keyToken.value));
264291
264296
  if (this.match("=")) {
264292
264297
  params.push(keyToken);
264293
264298
  shorthand = true;
264294
264299
  this.nextToken();
264295
264300
  var expr = this.parseAssignmentExpression();
264296
- value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
264301
+ value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init2, expr));
264297
264302
  } else if (!this.match(":")) {
264298
264303
  params.push(keyToken);
264299
264304
  shorthand = true;
264300
- value = init;
264305
+ value = init2;
264301
264306
  } else {
264302
264307
  this.expect(":");
264303
264308
  value = this.parsePatternWithDefault(params, kind);
@@ -264382,14 +264387,14 @@ var require_esprima24 = __commonJS5({
264382
264387
  this.tolerateError(messages_1.Messages.StrictVarName);
264383
264388
  }
264384
264389
  }
264385
- var init = null;
264390
+ var init2 = null;
264386
264391
  if (this.match("=")) {
264387
264392
  this.nextToken();
264388
- init = this.isolateCoverGrammar(this.parseAssignmentExpression);
264393
+ init2 = this.isolateCoverGrammar(this.parseAssignmentExpression);
264389
264394
  } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
264390
264395
  this.expect("=");
264391
264396
  }
264392
- return this.finalize(node, new Node.VariableDeclarator(id, init));
264397
+ return this.finalize(node, new Node.VariableDeclarator(id, init2));
264393
264398
  };
264394
264399
  Parser2.prototype.parseVariableDeclarationList = function(options) {
264395
264400
  var opt = { inFor: options.inFor };
@@ -264484,7 +264489,7 @@ var require_esprima24 = __commonJS5({
264484
264489
  return this.finalize(node, new Node.WhileStatement(test, body));
264485
264490
  };
264486
264491
  Parser2.prototype.parseForStatement = function() {
264487
- var init = null;
264492
+ var init2 = null;
264488
264493
  var test = null;
264489
264494
  var update = null;
264490
264495
  var forIn = true;
@@ -264496,7 +264501,7 @@ var require_esprima24 = __commonJS5({
264496
264501
  this.nextToken();
264497
264502
  } else {
264498
264503
  if (this.matchKeyword("var")) {
264499
- init = this.createNode();
264504
+ init2 = this.createNode();
264500
264505
  this.nextToken();
264501
264506
  var previousAllowIn = this.context.allowIn;
264502
264507
  this.context.allowIn = false;
@@ -264507,87 +264512,87 @@ var require_esprima24 = __commonJS5({
264507
264512
  if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
264508
264513
  this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, "for-in");
264509
264514
  }
264510
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
264515
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
264511
264516
  this.nextToken();
264512
- left = init;
264517
+ left = init2;
264513
264518
  right = this.parseExpression();
264514
- init = null;
264519
+ init2 = null;
264515
264520
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
264516
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
264521
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
264517
264522
  this.nextToken();
264518
- left = init;
264523
+ left = init2;
264519
264524
  right = this.parseAssignmentExpression();
264520
- init = null;
264525
+ init2 = null;
264521
264526
  forIn = false;
264522
264527
  } else {
264523
- init = this.finalize(init, new Node.VariableDeclaration(declarations, "var"));
264528
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, "var"));
264524
264529
  this.expect(";");
264525
264530
  }
264526
264531
  } else if (this.matchKeyword("const") || this.matchKeyword("let")) {
264527
- init = this.createNode();
264532
+ init2 = this.createNode();
264528
264533
  var kind = this.nextToken().value;
264529
264534
  if (!this.context.strict && this.lookahead.value === "in") {
264530
- init = this.finalize(init, new Node.Identifier(kind));
264535
+ init2 = this.finalize(init2, new Node.Identifier(kind));
264531
264536
  this.nextToken();
264532
- left = init;
264537
+ left = init2;
264533
264538
  right = this.parseExpression();
264534
- init = null;
264539
+ init2 = null;
264535
264540
  } else {
264536
264541
  var previousAllowIn = this.context.allowIn;
264537
264542
  this.context.allowIn = false;
264538
264543
  var declarations = this.parseBindingList(kind, { inFor: true });
264539
264544
  this.context.allowIn = previousAllowIn;
264540
264545
  if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword("in")) {
264541
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
264546
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
264542
264547
  this.nextToken();
264543
- left = init;
264548
+ left = init2;
264544
264549
  right = this.parseExpression();
264545
- init = null;
264550
+ init2 = null;
264546
264551
  } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) {
264547
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
264552
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
264548
264553
  this.nextToken();
264549
- left = init;
264554
+ left = init2;
264550
264555
  right = this.parseAssignmentExpression();
264551
- init = null;
264556
+ init2 = null;
264552
264557
  forIn = false;
264553
264558
  } else {
264554
264559
  this.consumeSemicolon();
264555
- init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
264560
+ init2 = this.finalize(init2, new Node.VariableDeclaration(declarations, kind));
264556
264561
  }
264557
264562
  }
264558
264563
  } else {
264559
264564
  var initStartToken = this.lookahead;
264560
264565
  var previousAllowIn = this.context.allowIn;
264561
264566
  this.context.allowIn = false;
264562
- init = this.inheritCoverGrammar(this.parseAssignmentExpression);
264567
+ init2 = this.inheritCoverGrammar(this.parseAssignmentExpression);
264563
264568
  this.context.allowIn = previousAllowIn;
264564
264569
  if (this.matchKeyword("in")) {
264565
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
264570
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
264566
264571
  this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
264567
264572
  }
264568
264573
  this.nextToken();
264569
- this.reinterpretExpressionAsPattern(init);
264570
- left = init;
264574
+ this.reinterpretExpressionAsPattern(init2);
264575
+ left = init2;
264571
264576
  right = this.parseExpression();
264572
- init = null;
264577
+ init2 = null;
264573
264578
  } else if (this.matchContextualKeyword("of")) {
264574
- if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
264579
+ if (!this.context.isAssignmentTarget || init2.type === syntax_1.Syntax.AssignmentExpression) {
264575
264580
  this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
264576
264581
  }
264577
264582
  this.nextToken();
264578
- this.reinterpretExpressionAsPattern(init);
264579
- left = init;
264583
+ this.reinterpretExpressionAsPattern(init2);
264584
+ left = init2;
264580
264585
  right = this.parseAssignmentExpression();
264581
- init = null;
264586
+ init2 = null;
264582
264587
  forIn = false;
264583
264588
  } else {
264584
264589
  if (this.match(",")) {
264585
- var initSeq = [init];
264590
+ var initSeq = [init2];
264586
264591
  while (this.match(",")) {
264587
264592
  this.nextToken();
264588
264593
  initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
264589
264594
  }
264590
- init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
264595
+ init2 = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
264591
264596
  }
264592
264597
  this.expect(";");
264593
264598
  }
@@ -264613,7 +264618,7 @@ var require_esprima24 = __commonJS5({
264613
264618
  body = this.isolateCoverGrammar(this.parseStatement);
264614
264619
  this.context.inIteration = previousInIteration;
264615
264620
  }
264616
- return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
264621
+ return typeof left === "undefined" ? this.finalize(node, new Node.ForStatement(init2, test, update, body)) : forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) : this.finalize(node, new Node.ForOfStatement(left, right, body));
264617
264622
  };
264618
264623
  Parser2.prototype.parseContinueStatement = function() {
264619
264624
  var node = this.createNode();
@@ -269986,10 +269991,10 @@ var require_printer5 = __commonJS5({
269986
269991
  return (0, lines_1.concat)(parts);
269987
269992
  }
269988
269993
  case "ForStatement": {
269989
- var init = path42.call(print132, "init");
269990
- var sep32 = init.length > 1 ? ";\n" : "; ";
269994
+ var init2 = path42.call(print132, "init");
269995
+ var sep32 = init2.length > 1 ? ";\n" : "; ";
269991
269996
  var forParen = "for (";
269992
- var indented = (0, lines_1.fromString)(sep32).join([init, path42.call(print132, "test"), path42.call(print132, "update")]).indentTail(forParen.length);
269997
+ var indented = (0, lines_1.fromString)(sep32).join([init2, path42.call(print132, "test"), path42.call(print132, "update")]).indentTail(forParen.length);
269993
269998
  var head = (0, lines_1.concat)([forParen, indented, ")"]);
269994
269999
  var clause = adjustClause(path42.call(print132, "body"), options);
269995
270000
  parts.push(head);
@@ -278197,23 +278202,23 @@ var validateHeaderValue2 = typeof import_node_http2.default.validateHeaderValue
278197
278202
  }
278198
278203
  };
278199
278204
  var Headers2 = class extends URLSearchParams {
278200
- constructor(init) {
278205
+ constructor(init2) {
278201
278206
  let result = [];
278202
- if (init instanceof Headers2) {
278203
- const raw = init.raw();
278207
+ if (init2 instanceof Headers2) {
278208
+ const raw = init2.raw();
278204
278209
  for (const [name, values] of Object.entries(raw)) {
278205
278210
  result.push(...values.map((value) => [name, value]));
278206
278211
  }
278207
- } else if (init == null) {
278208
- } else if (typeof init === "object" && !import_node_util9.types.isBoxedPrimitive(init)) {
278209
- const method = init[Symbol.iterator];
278212
+ } else if (init2 == null) {
278213
+ } else if (typeof init2 === "object" && !import_node_util9.types.isBoxedPrimitive(init2)) {
278214
+ const method = init2[Symbol.iterator];
278210
278215
  if (method == null) {
278211
- result.push(...Object.entries(init));
278216
+ result.push(...Object.entries(init2));
278212
278217
  } else {
278213
278218
  if (typeof method !== "function") {
278214
278219
  throw new TypeError("Header pairs must be iterable");
278215
278220
  }
278216
- result = [...init].map((pair) => {
278221
+ result = [...init2].map((pair) => {
278217
278222
  if (typeof pair !== "object" || import_node_util9.types.isBoxedPrimitive(pair)) {
278218
278223
  throw new TypeError("Each header pair must be an iterable object");
278219
278224
  }
@@ -278408,17 +278413,17 @@ var Response22 = class extends Body2 {
278408
278413
  response[INTERNALS22].type = "error";
278409
278414
  return response;
278410
278415
  }
278411
- static json(data = void 0, init = {}) {
278416
+ static json(data = void 0, init2 = {}) {
278412
278417
  const body = JSON.stringify(data);
278413
278418
  if (body === void 0) {
278414
278419
  throw new TypeError("data is not JSON serializable");
278415
278420
  }
278416
- const headers = new Headers2(init && init.headers);
278421
+ const headers = new Headers2(init2 && init2.headers);
278417
278422
  if (!headers.has("content-type")) {
278418
278423
  headers.set("content-type", "application/json");
278419
278424
  }
278420
278425
  return new Response22(body, {
278421
- ...init,
278426
+ ...init2,
278422
278427
  headers
278423
278428
  });
278424
278429
  }
@@ -278464,7 +278469,7 @@ var doBadDataWarn2 = (0, import_node_util10.deprecate)(
278464
278469
  "https://github.com/node-fetch/node-fetch/issues/1000 (request)"
278465
278470
  );
278466
278471
  var Request22 = class extends Body2 {
278467
- constructor(input, init = {}) {
278472
+ constructor(input, init2 = {}) {
278468
278473
  let parsedURL;
278469
278474
  if (isRequest2(input)) {
278470
278475
  parsedURL = new URL(input.url);
@@ -278475,21 +278480,21 @@ var Request22 = class extends Body2 {
278475
278480
  if (parsedURL.username !== "" || parsedURL.password !== "") {
278476
278481
  throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
278477
278482
  }
278478
- let method = init.method || input.method || "GET";
278483
+ let method = init2.method || input.method || "GET";
278479
278484
  if (/^(delete|get|head|options|post|put)$/i.test(method)) {
278480
278485
  method = method.toUpperCase();
278481
278486
  }
278482
- if (!isRequest2(init) && "data" in init) {
278487
+ if (!isRequest2(init2) && "data" in init2) {
278483
278488
  doBadDataWarn2();
278484
278489
  }
278485
- if ((init.body != null || isRequest2(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
278490
+ if ((init2.body != null || isRequest2(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
278486
278491
  throw new TypeError("Request with GET/HEAD method cannot have body");
278487
278492
  }
278488
- const inputBody = init.body ? init.body : isRequest2(input) && input.body !== null ? clone2(input) : null;
278493
+ const inputBody = init2.body ? init2.body : isRequest2(input) && input.body !== null ? clone2(input) : null;
278489
278494
  super(inputBody, {
278490
- size: init.size || input.size || 0
278495
+ size: init2.size || input.size || 0
278491
278496
  });
278492
- const headers = new Headers2(init.headers || input.headers || {});
278497
+ const headers = new Headers2(init2.headers || input.headers || {});
278493
278498
  if (inputBody !== null && !headers.has("Content-Type")) {
278494
278499
  const contentType = extractContentType2(inputBody, this);
278495
278500
  if (contentType) {
@@ -278497,13 +278502,13 @@ var Request22 = class extends Body2 {
278497
278502
  }
278498
278503
  }
278499
278504
  let signal = isRequest2(input) ? input.signal : null;
278500
- if ("signal" in init) {
278501
- signal = init.signal;
278505
+ if ("signal" in init2) {
278506
+ signal = init2.signal;
278502
278507
  }
278503
278508
  if (signal != null && !isAbortSignal2(signal)) {
278504
278509
  throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
278505
278510
  }
278506
- let referrer = init.referrer == null ? input.referrer : init.referrer;
278511
+ let referrer = init2.referrer == null ? input.referrer : init2.referrer;
278507
278512
  if (referrer === "") {
278508
278513
  referrer = "no-referrer";
278509
278514
  } else if (referrer) {
@@ -278514,19 +278519,19 @@ var Request22 = class extends Body2 {
278514
278519
  }
278515
278520
  this[INTERNALS32] = {
278516
278521
  method,
278517
- redirect: init.redirect || input.redirect || "follow",
278522
+ redirect: init2.redirect || input.redirect || "follow",
278518
278523
  headers,
278519
278524
  parsedURL,
278520
278525
  signal,
278521
278526
  referrer
278522
278527
  };
278523
- this.follow = init.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init.follow;
278524
- this.compress = init.compress === void 0 ? input.compress === void 0 ? true : input.compress : init.compress;
278525
- this.counter = init.counter || input.counter || 0;
278526
- this.agent = init.agent || input.agent;
278527
- this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
278528
- this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
278529
- this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
278528
+ this.follow = init2.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init2.follow;
278529
+ this.compress = init2.compress === void 0 ? input.compress === void 0 ? true : input.compress : init2.compress;
278530
+ this.counter = init2.counter || input.counter || 0;
278531
+ this.agent = init2.agent || input.agent;
278532
+ this.highWaterMark = init2.highWaterMark || input.highWaterMark || 16384;
278533
+ this.insecureHTTPParser = init2.insecureHTTPParser || input.insecureHTTPParser || false;
278534
+ this.referrerPolicy = init2.referrerPolicy || input.referrerPolicy || "";
278530
278535
  }
278531
278536
  get method() {
278532
278537
  return this[INTERNALS32].method;
@@ -281393,6 +281398,53 @@ For more information, please visit these links:
281393
281398
  - https://graphql.org/learn/global-object-identification/
281394
281399
  - ${siteURL3}/guides/caching-data#custom-ids
281395
281400
  `;
281401
+ var FORCE_COLOR;
281402
+ var NODE_DISABLE_COLORS;
281403
+ var NO_COLOR;
281404
+ var TERM;
281405
+ var isTTY = true;
281406
+ if (typeof process !== "undefined") {
281407
+ ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
281408
+ isTTY = process.stdout && process.stdout.isTTY;
281409
+ }
281410
+ var $ = {
281411
+ enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
281412
+ };
281413
+ function init(x22, y) {
281414
+ let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
281415
+ let open = `\x1B[${x22}m`, close = `\x1B[${y}m`;
281416
+ return function(txt) {
281417
+ if (!$.enabled || txt == null)
281418
+ return txt;
281419
+ return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
281420
+ };
281421
+ }
281422
+ var reset6 = init(0, 0);
281423
+ var bold6 = init(1, 22);
281424
+ var dim6 = init(2, 22);
281425
+ var italic6 = init(3, 23);
281426
+ var underline6 = init(4, 24);
281427
+ var inverse6 = init(7, 27);
281428
+ var hidden6 = init(8, 28);
281429
+ var strikethrough6 = init(9, 29);
281430
+ var black6 = init(30, 39);
281431
+ var red6 = init(31, 39);
281432
+ var green6 = init(32, 39);
281433
+ var yellow6 = init(33, 39);
281434
+ var blue6 = init(34, 39);
281435
+ var magenta6 = init(35, 39);
281436
+ var cyan6 = init(36, 39);
281437
+ var white6 = init(37, 39);
281438
+ var gray6 = init(90, 39);
281439
+ var grey = init(90, 39);
281440
+ var bgBlack6 = init(40, 49);
281441
+ var bgRed6 = init(41, 49);
281442
+ var bgGreen6 = init(42, 49);
281443
+ var bgYellow6 = init(43, 49);
281444
+ var bgBlue6 = init(44, 49);
281445
+ var bgMagenta6 = init(45, 49);
281446
+ var bgCyan6 = init(46, 49);
281447
+ var bgWhite6 = init(47, 49);
281396
281448
  var recast142 = __toESM5(require_main24(), 1);
281397
281449
  var AST152 = recast142.types.builders;
281398
281450
  function find_insert_index(script) {
@@ -281421,21 +281473,21 @@ function find_exported_fn(body, name) {
281421
281473
  continue;
281422
281474
  }
281423
281475
  const declaration = value.declarations[0];
281424
- let { init } = declaration;
281425
- if (!init) {
281476
+ let { init: init2 } = declaration;
281477
+ if (!init2) {
281426
281478
  continue;
281427
281479
  }
281428
- if (init.type === "TSSatisfiesExpression") {
281429
- init = init.expression;
281480
+ if (init2.type === "TSSatisfiesExpression") {
281481
+ init2 = init2.expression;
281430
281482
  }
281431
- if (init.type === "CallExpression" && init.arguments[0] && (init.arguments[0].type === "FunctionExpression" || init.arguments[0].type === "ArrowFunctionExpression")) {
281432
- init = init.arguments[0];
281483
+ if (init2.type === "CallExpression" && init2.arguments[0] && (init2.arguments[0].type === "FunctionExpression" || init2.arguments[0].type === "ArrowFunctionExpression")) {
281484
+ init2 = init2.arguments[0];
281433
281485
  }
281434
- if (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression") {
281435
- return { declaration: init, export: exportDeclaration };
281486
+ if (init2.type === "FunctionExpression" || init2.type === "ArrowFunctionExpression") {
281487
+ return { declaration: init2, export: exportDeclaration };
281436
281488
  }
281437
- if (init.type === "Identifier" || init.type === "CallExpression") {
281438
- return { declaration: init, export: exportDeclaration };
281489
+ if (init2.type === "Identifier" || init2.type === "CallExpression") {
281490
+ return { declaration: init2, export: exportDeclaration };
281439
281491
  }
281440
281492
  } else {
281441
281493
  continue;
@@ -281863,7 +281915,7 @@ var END3 = `$$KitQLEND$$`;
281863
281915
  var colorBrowser3 = (style, str) => {
281864
281916
  return `${START13}${style}${START23}${str}${END3}`;
281865
281917
  };
281866
- var yellow6 = (str) => {
281918
+ var yellow7 = (str) => {
281867
281919
  return color3("yellow", str);
281868
281920
  };
281869
281921
 
@@ -281969,7 +282021,7 @@ async function processScript(config, filepath, program, mockArtifacts) {
281969
282021
  load.push(result);
281970
282022
  if (!result) {
281971
282023
  throw new Error(
281972
- `Could not find ${yellow6(element.name)} for computing ${yellow6(houdini_load_fn)}. (if it was a global store, you need to instantiate the store manually.)
282024
+ `Could not find ${yellow7(element.name)} for computing ${yellow7(houdini_load_fn)}. (if it was a global store, you need to instantiate the store manually.)
281973
282025
  filepath: ${filepath}`
281974
282026
  );
281975
282027
  }
@@ -283238,7 +283290,7 @@ async function QueryProcessor(config, page) {
283238
283290
  if (query.variableDefinitions && query.variableDefinitions?.length > 0 && has_variables === null) {
283239
283291
  formatErrors({
283240
283292
  filepath: page.filepath,
283241
- message: `Could not find required variable function: ${yellow6(
283293
+ message: `Could not find required variable function: ${yellow7(
283242
283294
  variable_fn
283243
283295
  )}. maybe its not exported? `
283244
283296
  });
@@ -283795,7 +283847,7 @@ function variable_function_for_query(page, query, has_local) {
283795
283847
  if (missing_args.length > 0 && !has_local) {
283796
283848
  throw {
283797
283849
  filepath: page.filepath,
283798
- message: `Could not find required variable function: ${yellow6(
283850
+ message: `Could not find required variable function: ${yellow7(
283799
283851
  query_variable_fn(query.name.value)
283800
283852
  )}. maybe its not exported?`
283801
283853
  };