@putout/bundle 3.0.0 → 3.0.1

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.
Files changed (4) hide show
  1. package/bundle/putout-iife.js +1 -1
  2. package/bundle/putout.js +940 -920
  3. package/bundle/putout.min.js +1 -1
  4. package/package.json +2 -2
package/bundle/putout.js CHANGED
@@ -71154,485 +71154,495 @@ function isValidIdentifier$8(name, reserved = true) {
71154
71154
 
71155
71155
  var lib$m = {};
71156
71156
 
71157
- Object.defineProperty(lib$m, "__esModule", {
71158
- value: true
71159
- });
71160
- lib$m.readCodePoint = readCodePoint$4;
71161
- lib$m.readInt = readInt$4;
71162
- lib$m.readStringContents = readStringContents$4;
71163
- var _isDigit$4 = function isDigit(code) {
71164
- return code >= 48 && code <= 57;
71165
- };
71166
- const forbiddenNumericSeparatorSiblings$4 = {
71167
- decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
71168
- hex: new Set([46, 88, 95, 120])
71169
- };
71170
- const isAllowedNumericSeparatorSibling$4 = {
71171
- bin: ch => ch === 48 || ch === 49,
71172
- oct: ch => ch >= 48 && ch <= 55,
71173
- dec: ch => ch >= 48 && ch <= 57,
71174
- hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
71175
- };
71176
- function readStringContents$4(type, input, pos, lineStart, curLine, errors) {
71177
- const initialPos = pos;
71178
- const initialLineStart = lineStart;
71179
- const initialCurLine = curLine;
71180
- let out = "";
71181
- let firstInvalidLoc = null;
71182
- let chunkStart = pos;
71183
- const {
71184
- length
71185
- } = input;
71186
- for (;;) {
71187
- if (pos >= length) {
71188
- errors.unterminated(initialPos, initialLineStart, initialCurLine);
71189
- out += input.slice(chunkStart, pos);
71190
- break;
71191
- }
71192
- const ch = input.charCodeAt(pos);
71193
- if (isStringEnd$4(type, ch, input, pos)) {
71194
- out += input.slice(chunkStart, pos);
71195
- break;
71196
- }
71197
- if (ch === 92) {
71198
- out += input.slice(chunkStart, pos);
71199
- const res = readEscapedChar$4(input, pos, lineStart, curLine, type === "template", errors);
71200
- if (res.ch === null && !firstInvalidLoc) {
71201
- firstInvalidLoc = {
71202
- pos,
71203
- lineStart,
71204
- curLine
71205
- };
71206
- } else {
71207
- out += res.ch;
71208
- }
71209
- ({
71210
- pos,
71211
- lineStart,
71212
- curLine
71213
- } = res);
71214
- chunkStart = pos;
71215
- } else if (ch === 8232 || ch === 8233) {
71216
- ++pos;
71217
- ++curLine;
71218
- lineStart = pos;
71219
- } else if (ch === 10 || ch === 13) {
71220
- if (type === "template") {
71221
- out += input.slice(chunkStart, pos) + "\n";
71222
- ++pos;
71223
- if (ch === 13 && input.charCodeAt(pos) === 10) {
71224
- ++pos;
71225
- }
71226
- ++curLine;
71227
- chunkStart = lineStart = pos;
71228
- } else {
71229
- errors.unterminated(initialPos, initialLineStart, initialCurLine);
71230
- }
71231
- } else {
71232
- ++pos;
71233
- }
71234
- }
71235
- return {
71236
- pos,
71237
- str: out,
71238
- firstInvalidLoc,
71239
- lineStart,
71240
- curLine,
71241
- containsInvalid: !!firstInvalidLoc
71242
- };
71243
- }
71244
- function isStringEnd$4(type, ch, input, pos) {
71245
- if (type === "template") {
71246
- return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
71247
- }
71248
- return ch === (type === "double" ? 34 : 39);
71249
- }
71250
- function readEscapedChar$4(input, pos, lineStart, curLine, inTemplate, errors) {
71251
- const throwOnInvalid = !inTemplate;
71252
- pos++;
71253
- const res = ch => ({
71254
- pos,
71255
- ch,
71256
- lineStart,
71257
- curLine
71258
- });
71259
- const ch = input.charCodeAt(pos++);
71260
- switch (ch) {
71261
- case 110:
71262
- return res("\n");
71263
- case 114:
71264
- return res("\r");
71265
- case 120:
71266
- {
71267
- let code;
71268
- ({
71269
- code,
71270
- pos
71271
- } = readHexChar$4(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
71272
- return res(code === null ? null : String.fromCharCode(code));
71273
- }
71274
- case 117:
71275
- {
71276
- let code;
71277
- ({
71278
- code,
71279
- pos
71280
- } = readCodePoint$4(input, pos, lineStart, curLine, throwOnInvalid, errors));
71281
- return res(code === null ? null : String.fromCodePoint(code));
71282
- }
71283
- case 116:
71284
- return res("\t");
71285
- case 98:
71286
- return res("\b");
71287
- case 118:
71288
- return res("\u000b");
71289
- case 102:
71290
- return res("\f");
71291
- case 13:
71292
- if (input.charCodeAt(pos) === 10) {
71293
- ++pos;
71294
- }
71295
- case 10:
71296
- lineStart = pos;
71297
- ++curLine;
71298
- case 8232:
71299
- case 8233:
71300
- return res("");
71301
- case 56:
71302
- case 57:
71303
- if (inTemplate) {
71304
- return res(null);
71305
- } else {
71306
- errors.strictNumericEscape(pos - 1, lineStart, curLine);
71307
- }
71308
- default:
71309
- if (ch >= 48 && ch <= 55) {
71310
- const startPos = pos - 1;
71311
- const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
71312
- let octalStr = match[0];
71313
- let octal = parseInt(octalStr, 8);
71314
- if (octal > 255) {
71315
- octalStr = octalStr.slice(0, -1);
71316
- octal = parseInt(octalStr, 8);
71317
- }
71318
- pos += octalStr.length - 1;
71319
- const next = input.charCodeAt(pos);
71320
- if (octalStr !== "0" || next === 56 || next === 57) {
71321
- if (inTemplate) {
71322
- return res(null);
71323
- } else {
71324
- errors.strictNumericEscape(startPos, lineStart, curLine);
71325
- }
71326
- }
71327
- return res(String.fromCharCode(octal));
71328
- }
71329
- return res(String.fromCharCode(ch));
71330
- }
71331
- }
71332
- function readHexChar$4(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
71333
- const initialPos = pos;
71334
- let n;
71335
- ({
71336
- n,
71337
- pos
71338
- } = readInt$4(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
71339
- if (n === null) {
71340
- if (throwOnInvalid) {
71341
- errors.invalidEscapeSequence(initialPos, lineStart, curLine);
71342
- } else {
71343
- pos = initialPos - 1;
71344
- }
71345
- }
71346
- return {
71347
- code: n,
71348
- pos
71349
- };
71350
- }
71351
- function readInt$4(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
71352
- const start = pos;
71353
- const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$4.hex : forbiddenNumericSeparatorSiblings$4.decBinOct;
71354
- const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$4.hex : radix === 10 ? isAllowedNumericSeparatorSibling$4.dec : radix === 8 ? isAllowedNumericSeparatorSibling$4.oct : isAllowedNumericSeparatorSibling$4.bin;
71355
- let invalid = false;
71356
- let total = 0;
71357
- for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
71358
- const code = input.charCodeAt(pos);
71359
- let val;
71360
- if (code === 95 && allowNumSeparator !== "bail") {
71361
- const prev = input.charCodeAt(pos - 1);
71362
- const next = input.charCodeAt(pos + 1);
71363
- if (!allowNumSeparator) {
71364
- if (bailOnError) return {
71365
- n: null,
71366
- pos
71367
- };
71368
- errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
71369
- } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
71370
- if (bailOnError) return {
71371
- n: null,
71372
- pos
71373
- };
71374
- errors.unexpectedNumericSeparator(pos, lineStart, curLine);
71375
- }
71376
- ++pos;
71377
- continue;
71378
- }
71379
- if (code >= 97) {
71380
- val = code - 97 + 10;
71381
- } else if (code >= 65) {
71382
- val = code - 65 + 10;
71383
- } else if (_isDigit$4(code)) {
71384
- val = code - 48;
71385
- } else {
71386
- val = Infinity;
71387
- }
71388
- if (val >= radix) {
71389
- if (val <= 9 && bailOnError) {
71390
- return {
71391
- n: null,
71392
- pos
71393
- };
71394
- } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
71395
- val = 0;
71396
- } else if (forceLen) {
71397
- val = 0;
71398
- invalid = true;
71399
- } else {
71400
- break;
71401
- }
71402
- }
71403
- ++pos;
71404
- total = total * radix + val;
71405
- }
71406
- if (pos === start || len != null && pos - start !== len || invalid) {
71407
- return {
71408
- n: null,
71409
- pos
71410
- };
71411
- }
71412
- return {
71413
- n: total,
71414
- pos
71415
- };
71416
- }
71417
- function readCodePoint$4(input, pos, lineStart, curLine, throwOnInvalid, errors) {
71418
- const ch = input.charCodeAt(pos);
71419
- let code;
71420
- if (ch === 123) {
71421
- ++pos;
71422
- ({
71423
- code,
71424
- pos
71425
- } = readHexChar$4(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
71426
- ++pos;
71427
- if (code !== null && code > 0x10ffff) {
71428
- if (throwOnInvalid) {
71429
- errors.invalidCodePoint(pos, lineStart, curLine);
71430
- } else {
71431
- return {
71432
- code: null,
71433
- pos
71434
- };
71435
- }
71436
- }
71437
- } else {
71438
- ({
71439
- code,
71440
- pos
71441
- } = readHexChar$4(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
71442
- }
71443
- return {
71444
- code,
71445
- pos
71446
- };
71447
- }
71448
-
71449
- var constants$4 = {};
71450
-
71451
- Object.defineProperty(constants$4, "__esModule", {
71452
- value: true
71453
- });
71454
- constants$4.UPDATE_OPERATORS = constants$4.UNARY_OPERATORS = constants$4.STRING_UNARY_OPERATORS = constants$4.STATEMENT_OR_BLOCK_KEYS = constants$4.NUMBER_UNARY_OPERATORS = constants$4.NUMBER_BINARY_OPERATORS = constants$4.NOT_LOCAL_BINDING = constants$4.LOGICAL_OPERATORS = constants$4.INHERIT_KEYS = constants$4.FOR_INIT_KEYS = constants$4.FLATTENABLE_KEYS = constants$4.EQUALITY_BINARY_OPERATORS = constants$4.COMPARISON_BINARY_OPERATORS = constants$4.COMMENT_KEYS = constants$4.BOOLEAN_UNARY_OPERATORS = constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$4.BOOLEAN_BINARY_OPERATORS = constants$4.BLOCK_SCOPED_SYMBOL = constants$4.BINARY_OPERATORS = constants$4.ASSIGNMENT_OPERATORS = void 0;
71455
- const STATEMENT_OR_BLOCK_KEYS$5 = ["consequent", "body", "alternate"];
71456
- constants$4.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$5;
71457
- const FLATTENABLE_KEYS$4 = ["body", "expressions"];
71458
- constants$4.FLATTENABLE_KEYS = FLATTENABLE_KEYS$4;
71459
- const FOR_INIT_KEYS$4 = ["left", "init"];
71460
- constants$4.FOR_INIT_KEYS = FOR_INIT_KEYS$4;
71461
- const COMMENT_KEYS$4 = ["leadingComments", "trailingComments", "innerComments"];
71462
- constants$4.COMMENT_KEYS = COMMENT_KEYS$4;
71463
- const LOGICAL_OPERATORS$5 = ["||", "&&", "??"];
71464
- constants$4.LOGICAL_OPERATORS = LOGICAL_OPERATORS$5;
71465
- const UPDATE_OPERATORS$4 = ["++", "--"];
71466
- constants$4.UPDATE_OPERATORS = UPDATE_OPERATORS$4;
71467
- const BOOLEAN_NUMBER_BINARY_OPERATORS$5 = [">", "<", ">=", "<="];
71468
- constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$5;
71469
- const EQUALITY_BINARY_OPERATORS$4 = ["==", "===", "!=", "!=="];
71470
- constants$4.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$4;
71471
- const COMPARISON_BINARY_OPERATORS$4 = [...EQUALITY_BINARY_OPERATORS$4, "in", "instanceof"];
71472
- constants$4.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$4;
71473
- const BOOLEAN_BINARY_OPERATORS$4 = [...COMPARISON_BINARY_OPERATORS$4, ...BOOLEAN_NUMBER_BINARY_OPERATORS$5];
71474
- constants$4.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$4;
71475
- const NUMBER_BINARY_OPERATORS$4 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
71476
- constants$4.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$4;
71477
- const BINARY_OPERATORS$4 = ["+", ...NUMBER_BINARY_OPERATORS$4, ...BOOLEAN_BINARY_OPERATORS$4, "|>"];
71478
- constants$4.BINARY_OPERATORS = BINARY_OPERATORS$4;
71479
- const ASSIGNMENT_OPERATORS$4 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$4.map(op => op + "="), ...LOGICAL_OPERATORS$5.map(op => op + "=")];
71480
- constants$4.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$4;
71481
- const BOOLEAN_UNARY_OPERATORS$4 = ["delete", "!"];
71482
- constants$4.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$4;
71483
- const NUMBER_UNARY_OPERATORS$4 = ["+", "-", "~"];
71484
- constants$4.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$4;
71485
- const STRING_UNARY_OPERATORS$4 = ["typeof"];
71486
- constants$4.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$4;
71487
- const UNARY_OPERATORS$4 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$4, ...NUMBER_UNARY_OPERATORS$4, ...STRING_UNARY_OPERATORS$4];
71488
- constants$4.UNARY_OPERATORS = UNARY_OPERATORS$4;
71489
- const INHERIT_KEYS$4 = {
71490
- optional: ["typeAnnotation", "typeParameters", "returnType"],
71491
- force: ["start", "loc", "end"]
71492
- };
71493
- constants$4.INHERIT_KEYS = INHERIT_KEYS$4;
71494
- const BLOCK_SCOPED_SYMBOL$4 = Symbol.for("var used to be block scoped");
71495
- constants$4.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$4;
71496
- const NOT_LOCAL_BINDING$5 = Symbol.for("should not be considered a local binding");
71497
- constants$4.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$5;
71498
-
71499
- var utils$5 = {};
71157
+ var hasRequiredLib$8;
71500
71158
 
71501
- var hasRequiredUtils$4;
71502
-
71503
- function requireUtils$4 () {
71504
- if (hasRequiredUtils$4) return utils$5;
71505
- hasRequiredUtils$4 = 1;
71159
+ function requireLib$8 () {
71160
+ if (hasRequiredLib$8) return lib$m;
71161
+ hasRequiredLib$8 = 1;
71506
71162
 
71507
- Object.defineProperty(utils$5, "__esModule", {
71163
+ Object.defineProperty(lib$m, "__esModule", {
71508
71164
  value: true
71509
71165
  });
71510
- utils$5.VISITOR_KEYS = utils$5.NODE_PARENT_VALIDATIONS = utils$5.NODE_FIELDS = utils$5.FLIPPED_ALIAS_KEYS = utils$5.DEPRECATED_KEYS = utils$5.BUILDER_KEYS = utils$5.ALIAS_KEYS = void 0;
71511
- utils$5.arrayOf = arrayOf;
71512
- utils$5.arrayOfType = arrayOfType;
71513
- utils$5.assertEach = assertEach;
71514
- utils$5.assertNodeOrValueType = assertNodeOrValueType;
71515
- utils$5.assertNodeType = assertNodeType;
71516
- utils$5.assertOneOf = assertOneOf;
71517
- utils$5.assertOptionalChainStart = assertOptionalChainStart;
71518
- utils$5.assertShape = assertShape;
71519
- utils$5.assertValueType = assertValueType;
71520
- utils$5.chain = chain;
71521
- utils$5.default = defineType;
71522
- utils$5.defineAliasedType = defineAliasedType;
71523
- utils$5.typeIs = typeIs;
71524
- utils$5.validate = validate;
71525
- utils$5.validateArrayOfType = validateArrayOfType;
71526
- utils$5.validateOptional = validateOptional;
71527
- utils$5.validateOptionalType = validateOptionalType;
71528
- utils$5.validateType = validateType;
71529
- var _is = requireIs$4();
71530
- var _validate = requireValidate$4();
71531
- const VISITOR_KEYS = {};
71532
- utils$5.VISITOR_KEYS = VISITOR_KEYS;
71533
- const ALIAS_KEYS = {};
71534
- utils$5.ALIAS_KEYS = ALIAS_KEYS;
71535
- const FLIPPED_ALIAS_KEYS = {};
71536
- utils$5.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
71537
- const NODE_FIELDS = {};
71538
- utils$5.NODE_FIELDS = NODE_FIELDS;
71539
- const BUILDER_KEYS = {};
71540
- utils$5.BUILDER_KEYS = BUILDER_KEYS;
71541
- const DEPRECATED_KEYS = {};
71542
- utils$5.DEPRECATED_KEYS = DEPRECATED_KEYS;
71543
- const NODE_PARENT_VALIDATIONS = {};
71544
- utils$5.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
71545
- function getType(val) {
71546
- if (Array.isArray(val)) {
71547
- return "array";
71548
- } else if (val === null) {
71549
- return "null";
71550
- } else {
71551
- return typeof val;
71552
- }
71553
- }
71554
- function validate(validate) {
71555
- return {
71556
- validate
71557
- };
71558
- }
71559
- function typeIs(typeName) {
71560
- return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
71561
- }
71562
- function validateType(typeName) {
71563
- return validate(typeIs(typeName));
71564
- }
71565
- function validateOptional(validate) {
71566
- return {
71567
- validate,
71568
- optional: true
71569
- };
71570
- }
71571
- function validateOptionalType(typeName) {
71572
- return {
71573
- validate: typeIs(typeName),
71574
- optional: true
71575
- };
71576
- }
71577
- function arrayOf(elementType) {
71578
- return chain(assertValueType("array"), assertEach(elementType));
71579
- }
71580
- function arrayOfType(typeName) {
71581
- return arrayOf(typeIs(typeName));
71582
- }
71583
- function validateArrayOfType(typeName) {
71584
- return validate(arrayOfType(typeName));
71585
- }
71586
- function assertEach(callback) {
71587
- function validator(node, key, val) {
71588
- if (!Array.isArray(val)) return;
71589
- for (let i = 0; i < val.length; i++) {
71590
- const subkey = `${key}[${i}]`;
71591
- const v = val[i];
71592
- callback(node, subkey, v);
71593
- (0, _validate.validateChild)(node, subkey, v);
71166
+ lib$m.readCodePoint = readCodePoint;
71167
+ lib$m.readInt = readInt;
71168
+ lib$m.readStringContents = readStringContents;
71169
+ var _isDigit = function isDigit(code) {
71170
+ return code >= 48 && code <= 57;
71171
+ };
71172
+ const forbiddenNumericSeparatorSiblings = {
71173
+ decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
71174
+ hex: new Set([46, 88, 95, 120])
71175
+ };
71176
+ const isAllowedNumericSeparatorSibling = {
71177
+ bin: ch => ch === 48 || ch === 49,
71178
+ oct: ch => ch >= 48 && ch <= 55,
71179
+ dec: ch => ch >= 48 && ch <= 57,
71180
+ hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
71181
+ };
71182
+ function readStringContents(type, input, pos, lineStart, curLine, errors) {
71183
+ const initialPos = pos;
71184
+ const initialLineStart = lineStart;
71185
+ const initialCurLine = curLine;
71186
+ let out = "";
71187
+ let firstInvalidLoc = null;
71188
+ let chunkStart = pos;
71189
+ const {
71190
+ length
71191
+ } = input;
71192
+ for (;;) {
71193
+ if (pos >= length) {
71194
+ errors.unterminated(initialPos, initialLineStart, initialCurLine);
71195
+ out += input.slice(chunkStart, pos);
71196
+ break;
71594
71197
  }
71595
- }
71596
- validator.each = callback;
71597
- return validator;
71598
- }
71599
- function assertOneOf(...values) {
71600
- function validate(node, key, val) {
71601
- if (values.indexOf(val) < 0) {
71602
- throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
71198
+ const ch = input.charCodeAt(pos);
71199
+ if (isStringEnd(type, ch, input, pos)) {
71200
+ out += input.slice(chunkStart, pos);
71201
+ break;
71603
71202
  }
71604
- }
71605
- validate.oneOf = values;
71606
- return validate;
71607
- }
71608
- function assertNodeType(...types) {
71609
- function validate(node, key, val) {
71610
- for (const type of types) {
71611
- if ((0, _is.default)(type, val)) {
71612
- (0, _validate.validateChild)(node, key, val);
71613
- return;
71203
+ if (ch === 92) {
71204
+ out += input.slice(chunkStart, pos);
71205
+ const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
71206
+ if (res.ch === null && !firstInvalidLoc) {
71207
+ firstInvalidLoc = {
71208
+ pos,
71209
+ lineStart,
71210
+ curLine
71211
+ };
71212
+ } else {
71213
+ out += res.ch;
71614
71214
  }
71615
- }
71616
- throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
71617
- }
71618
- validate.oneOfNodeTypes = types;
71619
- return validate;
71620
- }
71621
- function assertNodeOrValueType(...types) {
71622
- function validate(node, key, val) {
71623
- for (const type of types) {
71624
- if (getType(val) === type || (0, _is.default)(type, val)) {
71625
- (0, _validate.validateChild)(node, key, val);
71626
- return;
71215
+ ({
71216
+ pos,
71217
+ lineStart,
71218
+ curLine
71219
+ } = res);
71220
+ chunkStart = pos;
71221
+ } else if (ch === 8232 || ch === 8233) {
71222
+ ++pos;
71223
+ ++curLine;
71224
+ lineStart = pos;
71225
+ } else if (ch === 10 || ch === 13) {
71226
+ if (type === "template") {
71227
+ out += input.slice(chunkStart, pos) + "\n";
71228
+ ++pos;
71229
+ if (ch === 13 && input.charCodeAt(pos) === 10) {
71230
+ ++pos;
71231
+ }
71232
+ ++curLine;
71233
+ chunkStart = lineStart = pos;
71234
+ } else {
71235
+ errors.unterminated(initialPos, initialLineStart, initialCurLine);
71627
71236
  }
71237
+ } else {
71238
+ ++pos;
71628
71239
  }
71629
- throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
71630
71240
  }
71631
- validate.oneOfNodeOrValueTypes = types;
71632
- return validate;
71633
- }
71634
- function assertValueType(type) {
71635
- function validate(node, key, val) {
71241
+ return {
71242
+ pos,
71243
+ str: out,
71244
+ firstInvalidLoc,
71245
+ lineStart,
71246
+ curLine,
71247
+ containsInvalid: !!firstInvalidLoc
71248
+ };
71249
+ }
71250
+ function isStringEnd(type, ch, input, pos) {
71251
+ if (type === "template") {
71252
+ return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
71253
+ }
71254
+ return ch === (type === "double" ? 34 : 39);
71255
+ }
71256
+ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
71257
+ const throwOnInvalid = !inTemplate;
71258
+ pos++;
71259
+ const res = ch => ({
71260
+ pos,
71261
+ ch,
71262
+ lineStart,
71263
+ curLine
71264
+ });
71265
+ const ch = input.charCodeAt(pos++);
71266
+ switch (ch) {
71267
+ case 110:
71268
+ return res("\n");
71269
+ case 114:
71270
+ return res("\r");
71271
+ case 120:
71272
+ {
71273
+ let code;
71274
+ ({
71275
+ code,
71276
+ pos
71277
+ } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
71278
+ return res(code === null ? null : String.fromCharCode(code));
71279
+ }
71280
+ case 117:
71281
+ {
71282
+ let code;
71283
+ ({
71284
+ code,
71285
+ pos
71286
+ } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
71287
+ return res(code === null ? null : String.fromCodePoint(code));
71288
+ }
71289
+ case 116:
71290
+ return res("\t");
71291
+ case 98:
71292
+ return res("\b");
71293
+ case 118:
71294
+ return res("\u000b");
71295
+ case 102:
71296
+ return res("\f");
71297
+ case 13:
71298
+ if (input.charCodeAt(pos) === 10) {
71299
+ ++pos;
71300
+ }
71301
+ case 10:
71302
+ lineStart = pos;
71303
+ ++curLine;
71304
+ case 8232:
71305
+ case 8233:
71306
+ return res("");
71307
+ case 56:
71308
+ case 57:
71309
+ if (inTemplate) {
71310
+ return res(null);
71311
+ } else {
71312
+ errors.strictNumericEscape(pos - 1, lineStart, curLine);
71313
+ }
71314
+ default:
71315
+ if (ch >= 48 && ch <= 55) {
71316
+ const startPos = pos - 1;
71317
+ const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
71318
+ let octalStr = match[0];
71319
+ let octal = parseInt(octalStr, 8);
71320
+ if (octal > 255) {
71321
+ octalStr = octalStr.slice(0, -1);
71322
+ octal = parseInt(octalStr, 8);
71323
+ }
71324
+ pos += octalStr.length - 1;
71325
+ const next = input.charCodeAt(pos);
71326
+ if (octalStr !== "0" || next === 56 || next === 57) {
71327
+ if (inTemplate) {
71328
+ return res(null);
71329
+ } else {
71330
+ errors.strictNumericEscape(startPos, lineStart, curLine);
71331
+ }
71332
+ }
71333
+ return res(String.fromCharCode(octal));
71334
+ }
71335
+ return res(String.fromCharCode(ch));
71336
+ }
71337
+ }
71338
+ function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
71339
+ const initialPos = pos;
71340
+ let n;
71341
+ ({
71342
+ n,
71343
+ pos
71344
+ } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
71345
+ if (n === null) {
71346
+ if (throwOnInvalid) {
71347
+ errors.invalidEscapeSequence(initialPos, lineStart, curLine);
71348
+ } else {
71349
+ pos = initialPos - 1;
71350
+ }
71351
+ }
71352
+ return {
71353
+ code: n,
71354
+ pos
71355
+ };
71356
+ }
71357
+ function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
71358
+ const start = pos;
71359
+ const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
71360
+ const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
71361
+ let invalid = false;
71362
+ let total = 0;
71363
+ for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
71364
+ const code = input.charCodeAt(pos);
71365
+ let val;
71366
+ if (code === 95 && allowNumSeparator !== "bail") {
71367
+ const prev = input.charCodeAt(pos - 1);
71368
+ const next = input.charCodeAt(pos + 1);
71369
+ if (!allowNumSeparator) {
71370
+ if (bailOnError) return {
71371
+ n: null,
71372
+ pos
71373
+ };
71374
+ errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
71375
+ } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
71376
+ if (bailOnError) return {
71377
+ n: null,
71378
+ pos
71379
+ };
71380
+ errors.unexpectedNumericSeparator(pos, lineStart, curLine);
71381
+ }
71382
+ ++pos;
71383
+ continue;
71384
+ }
71385
+ if (code >= 97) {
71386
+ val = code - 97 + 10;
71387
+ } else if (code >= 65) {
71388
+ val = code - 65 + 10;
71389
+ } else if (_isDigit(code)) {
71390
+ val = code - 48;
71391
+ } else {
71392
+ val = Infinity;
71393
+ }
71394
+ if (val >= radix) {
71395
+ if (val <= 9 && bailOnError) {
71396
+ return {
71397
+ n: null,
71398
+ pos
71399
+ };
71400
+ } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
71401
+ val = 0;
71402
+ } else if (forceLen) {
71403
+ val = 0;
71404
+ invalid = true;
71405
+ } else {
71406
+ break;
71407
+ }
71408
+ }
71409
+ ++pos;
71410
+ total = total * radix + val;
71411
+ }
71412
+ if (pos === start || len != null && pos - start !== len || invalid) {
71413
+ return {
71414
+ n: null,
71415
+ pos
71416
+ };
71417
+ }
71418
+ return {
71419
+ n: total,
71420
+ pos
71421
+ };
71422
+ }
71423
+ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
71424
+ const ch = input.charCodeAt(pos);
71425
+ let code;
71426
+ if (ch === 123) {
71427
+ ++pos;
71428
+ ({
71429
+ code,
71430
+ pos
71431
+ } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
71432
+ ++pos;
71433
+ if (code !== null && code > 0x10ffff) {
71434
+ if (throwOnInvalid) {
71435
+ errors.invalidCodePoint(pos, lineStart, curLine);
71436
+ } else {
71437
+ return {
71438
+ code: null,
71439
+ pos
71440
+ };
71441
+ }
71442
+ }
71443
+ } else {
71444
+ ({
71445
+ code,
71446
+ pos
71447
+ } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
71448
+ }
71449
+ return {
71450
+ code,
71451
+ pos
71452
+ };
71453
+ }
71454
+
71455
+
71456
+ return lib$m;
71457
+ }
71458
+
71459
+ var constants$4 = {};
71460
+
71461
+ Object.defineProperty(constants$4, "__esModule", {
71462
+ value: true
71463
+ });
71464
+ constants$4.UPDATE_OPERATORS = constants$4.UNARY_OPERATORS = constants$4.STRING_UNARY_OPERATORS = constants$4.STATEMENT_OR_BLOCK_KEYS = constants$4.NUMBER_UNARY_OPERATORS = constants$4.NUMBER_BINARY_OPERATORS = constants$4.NOT_LOCAL_BINDING = constants$4.LOGICAL_OPERATORS = constants$4.INHERIT_KEYS = constants$4.FOR_INIT_KEYS = constants$4.FLATTENABLE_KEYS = constants$4.EQUALITY_BINARY_OPERATORS = constants$4.COMPARISON_BINARY_OPERATORS = constants$4.COMMENT_KEYS = constants$4.BOOLEAN_UNARY_OPERATORS = constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$4.BOOLEAN_BINARY_OPERATORS = constants$4.BLOCK_SCOPED_SYMBOL = constants$4.BINARY_OPERATORS = constants$4.ASSIGNMENT_OPERATORS = void 0;
71465
+ const STATEMENT_OR_BLOCK_KEYS$5 = ["consequent", "body", "alternate"];
71466
+ constants$4.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$5;
71467
+ const FLATTENABLE_KEYS$4 = ["body", "expressions"];
71468
+ constants$4.FLATTENABLE_KEYS = FLATTENABLE_KEYS$4;
71469
+ const FOR_INIT_KEYS$4 = ["left", "init"];
71470
+ constants$4.FOR_INIT_KEYS = FOR_INIT_KEYS$4;
71471
+ const COMMENT_KEYS$4 = ["leadingComments", "trailingComments", "innerComments"];
71472
+ constants$4.COMMENT_KEYS = COMMENT_KEYS$4;
71473
+ const LOGICAL_OPERATORS$5 = ["||", "&&", "??"];
71474
+ constants$4.LOGICAL_OPERATORS = LOGICAL_OPERATORS$5;
71475
+ const UPDATE_OPERATORS$4 = ["++", "--"];
71476
+ constants$4.UPDATE_OPERATORS = UPDATE_OPERATORS$4;
71477
+ const BOOLEAN_NUMBER_BINARY_OPERATORS$5 = [">", "<", ">=", "<="];
71478
+ constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$5;
71479
+ const EQUALITY_BINARY_OPERATORS$4 = ["==", "===", "!=", "!=="];
71480
+ constants$4.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$4;
71481
+ const COMPARISON_BINARY_OPERATORS$4 = [...EQUALITY_BINARY_OPERATORS$4, "in", "instanceof"];
71482
+ constants$4.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$4;
71483
+ const BOOLEAN_BINARY_OPERATORS$4 = [...COMPARISON_BINARY_OPERATORS$4, ...BOOLEAN_NUMBER_BINARY_OPERATORS$5];
71484
+ constants$4.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$4;
71485
+ const NUMBER_BINARY_OPERATORS$4 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
71486
+ constants$4.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$4;
71487
+ const BINARY_OPERATORS$4 = ["+", ...NUMBER_BINARY_OPERATORS$4, ...BOOLEAN_BINARY_OPERATORS$4, "|>"];
71488
+ constants$4.BINARY_OPERATORS = BINARY_OPERATORS$4;
71489
+ const ASSIGNMENT_OPERATORS$4 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$4.map(op => op + "="), ...LOGICAL_OPERATORS$5.map(op => op + "=")];
71490
+ constants$4.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$4;
71491
+ const BOOLEAN_UNARY_OPERATORS$4 = ["delete", "!"];
71492
+ constants$4.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$4;
71493
+ const NUMBER_UNARY_OPERATORS$4 = ["+", "-", "~"];
71494
+ constants$4.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$4;
71495
+ const STRING_UNARY_OPERATORS$4 = ["typeof"];
71496
+ constants$4.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$4;
71497
+ const UNARY_OPERATORS$4 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$4, ...NUMBER_UNARY_OPERATORS$4, ...STRING_UNARY_OPERATORS$4];
71498
+ constants$4.UNARY_OPERATORS = UNARY_OPERATORS$4;
71499
+ const INHERIT_KEYS$4 = {
71500
+ optional: ["typeAnnotation", "typeParameters", "returnType"],
71501
+ force: ["start", "loc", "end"]
71502
+ };
71503
+ constants$4.INHERIT_KEYS = INHERIT_KEYS$4;
71504
+ const BLOCK_SCOPED_SYMBOL$4 = Symbol.for("var used to be block scoped");
71505
+ constants$4.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$4;
71506
+ const NOT_LOCAL_BINDING$5 = Symbol.for("should not be considered a local binding");
71507
+ constants$4.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$5;
71508
+
71509
+ var utils$5 = {};
71510
+
71511
+ var hasRequiredUtils$4;
71512
+
71513
+ function requireUtils$4 () {
71514
+ if (hasRequiredUtils$4) return utils$5;
71515
+ hasRequiredUtils$4 = 1;
71516
+
71517
+ Object.defineProperty(utils$5, "__esModule", {
71518
+ value: true
71519
+ });
71520
+ utils$5.VISITOR_KEYS = utils$5.NODE_PARENT_VALIDATIONS = utils$5.NODE_FIELDS = utils$5.FLIPPED_ALIAS_KEYS = utils$5.DEPRECATED_KEYS = utils$5.BUILDER_KEYS = utils$5.ALIAS_KEYS = void 0;
71521
+ utils$5.arrayOf = arrayOf;
71522
+ utils$5.arrayOfType = arrayOfType;
71523
+ utils$5.assertEach = assertEach;
71524
+ utils$5.assertNodeOrValueType = assertNodeOrValueType;
71525
+ utils$5.assertNodeType = assertNodeType;
71526
+ utils$5.assertOneOf = assertOneOf;
71527
+ utils$5.assertOptionalChainStart = assertOptionalChainStart;
71528
+ utils$5.assertShape = assertShape;
71529
+ utils$5.assertValueType = assertValueType;
71530
+ utils$5.chain = chain;
71531
+ utils$5.default = defineType;
71532
+ utils$5.defineAliasedType = defineAliasedType;
71533
+ utils$5.typeIs = typeIs;
71534
+ utils$5.validate = validate;
71535
+ utils$5.validateArrayOfType = validateArrayOfType;
71536
+ utils$5.validateOptional = validateOptional;
71537
+ utils$5.validateOptionalType = validateOptionalType;
71538
+ utils$5.validateType = validateType;
71539
+ var _is = requireIs$4();
71540
+ var _validate = requireValidate$4();
71541
+ const VISITOR_KEYS = {};
71542
+ utils$5.VISITOR_KEYS = VISITOR_KEYS;
71543
+ const ALIAS_KEYS = {};
71544
+ utils$5.ALIAS_KEYS = ALIAS_KEYS;
71545
+ const FLIPPED_ALIAS_KEYS = {};
71546
+ utils$5.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
71547
+ const NODE_FIELDS = {};
71548
+ utils$5.NODE_FIELDS = NODE_FIELDS;
71549
+ const BUILDER_KEYS = {};
71550
+ utils$5.BUILDER_KEYS = BUILDER_KEYS;
71551
+ const DEPRECATED_KEYS = {};
71552
+ utils$5.DEPRECATED_KEYS = DEPRECATED_KEYS;
71553
+ const NODE_PARENT_VALIDATIONS = {};
71554
+ utils$5.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
71555
+ function getType(val) {
71556
+ if (Array.isArray(val)) {
71557
+ return "array";
71558
+ } else if (val === null) {
71559
+ return "null";
71560
+ } else {
71561
+ return typeof val;
71562
+ }
71563
+ }
71564
+ function validate(validate) {
71565
+ return {
71566
+ validate
71567
+ };
71568
+ }
71569
+ function typeIs(typeName) {
71570
+ return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
71571
+ }
71572
+ function validateType(typeName) {
71573
+ return validate(typeIs(typeName));
71574
+ }
71575
+ function validateOptional(validate) {
71576
+ return {
71577
+ validate,
71578
+ optional: true
71579
+ };
71580
+ }
71581
+ function validateOptionalType(typeName) {
71582
+ return {
71583
+ validate: typeIs(typeName),
71584
+ optional: true
71585
+ };
71586
+ }
71587
+ function arrayOf(elementType) {
71588
+ return chain(assertValueType("array"), assertEach(elementType));
71589
+ }
71590
+ function arrayOfType(typeName) {
71591
+ return arrayOf(typeIs(typeName));
71592
+ }
71593
+ function validateArrayOfType(typeName) {
71594
+ return validate(arrayOfType(typeName));
71595
+ }
71596
+ function assertEach(callback) {
71597
+ function validator(node, key, val) {
71598
+ if (!Array.isArray(val)) return;
71599
+ for (let i = 0; i < val.length; i++) {
71600
+ const subkey = `${key}[${i}]`;
71601
+ const v = val[i];
71602
+ callback(node, subkey, v);
71603
+ (0, _validate.validateChild)(node, subkey, v);
71604
+ }
71605
+ }
71606
+ validator.each = callback;
71607
+ return validator;
71608
+ }
71609
+ function assertOneOf(...values) {
71610
+ function validate(node, key, val) {
71611
+ if (values.indexOf(val) < 0) {
71612
+ throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
71613
+ }
71614
+ }
71615
+ validate.oneOf = values;
71616
+ return validate;
71617
+ }
71618
+ function assertNodeType(...types) {
71619
+ function validate(node, key, val) {
71620
+ for (const type of types) {
71621
+ if ((0, _is.default)(type, val)) {
71622
+ (0, _validate.validateChild)(node, key, val);
71623
+ return;
71624
+ }
71625
+ }
71626
+ throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
71627
+ }
71628
+ validate.oneOfNodeTypes = types;
71629
+ return validate;
71630
+ }
71631
+ function assertNodeOrValueType(...types) {
71632
+ function validate(node, key, val) {
71633
+ for (const type of types) {
71634
+ if (getType(val) === type || (0, _is.default)(type, val)) {
71635
+ (0, _validate.validateChild)(node, key, val);
71636
+ return;
71637
+ }
71638
+ }
71639
+ throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
71640
+ }
71641
+ validate.oneOfNodeOrValueTypes = types;
71642
+ return validate;
71643
+ }
71644
+ function assertValueType(type) {
71645
+ function validate(node, key, val) {
71636
71646
  const valid = getType(val) === type;
71637
71647
  if (!valid) {
71638
71648
  throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
@@ -71798,7 +71808,7 @@ function requireCore$4 () {
71798
71808
  var _is = requireIs$4();
71799
71809
  var _isValidIdentifier = isValidIdentifier$9;
71800
71810
  var _helperValidatorIdentifier = lib$n;
71801
- var _helperStringParser = lib$m;
71811
+ var _helperStringParser = requireLib$8();
71802
71812
  var _constants = constants$4;
71803
71813
  var _utils = requireUtils$4();
71804
71814
  const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -74957,7 +74967,7 @@ function requireValidateNode$4 () {
74957
74967
  });
74958
74968
  validateNode$4.default = validateNode;
74959
74969
  var _validate = requireValidate$4();
74960
- var _ = requireLib$6();
74970
+ var _ = requireLib$7();
74961
74971
  function validateNode(node) {
74962
74972
  const keys = _.BUILDER_KEYS[node.type];
74963
74973
  for (const key of keys) {
@@ -76973,7 +76983,7 @@ function requireCleanJSXElementLiteralChild$4 () {
76973
76983
  });
76974
76984
  cleanJSXElementLiteralChild$4.default = cleanJSXElementLiteralChild;
76975
76985
  var _generated = requireGenerated$4();
76976
- var _ = requireLib$6();
76986
+ var _ = requireLib$7();
76977
76987
  function cleanJSXElementLiteralChild(child, args) {
76978
76988
  const lines = child.value.split(/\r\n|\n|\r/);
76979
76989
  let lastNonEmptyLine = 0;
@@ -81059,7 +81069,7 @@ function requirePrependToMemberExpression$4 () {
81059
81069
  });
81060
81070
  prependToMemberExpression$4.default = prependToMemberExpression;
81061
81071
  var _generated = requireGenerated$4();
81062
- var _ = requireLib$6();
81072
+ var _ = requireLib$7();
81063
81073
  function prependToMemberExpression(member, prepend) {
81064
81074
  if ((0, _.isSuper)(member.object)) {
81065
81075
  throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -81411,11 +81421,11 @@ function isVar$9(node) {
81411
81421
  }) && !node[_constants$k.BLOCK_SCOPED_SYMBOL];
81412
81422
  }
81413
81423
 
81414
- var hasRequiredLib$6;
81424
+ var hasRequiredLib$7;
81415
81425
 
81416
- function requireLib$6 () {
81417
- if (hasRequiredLib$6) return lib$o;
81418
- hasRequiredLib$6 = 1;
81426
+ function requireLib$7 () {
81427
+ if (hasRequiredLib$7) return lib$o;
81428
+ hasRequiredLib$7 = 1;
81419
81429
  (function (exports) {
81420
81430
 
81421
81431
  Object.defineProperty(exports, "__esModule", {
@@ -81998,7 +82008,7 @@ visitors.isExplodedVisitor = isExplodedVisitor;
81998
82008
  visitors.merge = merge$4;
81999
82009
  visitors.verify = verify;
82000
82010
  var virtualTypes = virtualTypes$1;
82001
- var _t$p = requireLib$6();
82011
+ var _t$p = requireLib$7();
82002
82012
  const {
82003
82013
  DEPRECATED_KEYS,
82004
82014
  DEPRECATED_ALIASES: DEPRECATED_ALIASES$4,
@@ -82265,7 +82275,7 @@ Object.defineProperty(lib$l, "__esModule", {
82265
82275
  value: true
82266
82276
  });
82267
82277
  lib$l.default = splitExportDeclaration;
82268
- var _t$o = requireLib$6();
82278
+ var _t$o = requireLib$7();
82269
82279
  const {
82270
82280
  cloneNode: cloneNode$b,
82271
82281
  exportNamedDeclaration,
@@ -82383,7 +82393,7 @@ function requireRenamer () {
82383
82393
  });
82384
82394
  renamer.default = void 0;
82385
82395
  var _helperSplitExportDeclaration = lib$l;
82386
- var t = requireLib$6();
82396
+ var t = requireLib$7();
82387
82397
  var _helperEnvironmentVisitor = lib$k;
82388
82398
  var _traverseNode = requireTraverseNode();
82389
82399
  var _visitors = visitors;
@@ -84183,10 +84193,10 @@ function requireScope () {
84183
84193
  });
84184
84194
  scope.default = void 0;
84185
84195
  var _renamer = requireRenamer();
84186
- var _index = requireLib$2();
84196
+ var _index = requireLib$3();
84187
84197
  var _binding = binding;
84188
84198
  var _globals = globals;
84189
- var _t = requireLib$6();
84199
+ var _t = requireLib$7();
84190
84200
  var t = _t;
84191
84201
  var _cache = cache;
84192
84202
  var _visitors = visitors;
@@ -86791,7 +86801,7 @@ Object.defineProperty(whitespace$1, "__esModule", {
86791
86801
  value: true
86792
86802
  });
86793
86803
  whitespace$1.nodes = void 0;
86794
- var _t$n = requireLib$6();
86804
+ var _t$n = requireLib$7();
86795
86805
  const {
86796
86806
  FLIPPED_ALIAS_KEYS: FLIPPED_ALIAS_KEYS$1,
86797
86807
  isArrayExpression: isArrayExpression$6,
@@ -86959,7 +86969,7 @@ parentheses.UnaryLike = UnaryLike;
86959
86969
  parentheses.IntersectionTypeAnnotation = parentheses.UnionTypeAnnotation = UnionTypeAnnotation;
86960
86970
  parentheses.UpdateExpression = UpdateExpression$1;
86961
86971
  parentheses.AwaitExpression = parentheses.YieldExpression = YieldExpression$1;
86962
- var _t$m = requireLib$6();
86972
+ var _t$m = requireLib$7();
86963
86973
  const {
86964
86974
  isArrayTypeAnnotation: isArrayTypeAnnotation$5,
86965
86975
  isArrowFunctionExpression: isArrowFunctionExpression$6,
@@ -87243,7 +87253,7 @@ node.needsWhitespaceAfter = needsWhitespaceAfter;
87243
87253
  node.needsWhitespaceBefore = needsWhitespaceBefore;
87244
87254
  var whitespace = whitespace$1;
87245
87255
  var parens$2 = parentheses;
87246
- var _t$l = requireLib$6();
87256
+ var _t$l = requireLib$7();
87247
87257
  const {
87248
87258
  FLIPPED_ALIAS_KEYS,
87249
87259
  isCallExpression: isCallExpression$8,
@@ -87372,7 +87382,7 @@ expressions$2.UpdateExpression = UpdateExpression;
87372
87382
  expressions$2.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
87373
87383
  expressions$2.YieldExpression = YieldExpression;
87374
87384
  expressions$2._shouldPrintDecoratorsBeforeExport = _shouldPrintDecoratorsBeforeExport;
87375
- var _t$k = requireLib$6();
87385
+ var _t$k = requireLib$7();
87376
87386
  var n$1 = node;
87377
87387
  const {
87378
87388
  isCallExpression: isCallExpression$7,
@@ -87671,7 +87681,7 @@ statements$4.VariableDeclaration = VariableDeclaration$1;
87671
87681
  statements$4.VariableDeclarator = VariableDeclarator;
87672
87682
  statements$4.WhileStatement = WhileStatement$1;
87673
87683
  statements$4.WithStatement = WithStatement;
87674
- var _t$j = requireLib$6();
87684
+ var _t$j = requireLib$7();
87675
87685
  const {
87676
87686
  isFor: isFor$4,
87677
87687
  isForStatement: isForStatement$5,
@@ -87938,7 +87948,7 @@ classes.ClassPrivateProperty = ClassPrivateProperty$1;
87938
87948
  classes.ClassProperty = ClassProperty$2;
87939
87949
  classes.StaticBlock = StaticBlock$1;
87940
87950
  classes._classMethodHead = _classMethodHead;
87941
- var _t$i = requireLib$6();
87951
+ var _t$i = requireLib$7();
87942
87952
  const {
87943
87953
  isExportDefaultDeclaration: isExportDefaultDeclaration$4,
87944
87954
  isExportNamedDeclaration: isExportNamedDeclaration$4
@@ -88113,7 +88123,7 @@ methods._param = _param;
88113
88123
  methods._parameters = _parameters;
88114
88124
  methods._params = _params;
88115
88125
  methods._predicate = _predicate;
88116
- var _t$h = requireLib$6();
88126
+ var _t$h = requireLib$7();
88117
88127
  const {
88118
88128
  isIdentifier: isIdentifier$k
88119
88129
  } = _t$h;
@@ -88289,7 +88299,7 @@ modules.ImportDefaultSpecifier = ImportDefaultSpecifier;
88289
88299
  modules.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
88290
88300
  modules.ImportSpecifier = ImportSpecifier;
88291
88301
  modules._printAttributes = _printAttributes;
88292
- var _t$g = requireLib$6();
88302
+ var _t$g = requireLib$7();
88293
88303
  const {
88294
88304
  isClassDeclaration: isClassDeclaration$4,
88295
88305
  isExportDefaultSpecifier: isExportDefaultSpecifier$4,
@@ -88878,7 +88888,7 @@ types$l.SpreadElement = types$l.RestElement = RestElement$1;
88878
88888
  types$l.StringLiteral = StringLiteral$1;
88879
88889
  types$l.TopicReference = TopicReference;
88880
88890
  types$l.TupleExpression = TupleExpression$1;
88881
- var _t$f = requireLib$6();
88891
+ var _t$f = requireLib$7();
88882
88892
  var _jsesc = jsesc_1;
88883
88893
  const {
88884
88894
  isAssignmentPattern: isAssignmentPattern$6,
@@ -89153,7 +89163,7 @@ var flow$5 = {};
89153
89163
  exports.VoidTypeAnnotation = VoidTypeAnnotation;
89154
89164
  exports._interfaceish = _interfaceish;
89155
89165
  exports._variance = _variance;
89156
- var _t = requireLib$6();
89166
+ var _t = requireLib$7();
89157
89167
  var _modules = modules;
89158
89168
  var _types2 = types$l;
89159
89169
  const {
@@ -90790,7 +90800,7 @@ Object.defineProperty(printer, "__esModule", {
90790
90800
  printer.default = void 0;
90791
90801
  var _buffer = buffer;
90792
90802
  var n = node;
90793
- var _t$e = requireLib$6();
90803
+ var _t$e = requireLib$7();
90794
90804
  var generatorFunctions = generators;
90795
90805
  const {
90796
90806
  isFunction: isFunction$8,
@@ -91538,7 +91548,7 @@ ancestry.getStatementParent = getStatementParent;
91538
91548
  ancestry.inType = inType;
91539
91549
  ancestry.isAncestor = isAncestor;
91540
91550
  ancestry.isDescendant = isDescendant;
91541
- var _t$d = requireLib$6();
91551
+ var _t$d = requireLib$7();
91542
91552
  const {
91543
91553
  VISITOR_KEYS: VISITOR_KEYS$1
91544
91554
  } = _t$d;
@@ -91675,7 +91685,7 @@ Object.defineProperty(util, "__esModule", {
91675
91685
  value: true
91676
91686
  });
91677
91687
  util.createUnionType = createUnionType;
91678
- var _t$c = requireLib$6();
91688
+ var _t$c = requireLib$7();
91679
91689
  const {
91680
91690
  createFlowUnionType: createFlowUnionType$4,
91681
91691
  createTSUnionType: createTSUnionType$4,
@@ -91702,7 +91712,7 @@ Object.defineProperty(infererReference, "__esModule", {
91702
91712
  value: true
91703
91713
  });
91704
91714
  infererReference.default = _default$f;
91705
- var _t$b = requireLib$6();
91715
+ var _t$b = requireLib$7();
91706
91716
  var _util = util;
91707
91717
  const {
91708
91718
  BOOLEAN_NUMBER_BINARY_OPERATORS: BOOLEAN_NUMBER_BINARY_OPERATORS$4,
@@ -91882,7 +91892,7 @@ function getConditionalAnnotation(binding, path, name) {
91882
91892
  exports.UnaryExpression = UnaryExpression;
91883
91893
  exports.UpdateExpression = UpdateExpression;
91884
91894
  exports.VariableDeclarator = VariableDeclarator;
91885
- var _t = requireLib$6();
91895
+ var _t = requireLib$7();
91886
91896
  var _infererReference = infererReference;
91887
91897
  var _util = util;
91888
91898
  const {
@@ -92067,7 +92077,7 @@ inference.getTypeAnnotation = getTypeAnnotation;
92067
92077
  inference.isBaseType = isBaseType;
92068
92078
  inference.isGenericType = isGenericType;
92069
92079
  var inferers = inferers$1;
92070
- var _t$a = requireLib$6();
92080
+ var _t$a = requireLib$7();
92071
92081
  const {
92072
92082
  anyTypeAnnotation,
92073
92083
  isAnyTypeAnnotation: isAnyTypeAnnotation$4,
@@ -94544,20 +94554,20 @@ let State$2 = class State {
94544
94554
  return state;
94545
94555
  }
94546
94556
  };
94547
- var _isDigit$3 = function isDigit(code) {
94557
+ var _isDigit$2 = function isDigit(code) {
94548
94558
  return code >= 48 && code <= 57;
94549
94559
  };
94550
- const forbiddenNumericSeparatorSiblings$3 = {
94560
+ const forbiddenNumericSeparatorSiblings$2 = {
94551
94561
  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
94552
94562
  hex: new Set([46, 88, 95, 120])
94553
94563
  };
94554
- const isAllowedNumericSeparatorSibling$3 = {
94564
+ const isAllowedNumericSeparatorSibling$2 = {
94555
94565
  bin: ch => ch === 48 || ch === 49,
94556
94566
  oct: ch => ch >= 48 && ch <= 55,
94557
94567
  dec: ch => ch >= 48 && ch <= 57,
94558
94568
  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
94559
94569
  };
94560
- function readStringContents$3(type, input, pos, lineStart, curLine, errors) {
94570
+ function readStringContents$2(type, input, pos, lineStart, curLine, errors) {
94561
94571
  const initialPos = pos;
94562
94572
  const initialLineStart = lineStart;
94563
94573
  const initialCurLine = curLine;
@@ -94574,13 +94584,13 @@ function readStringContents$3(type, input, pos, lineStart, curLine, errors) {
94574
94584
  break;
94575
94585
  }
94576
94586
  const ch = input.charCodeAt(pos);
94577
- if (isStringEnd$3(type, ch, input, pos)) {
94587
+ if (isStringEnd$2(type, ch, input, pos)) {
94578
94588
  out += input.slice(chunkStart, pos);
94579
94589
  break;
94580
94590
  }
94581
94591
  if (ch === 92) {
94582
94592
  out += input.slice(chunkStart, pos);
94583
- const res = readEscapedChar$3(input, pos, lineStart, curLine, type === "template", errors);
94593
+ const res = readEscapedChar$2(input, pos, lineStart, curLine, type === "template", errors);
94584
94594
  if (res.ch === null && !firstInvalidLoc) {
94585
94595
  firstInvalidLoc = {
94586
94596
  pos,
@@ -94625,13 +94635,13 @@ function readStringContents$3(type, input, pos, lineStart, curLine, errors) {
94625
94635
  containsInvalid: !!firstInvalidLoc
94626
94636
  };
94627
94637
  }
94628
- function isStringEnd$3(type, ch, input, pos) {
94638
+ function isStringEnd$2(type, ch, input, pos) {
94629
94639
  if (type === "template") {
94630
94640
  return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
94631
94641
  }
94632
94642
  return ch === (type === "double" ? 34 : 39);
94633
94643
  }
94634
- function readEscapedChar$3(input, pos, lineStart, curLine, inTemplate, errors) {
94644
+ function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
94635
94645
  const throwOnInvalid = !inTemplate;
94636
94646
  pos++;
94637
94647
  const res = ch => ({
@@ -94652,7 +94662,7 @@ function readEscapedChar$3(input, pos, lineStart, curLine, inTemplate, errors) {
94652
94662
  ({
94653
94663
  code,
94654
94664
  pos
94655
- } = readHexChar$3(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
94665
+ } = readHexChar$2(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
94656
94666
  return res(code === null ? null : String.fromCharCode(code));
94657
94667
  }
94658
94668
  case 117:
@@ -94661,7 +94671,7 @@ function readEscapedChar$3(input, pos, lineStart, curLine, inTemplate, errors) {
94661
94671
  ({
94662
94672
  code,
94663
94673
  pos
94664
- } = readCodePoint$3(input, pos, lineStart, curLine, throwOnInvalid, errors));
94674
+ } = readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors));
94665
94675
  return res(code === null ? null : String.fromCodePoint(code));
94666
94676
  }
94667
94677
  case 116:
@@ -94713,13 +94723,13 @@ function readEscapedChar$3(input, pos, lineStart, curLine, inTemplate, errors) {
94713
94723
  return res(String.fromCharCode(ch));
94714
94724
  }
94715
94725
  }
94716
- function readHexChar$3(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
94726
+ function readHexChar$2(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
94717
94727
  const initialPos = pos;
94718
94728
  let n;
94719
94729
  ({
94720
94730
  n,
94721
94731
  pos
94722
- } = readInt$3(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
94732
+ } = readInt$2(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
94723
94733
  if (n === null) {
94724
94734
  if (throwOnInvalid) {
94725
94735
  errors.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -94732,10 +94742,10 @@ function readHexChar$3(input, pos, lineStart, curLine, len, forceLen, throwOnInv
94732
94742
  pos
94733
94743
  };
94734
94744
  }
94735
- function readInt$3(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
94745
+ function readInt$2(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
94736
94746
  const start = pos;
94737
- const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$3.hex : forbiddenNumericSeparatorSiblings$3.decBinOct;
94738
- const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$3.hex : radix === 10 ? isAllowedNumericSeparatorSibling$3.dec : radix === 8 ? isAllowedNumericSeparatorSibling$3.oct : isAllowedNumericSeparatorSibling$3.bin;
94747
+ const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$2.hex : forbiddenNumericSeparatorSiblings$2.decBinOct;
94748
+ const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$2.hex : radix === 10 ? isAllowedNumericSeparatorSibling$2.dec : radix === 8 ? isAllowedNumericSeparatorSibling$2.oct : isAllowedNumericSeparatorSibling$2.bin;
94739
94749
  let invalid = false;
94740
94750
  let total = 0;
94741
94751
  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
@@ -94764,7 +94774,7 @@ function readInt$3(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
94764
94774
  val = code - 97 + 10;
94765
94775
  } else if (code >= 65) {
94766
94776
  val = code - 65 + 10;
94767
- } else if (_isDigit$3(code)) {
94777
+ } else if (_isDigit$2(code)) {
94768
94778
  val = code - 48;
94769
94779
  } else {
94770
94780
  val = Infinity;
@@ -94798,7 +94808,7 @@ function readInt$3(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
94798
94808
  pos
94799
94809
  };
94800
94810
  }
94801
- function readCodePoint$3(input, pos, lineStart, curLine, throwOnInvalid, errors) {
94811
+ function readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors) {
94802
94812
  const ch = input.charCodeAt(pos);
94803
94813
  let code;
94804
94814
  if (ch === 123) {
@@ -94806,7 +94816,7 @@ function readCodePoint$3(input, pos, lineStart, curLine, throwOnInvalid, errors)
94806
94816
  ({
94807
94817
  code,
94808
94818
  pos
94809
- } = readHexChar$3(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
94819
+ } = readHexChar$2(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
94810
94820
  ++pos;
94811
94821
  if (code !== null && code > 0x10ffff) {
94812
94822
  if (throwOnInvalid) {
@@ -94822,7 +94832,7 @@ function readCodePoint$3(input, pos, lineStart, curLine, throwOnInvalid, errors)
94822
94832
  ({
94823
94833
  code,
94824
94834
  pos
94825
- } = readHexChar$3(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
94835
+ } = readHexChar$2(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
94826
94836
  }
94827
94837
  return {
94828
94838
  code,
@@ -95619,7 +95629,7 @@ class Tokenizer extends CommentsParser {
95619
95629
  const {
95620
95630
  n,
95621
95631
  pos
95622
- } = readInt$3(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
95632
+ } = readInt$2(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
95623
95633
  this.state.pos = pos;
95624
95634
  return n;
95625
95635
  }
@@ -95745,7 +95755,7 @@ class Tokenizer extends CommentsParser {
95745
95755
  const {
95746
95756
  code,
95747
95757
  pos
95748
- } = readCodePoint$3(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
95758
+ } = readCodePoint$2(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
95749
95759
  this.state.pos = pos;
95750
95760
  return code;
95751
95761
  }
@@ -95755,7 +95765,7 @@ class Tokenizer extends CommentsParser {
95755
95765
  pos,
95756
95766
  curLine,
95757
95767
  lineStart
95758
- } = readStringContents$3(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
95768
+ } = readStringContents$2(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
95759
95769
  this.state.pos = pos + 1;
95760
95770
  this.state.lineStart = lineStart;
95761
95771
  this.state.curLine = curLine;
@@ -95776,7 +95786,7 @@ class Tokenizer extends CommentsParser {
95776
95786
  pos,
95777
95787
  curLine,
95778
95788
  lineStart
95779
- } = readStringContents$3("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
95789
+ } = readStringContents$2("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
95780
95790
  this.state.pos = pos + 1;
95781
95791
  this.state.lineStart = lineStart;
95782
95792
  this.state.curLine = curLine;
@@ -110241,11 +110251,11 @@ function isValidIdentifier$6(name, reserved = true) {
110241
110251
 
110242
110252
  var lib$b = {};
110243
110253
 
110244
- var hasRequiredLib$5;
110254
+ var hasRequiredLib$6;
110245
110255
 
110246
- function requireLib$5 () {
110247
- if (hasRequiredLib$5) return lib$b;
110248
- hasRequiredLib$5 = 1;
110256
+ function requireLib$6 () {
110257
+ if (hasRequiredLib$6) return lib$b;
110258
+ hasRequiredLib$6 = 1;
110249
110259
 
110250
110260
  Object.defineProperty(lib$b, "__esModule", {
110251
110261
  value: true
@@ -110895,7 +110905,7 @@ function requireCore$3 () {
110895
110905
  var _is = requireIs$3();
110896
110906
  var _isValidIdentifier = isValidIdentifier$7;
110897
110907
  var _helperValidatorIdentifier = lib$c;
110898
- var _helperStringParser = requireLib$5();
110908
+ var _helperStringParser = requireLib$6();
110899
110909
  var _constants = constants$3;
110900
110910
  var _utils = requireUtils$3();
110901
110911
  const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -114054,7 +114064,7 @@ function requireValidateNode$3 () {
114054
114064
  });
114055
114065
  validateNode$3.default = validateNode;
114056
114066
  var _validate = requireValidate$3();
114057
- var _ = requireLib$4();
114067
+ var _ = requireLib$5();
114058
114068
  function validateNode(node) {
114059
114069
  const keys = _.BUILDER_KEYS[node.type];
114060
114070
  for (const key of keys) {
@@ -116070,7 +116080,7 @@ function requireCleanJSXElementLiteralChild$3 () {
116070
116080
  });
116071
116081
  cleanJSXElementLiteralChild$3.default = cleanJSXElementLiteralChild;
116072
116082
  var _generated = requireGenerated$3();
116073
- var _ = requireLib$4();
116083
+ var _ = requireLib$5();
116074
116084
  function cleanJSXElementLiteralChild(child, args) {
116075
116085
  const lines = child.value.split(/\r\n|\n|\r/);
116076
116086
  let lastNonEmptyLine = 0;
@@ -120156,7 +120166,7 @@ function requirePrependToMemberExpression$3 () {
120156
120166
  });
120157
120167
  prependToMemberExpression$3.default = prependToMemberExpression;
120158
120168
  var _generated = requireGenerated$3();
120159
- var _ = requireLib$4();
120169
+ var _ = requireLib$5();
120160
120170
  function prependToMemberExpression(member, prepend) {
120161
120171
  if ((0, _.isSuper)(member.object)) {
120162
120172
  throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -120508,11 +120518,11 @@ function isVar$7(node) {
120508
120518
  }) && !node[_constants$f.BLOCK_SCOPED_SYMBOL];
120509
120519
  }
120510
120520
 
120511
- var hasRequiredLib$4;
120521
+ var hasRequiredLib$5;
120512
120522
 
120513
- function requireLib$4 () {
120514
- if (hasRequiredLib$4) return lib$d;
120515
- hasRequiredLib$4 = 1;
120523
+ function requireLib$5 () {
120524
+ if (hasRequiredLib$5) return lib$d;
120525
+ hasRequiredLib$5 = 1;
120516
120526
  (function (exports) {
120517
120527
 
120518
120528
  Object.defineProperty(exports, "__esModule", {
@@ -121091,7 +121101,7 @@ Object.defineProperty(lib$e, "__esModule", {
121091
121101
  value: true
121092
121102
  });
121093
121103
  lib$e.default = hoistVariables;
121094
- var _t$9 = requireLib$4();
121104
+ var _t$9 = requireLib$5();
121095
121105
  const {
121096
121106
  assignmentExpression: assignmentExpression$2,
121097
121107
  expressionStatement: expressionStatement$3,
@@ -121150,11 +121160,11 @@ function requireReplacement () {
121150
121160
  replacement.replaceWithMultiple = replaceWithMultiple;
121151
121161
  replacement.replaceWithSourceString = replaceWithSourceString;
121152
121162
  var _codeFrame = lib$i;
121153
- var _index = requireLib$2();
121163
+ var _index = requireLib$3();
121154
121164
  var _index2 = requirePath();
121155
121165
  var _cache = cache;
121156
121166
  var _parser = lib$f;
121157
- var _t = requireLib$6();
121167
+ var _t = requireLib$7();
121158
121168
  var _helperHoistVariables = lib$e;
121159
121169
  const {
121160
121170
  FUNCTION_TYPES,
@@ -124888,23 +124898,23 @@ var lib$6 = {};
124888
124898
  Object.defineProperty(lib$6, "__esModule", {
124889
124899
  value: true
124890
124900
  });
124891
- lib$6.readCodePoint = readCodePoint$2;
124892
- lib$6.readInt = readInt$2;
124893
- lib$6.readStringContents = readStringContents$2;
124894
- var _isDigit$2 = function isDigit(code) {
124901
+ lib$6.readCodePoint = readCodePoint$1;
124902
+ lib$6.readInt = readInt$1;
124903
+ lib$6.readStringContents = readStringContents$1;
124904
+ var _isDigit$1 = function isDigit(code) {
124895
124905
  return code >= 48 && code <= 57;
124896
124906
  };
124897
- const forbiddenNumericSeparatorSiblings$2 = {
124907
+ const forbiddenNumericSeparatorSiblings$1 = {
124898
124908
  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
124899
124909
  hex: new Set([46, 88, 95, 120])
124900
124910
  };
124901
- const isAllowedNumericSeparatorSibling$2 = {
124911
+ const isAllowedNumericSeparatorSibling$1 = {
124902
124912
  bin: ch => ch === 48 || ch === 49,
124903
124913
  oct: ch => ch >= 48 && ch <= 55,
124904
124914
  dec: ch => ch >= 48 && ch <= 57,
124905
124915
  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
124906
124916
  };
124907
- function readStringContents$2(type, input, pos, lineStart, curLine, errors) {
124917
+ function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
124908
124918
  const initialPos = pos;
124909
124919
  const initialLineStart = lineStart;
124910
124920
  const initialCurLine = curLine;
@@ -124921,13 +124931,13 @@ function readStringContents$2(type, input, pos, lineStart, curLine, errors) {
124921
124931
  break;
124922
124932
  }
124923
124933
  const ch = input.charCodeAt(pos);
124924
- if (isStringEnd$2(type, ch, input, pos)) {
124934
+ if (isStringEnd$1(type, ch, input, pos)) {
124925
124935
  out += input.slice(chunkStart, pos);
124926
124936
  break;
124927
124937
  }
124928
124938
  if (ch === 92) {
124929
124939
  out += input.slice(chunkStart, pos);
124930
- const res = readEscapedChar$2(input, pos, lineStart, curLine, type === "template", errors);
124940
+ const res = readEscapedChar$1(input, pos, lineStart, curLine, type === "template", errors);
124931
124941
  if (res.ch === null && !firstInvalidLoc) {
124932
124942
  firstInvalidLoc = {
124933
124943
  pos,
@@ -124972,13 +124982,13 @@ function readStringContents$2(type, input, pos, lineStart, curLine, errors) {
124972
124982
  containsInvalid: !!firstInvalidLoc
124973
124983
  };
124974
124984
  }
124975
- function isStringEnd$2(type, ch, input, pos) {
124985
+ function isStringEnd$1(type, ch, input, pos) {
124976
124986
  if (type === "template") {
124977
124987
  return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
124978
124988
  }
124979
124989
  return ch === (type === "double" ? 34 : 39);
124980
124990
  }
124981
- function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
124991
+ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
124982
124992
  const throwOnInvalid = !inTemplate;
124983
124993
  pos++;
124984
124994
  const res = ch => ({
@@ -124999,7 +125009,7 @@ function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
124999
125009
  ({
125000
125010
  code,
125001
125011
  pos
125002
- } = readHexChar$2(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
125012
+ } = readHexChar$1(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
125003
125013
  return res(code === null ? null : String.fromCharCode(code));
125004
125014
  }
125005
125015
  case 117:
@@ -125008,7 +125018,7 @@ function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
125008
125018
  ({
125009
125019
  code,
125010
125020
  pos
125011
- } = readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors));
125021
+ } = readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors));
125012
125022
  return res(code === null ? null : String.fromCodePoint(code));
125013
125023
  }
125014
125024
  case 116:
@@ -125060,13 +125070,13 @@ function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
125060
125070
  return res(String.fromCharCode(ch));
125061
125071
  }
125062
125072
  }
125063
- function readHexChar$2(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
125073
+ function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
125064
125074
  const initialPos = pos;
125065
125075
  let n;
125066
125076
  ({
125067
125077
  n,
125068
125078
  pos
125069
- } = readInt$2(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
125079
+ } = readInt$1(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
125070
125080
  if (n === null) {
125071
125081
  if (throwOnInvalid) {
125072
125082
  errors.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -125079,10 +125089,10 @@ function readHexChar$2(input, pos, lineStart, curLine, len, forceLen, throwOnInv
125079
125089
  pos
125080
125090
  };
125081
125091
  }
125082
- function readInt$2(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
125092
+ function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
125083
125093
  const start = pos;
125084
- const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$2.hex : forbiddenNumericSeparatorSiblings$2.decBinOct;
125085
- const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$2.hex : radix === 10 ? isAllowedNumericSeparatorSibling$2.dec : radix === 8 ? isAllowedNumericSeparatorSibling$2.oct : isAllowedNumericSeparatorSibling$2.bin;
125094
+ const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$1.hex : forbiddenNumericSeparatorSiblings$1.decBinOct;
125095
+ const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$1.hex : radix === 10 ? isAllowedNumericSeparatorSibling$1.dec : radix === 8 ? isAllowedNumericSeparatorSibling$1.oct : isAllowedNumericSeparatorSibling$1.bin;
125086
125096
  let invalid = false;
125087
125097
  let total = 0;
125088
125098
  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
@@ -125111,7 +125121,7 @@ function readInt$2(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
125111
125121
  val = code - 97 + 10;
125112
125122
  } else if (code >= 65) {
125113
125123
  val = code - 65 + 10;
125114
- } else if (_isDigit$2(code)) {
125124
+ } else if (_isDigit$1(code)) {
125115
125125
  val = code - 48;
125116
125126
  } else {
125117
125127
  val = Infinity;
@@ -125145,7 +125155,7 @@ function readInt$2(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
125145
125155
  pos
125146
125156
  };
125147
125157
  }
125148
- function readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors) {
125158
+ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors) {
125149
125159
  const ch = input.charCodeAt(pos);
125150
125160
  let code;
125151
125161
  if (ch === 123) {
@@ -125153,7 +125163,7 @@ function readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors)
125153
125163
  ({
125154
125164
  code,
125155
125165
  pos
125156
- } = readHexChar$2(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
125166
+ } = readHexChar$1(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
125157
125167
  ++pos;
125158
125168
  if (code !== null && code > 0x10ffff) {
125159
125169
  if (throwOnInvalid) {
@@ -125169,7 +125179,7 @@ function readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors)
125169
125179
  ({
125170
125180
  code,
125171
125181
  pos
125172
- } = readHexChar$2(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
125182
+ } = readHexChar$1(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
125173
125183
  }
125174
125184
  return {
125175
125185
  code,
@@ -128688,7 +128698,7 @@ function requireValidateNode$2 () {
128688
128698
  });
128689
128699
  validateNode$2.default = validateNode;
128690
128700
  var _validate = requireValidate$2();
128691
- var _ = requireLib$3();
128701
+ var _ = requireLib$4();
128692
128702
  function validateNode(node) {
128693
128703
  const keys = _.BUILDER_KEYS[node.type];
128694
128704
  for (const key of keys) {
@@ -130704,7 +130714,7 @@ function requireCleanJSXElementLiteralChild$2 () {
130704
130714
  });
130705
130715
  cleanJSXElementLiteralChild$2.default = cleanJSXElementLiteralChild;
130706
130716
  var _generated = requireGenerated$2();
130707
- var _ = requireLib$3();
130717
+ var _ = requireLib$4();
130708
130718
  function cleanJSXElementLiteralChild(child, args) {
130709
130719
  const lines = child.value.split(/\r\n|\n|\r/);
130710
130720
  let lastNonEmptyLine = 0;
@@ -134790,7 +134800,7 @@ function requirePrependToMemberExpression$2 () {
134790
134800
  });
134791
134801
  prependToMemberExpression$2.default = prependToMemberExpression;
134792
134802
  var _generated = requireGenerated$2();
134793
- var _ = requireLib$3();
134803
+ var _ = requireLib$4();
134794
134804
  function prependToMemberExpression(member, prepend) {
134795
134805
  if ((0, _.isSuper)(member.object)) {
134796
134806
  throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -135142,11 +135152,11 @@ function isVar$5(node) {
135142
135152
  }) && !node[_constants$a.BLOCK_SCOPED_SYMBOL];
135143
135153
  }
135144
135154
 
135145
- var hasRequiredLib$3;
135155
+ var hasRequiredLib$4;
135146
135156
 
135147
- function requireLib$3 () {
135148
- if (hasRequiredLib$3) return lib$8;
135149
- hasRequiredLib$3 = 1;
135157
+ function requireLib$4 () {
135158
+ if (hasRequiredLib$4) return lib$8;
135159
+ hasRequiredLib$4 = 1;
135150
135160
  (function (exports) {
135151
135161
 
135152
135162
  Object.defineProperty(exports, "__esModule", {
@@ -135725,7 +135735,7 @@ Object.defineProperty(formatters$1, "__esModule", {
135725
135735
  value: true
135726
135736
  });
135727
135737
  formatters$1.statements = formatters$1.statement = formatters$1.smart = formatters$1.program = formatters$1.expression = void 0;
135728
- var _t$8 = requireLib$3();
135738
+ var _t$8 = requireLib$4();
135729
135739
  const {
135730
135740
  assertExpressionStatement: assertExpressionStatement$2
135731
135741
  } = _t$8;
@@ -135866,7 +135876,7 @@ Object.defineProperty(parse$5, "__esModule", {
135866
135876
  value: true
135867
135877
  });
135868
135878
  parse$5.default = parseAndBuildMetadata;
135869
- var _t$7 = requireLib$3();
135879
+ var _t$7 = requireLib$4();
135870
135880
  var _parser = lib$f;
135871
135881
  var _codeFrame = lib$i;
135872
135882
  const {
@@ -136025,7 +136035,7 @@ Object.defineProperty(populate, "__esModule", {
136025
136035
  value: true
136026
136036
  });
136027
136037
  populate.default = populatePlaceholders;
136028
- var _t$6 = requireLib$3();
136038
+ var _t$6 = requireLib$4();
136029
136039
  const {
136030
136040
  blockStatement: blockStatement$2,
136031
136041
  cloneNode: cloneNode$6,
@@ -136322,7 +136332,7 @@ Object.defineProperty(lib$a, "__esModule", {
136322
136332
  });
136323
136333
  lib$a.default = _default$6;
136324
136334
  var _template = lib$9;
136325
- var _t$5 = requireLib$3();
136335
+ var _t$5 = requireLib$4();
136326
136336
  const {
136327
136337
  NOT_LOCAL_BINDING: NOT_LOCAL_BINDING$2,
136328
136338
  cloneNode: cloneNode$5,
@@ -136491,7 +136501,7 @@ conversion.arrowFunctionToExpression = arrowFunctionToExpression;
136491
136501
  conversion.ensureBlock = ensureBlock$2;
136492
136502
  conversion.toComputedKey = toComputedKey$2;
136493
136503
  conversion.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
136494
- var _t$4 = requireLib$6();
136504
+ var _t$4 = requireLib$7();
136495
136505
  var _helperEnvironmentVisitor = lib$k;
136496
136506
  var _helperFunctionName = lib$a;
136497
136507
  var _visitors = visitors;
@@ -136975,7 +136985,7 @@ introspection.matchesPattern = matchesPattern$5;
136975
136985
  introspection.referencesImport = referencesImport;
136976
136986
  introspection.resolve = resolve$1;
136977
136987
  introspection.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
136978
- var _t$3 = requireLib$6();
136988
+ var _t$3 = requireLib$7();
136979
136989
  const {
136980
136990
  STATEMENT_OR_BLOCK_KEYS: STATEMENT_OR_BLOCK_KEYS$2,
136981
136991
  VISITOR_KEYS,
@@ -137679,7 +137689,7 @@ Object.defineProperty(hoister, "__esModule", {
137679
137689
  value: true
137680
137690
  });
137681
137691
  hoister.default = void 0;
137682
- var _t$2 = requireLib$6();
137692
+ var _t$2 = requireLib$7();
137683
137693
  var _t2 = _t$2;
137684
137694
  const {
137685
137695
  react: react$1
@@ -137865,7 +137875,7 @@ function requireModification () {
137865
137875
  var _cache = cache;
137866
137876
  var _hoister = hoister;
137867
137877
  var _index = requirePath();
137868
- var _t = requireLib$6();
137878
+ var _t = requireLib$7();
137869
137879
  const {
137870
137880
  arrowFunctionExpression,
137871
137881
  assertExpression,
@@ -138101,7 +138111,7 @@ function requireFamily () {
138101
138111
  family.getPrevSibling = getPrevSibling;
138102
138112
  family.getSibling = getSibling;
138103
138113
  var _index = requirePath();
138104
- var _t = requireLib$6();
138114
+ var _t = requireLib$7();
138105
138115
  const {
138106
138116
  getBindingIdentifiers: _getBindingIdentifiers,
138107
138117
  getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
@@ -138428,7 +138438,7 @@ Object.defineProperty(comments$1, "__esModule", {
138428
138438
  comments$1.addComment = addComment$4;
138429
138439
  comments$1.addComments = addComments$4;
138430
138440
  comments$1.shareCommentsWithSiblings = shareCommentsWithSiblings;
138431
- var _t$1 = requireLib$6();
138441
+ var _t$1 = requireLib$7();
138432
138442
  const {
138433
138443
  addComment: _addComment,
138434
138444
  addComments: _addComments$2
@@ -138494,7 +138504,7 @@ virtualTypesValidator.isSpreadProperty = isSpreadProperty$2;
138494
138504
  virtualTypesValidator.isStatement = isStatement$7;
138495
138505
  virtualTypesValidator.isUser = isUser;
138496
138506
  virtualTypesValidator.isVar = isVar$4;
138497
- var _t = requireLib$6();
138507
+ var _t = requireLib$7();
138498
138508
  const {
138499
138509
  isBinding: isBinding$5,
138500
138510
  isBlockScoped: nodeIsBlockScoped,
@@ -138647,9 +138657,9 @@ function requirePath () {
138647
138657
  path.default = path.SHOULD_STOP = path.SHOULD_SKIP = path.REMOVED = void 0;
138648
138658
  var virtualTypes = virtualTypes$1;
138649
138659
  var _debug = browserExports;
138650
- var _index = requireLib$2();
138660
+ var _index = requireLib$3();
138651
138661
  var _scope = requireScope();
138652
- var _t = requireLib$6();
138662
+ var _t = requireLib$7();
138653
138663
  var t = _t;
138654
138664
  var cache$1 = cache;
138655
138665
  var _generator = lib$j;
@@ -138846,7 +138856,7 @@ function requireContext () {
138846
138856
  });
138847
138857
  context$1.default = void 0;
138848
138858
  var _path = requirePath();
138849
- var _t = requireLib$6();
138859
+ var _t = requireLib$7();
138850
138860
  const {
138851
138861
  VISITOR_KEYS
138852
138862
  } = _t;
@@ -138968,7 +138978,7 @@ function requireTraverseNode () {
138968
138978
  });
138969
138979
  traverseNode.traverseNode = traverseNode$1;
138970
138980
  var _context = requireContext();
138971
- var _t = requireLib$6();
138981
+ var _t = requireLib$7();
138972
138982
  const {
138973
138983
  VISITOR_KEYS
138974
138984
  } = _t;
@@ -139011,11 +139021,11 @@ class Hub {
139011
139021
  }
139012
139022
  hub.default = Hub;
139013
139023
 
139014
- var hasRequiredLib$2;
139024
+ var hasRequiredLib$3;
139015
139025
 
139016
- function requireLib$2 () {
139017
- if (hasRequiredLib$2) return lib$p;
139018
- hasRequiredLib$2 = 1;
139026
+ function requireLib$3 () {
139027
+ if (hasRequiredLib$3) return lib$p;
139028
+ hasRequiredLib$3 = 1;
139019
139029
  (function (exports) {
139020
139030
 
139021
139031
  Object.defineProperty(exports, "__esModule", {
@@ -139042,7 +139052,7 @@ function requireLib$2 () {
139042
139052
  exports.visitors = exports.default = void 0;
139043
139053
  var visitors$1 = visitors;
139044
139054
  exports.visitors = visitors$1;
139045
- var _t = requireLib$6();
139055
+ var _t = requireLib$7();
139046
139056
  var cache$1 = cache;
139047
139057
  var _traverseNode = requireTraverseNode();
139048
139058
  var _path = requirePath();
@@ -142316,23 +142326,23 @@ var lib$3 = {};
142316
142326
  Object.defineProperty(lib$3, "__esModule", {
142317
142327
  value: true
142318
142328
  });
142319
- lib$3.readCodePoint = readCodePoint$1;
142320
- lib$3.readInt = readInt$1;
142321
- lib$3.readStringContents = readStringContents$1;
142322
- var _isDigit$1 = function isDigit(code) {
142329
+ lib$3.readCodePoint = readCodePoint;
142330
+ lib$3.readInt = readInt;
142331
+ lib$3.readStringContents = readStringContents;
142332
+ var _isDigit = function isDigit(code) {
142323
142333
  return code >= 48 && code <= 57;
142324
142334
  };
142325
- const forbiddenNumericSeparatorSiblings$1 = {
142335
+ const forbiddenNumericSeparatorSiblings = {
142326
142336
  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
142327
142337
  hex: new Set([46, 88, 95, 120])
142328
142338
  };
142329
- const isAllowedNumericSeparatorSibling$1 = {
142339
+ const isAllowedNumericSeparatorSibling = {
142330
142340
  bin: ch => ch === 48 || ch === 49,
142331
142341
  oct: ch => ch >= 48 && ch <= 55,
142332
142342
  dec: ch => ch >= 48 && ch <= 57,
142333
142343
  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
142334
142344
  };
142335
- function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
142345
+ function readStringContents(type, input, pos, lineStart, curLine, errors) {
142336
142346
  const initialPos = pos;
142337
142347
  const initialLineStart = lineStart;
142338
142348
  const initialCurLine = curLine;
@@ -142349,13 +142359,13 @@ function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
142349
142359
  break;
142350
142360
  }
142351
142361
  const ch = input.charCodeAt(pos);
142352
- if (isStringEnd$1(type, ch, input, pos)) {
142362
+ if (isStringEnd(type, ch, input, pos)) {
142353
142363
  out += input.slice(chunkStart, pos);
142354
142364
  break;
142355
142365
  }
142356
142366
  if (ch === 92) {
142357
142367
  out += input.slice(chunkStart, pos);
142358
- const res = readEscapedChar$1(input, pos, lineStart, curLine, type === "template", errors);
142368
+ const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
142359
142369
  if (res.ch === null && !firstInvalidLoc) {
142360
142370
  firstInvalidLoc = {
142361
142371
  pos,
@@ -142400,13 +142410,13 @@ function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
142400
142410
  containsInvalid: !!firstInvalidLoc
142401
142411
  };
142402
142412
  }
142403
- function isStringEnd$1(type, ch, input, pos) {
142413
+ function isStringEnd(type, ch, input, pos) {
142404
142414
  if (type === "template") {
142405
142415
  return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
142406
142416
  }
142407
142417
  return ch === (type === "double" ? 34 : 39);
142408
142418
  }
142409
- function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
142419
+ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
142410
142420
  const throwOnInvalid = !inTemplate;
142411
142421
  pos++;
142412
142422
  const res = ch => ({
@@ -142427,7 +142437,7 @@ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
142427
142437
  ({
142428
142438
  code,
142429
142439
  pos
142430
- } = readHexChar$1(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
142440
+ } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
142431
142441
  return res(code === null ? null : String.fromCharCode(code));
142432
142442
  }
142433
142443
  case 117:
@@ -142436,7 +142446,7 @@ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
142436
142446
  ({
142437
142447
  code,
142438
142448
  pos
142439
- } = readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors));
142449
+ } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
142440
142450
  return res(code === null ? null : String.fromCodePoint(code));
142441
142451
  }
142442
142452
  case 116:
@@ -142488,13 +142498,13 @@ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
142488
142498
  return res(String.fromCharCode(ch));
142489
142499
  }
142490
142500
  }
142491
- function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
142501
+ function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
142492
142502
  const initialPos = pos;
142493
142503
  let n;
142494
142504
  ({
142495
142505
  n,
142496
142506
  pos
142497
- } = readInt$1(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
142507
+ } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
142498
142508
  if (n === null) {
142499
142509
  if (throwOnInvalid) {
142500
142510
  errors.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -142507,10 +142517,10 @@ function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInv
142507
142517
  pos
142508
142518
  };
142509
142519
  }
142510
- function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
142520
+ function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
142511
142521
  const start = pos;
142512
- const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$1.hex : forbiddenNumericSeparatorSiblings$1.decBinOct;
142513
- const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$1.hex : radix === 10 ? isAllowedNumericSeparatorSibling$1.dec : radix === 8 ? isAllowedNumericSeparatorSibling$1.oct : isAllowedNumericSeparatorSibling$1.bin;
142522
+ const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
142523
+ const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
142514
142524
  let invalid = false;
142515
142525
  let total = 0;
142516
142526
  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
@@ -142539,7 +142549,7 @@ function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
142539
142549
  val = code - 97 + 10;
142540
142550
  } else if (code >= 65) {
142541
142551
  val = code - 65 + 10;
142542
- } else if (_isDigit$1(code)) {
142552
+ } else if (_isDigit(code)) {
142543
142553
  val = code - 48;
142544
142554
  } else {
142545
142555
  val = Infinity;
@@ -142573,7 +142583,7 @@ function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
142573
142583
  pos
142574
142584
  };
142575
142585
  }
142576
- function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors) {
142586
+ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
142577
142587
  const ch = input.charCodeAt(pos);
142578
142588
  let code;
142579
142589
  if (ch === 123) {
@@ -142581,7 +142591,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
142581
142591
  ({
142582
142592
  code,
142583
142593
  pos
142584
- } = readHexChar$1(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
142594
+ } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
142585
142595
  ++pos;
142586
142596
  if (code !== null && code > 0x10ffff) {
142587
142597
  if (throwOnInvalid) {
@@ -142597,7 +142607,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
142597
142607
  ({
142598
142608
  code,
142599
142609
  pos
142600
- } = readHexChar$1(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
142610
+ } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
142601
142611
  }
142602
142612
  return {
142603
142613
  code,
@@ -146116,7 +146126,7 @@ function requireValidateNode$1 () {
146116
146126
  });
146117
146127
  validateNode$1.default = validateNode;
146118
146128
  var _validate = requireValidate$1();
146119
- var _ = requireLib$1();
146129
+ var _ = requireLib$2();
146120
146130
  function validateNode(node) {
146121
146131
  const keys = _.BUILDER_KEYS[node.type];
146122
146132
  for (const key of keys) {
@@ -148132,7 +148142,7 @@ function requireCleanJSXElementLiteralChild$1 () {
148132
148142
  });
148133
148143
  cleanJSXElementLiteralChild$1.default = cleanJSXElementLiteralChild;
148134
148144
  var _generated = requireGenerated$1();
148135
- var _ = requireLib$1();
148145
+ var _ = requireLib$2();
148136
148146
  function cleanJSXElementLiteralChild(child, args) {
148137
148147
  const lines = child.value.split(/\r\n|\n|\r/);
148138
148148
  let lastNonEmptyLine = 0;
@@ -152218,7 +152228,7 @@ function requirePrependToMemberExpression$1 () {
152218
152228
  });
152219
152229
  prependToMemberExpression$1.default = prependToMemberExpression;
152220
152230
  var _generated = requireGenerated$1();
152221
- var _ = requireLib$1();
152231
+ var _ = requireLib$2();
152222
152232
  function prependToMemberExpression(member, prepend) {
152223
152233
  if ((0, _.isSuper)(member.object)) {
152224
152234
  throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -152570,11 +152580,11 @@ function isVar$2(node) {
152570
152580
  }) && !node[_constants$5.BLOCK_SCOPED_SYMBOL];
152571
152581
  }
152572
152582
 
152573
- var hasRequiredLib$1;
152583
+ var hasRequiredLib$2;
152574
152584
 
152575
- function requireLib$1 () {
152576
- if (hasRequiredLib$1) return lib$5;
152577
- hasRequiredLib$1 = 1;
152585
+ function requireLib$2 () {
152586
+ if (hasRequiredLib$2) return lib$5;
152587
+ hasRequiredLib$2 = 1;
152578
152588
  (function (exports) {
152579
152589
 
152580
152590
  Object.defineProperty(exports, "__esModule", {
@@ -153158,7 +153168,7 @@ const {
153158
153168
  isVariableDeclaration: isVariableDeclaration$2,
153159
153169
  isMemberExpression: isMemberExpression$3,
153160
153170
  isArrayExpression: isArrayExpression$2,
153161
- } = requireLib$1();
153171
+ } = requireLib$2();
153162
153172
 
153163
153173
  const isParentProgram$1 = (path) => path.parentPath?.isProgram();
153164
153174
  const isParentBlock$3 = (path) => path.parentPath.isBlockStatement();
@@ -153304,7 +153314,7 @@ maybeInsideFn$1.maybeInsideFn = (insideFn, {print, indent}) => {
153304
153314
  };
153305
153315
 
153306
153316
  const {hasTrailingComment: hasTrailingComment$1} = is$5;
153307
- const {isVariableDeclarator: isVariableDeclarator$1} = requireLib$1();
153317
+ const {isVariableDeclarator: isVariableDeclarator$1} = requireLib$2();
153308
153318
 
153309
153319
  const {markBefore: markBefore$1} = mark;
153310
153320
  const {maybeInsideFn} = maybeInsideFn$1;
@@ -153915,7 +153925,7 @@ const {
153915
153925
  isArrowFunctionExpression: isArrowFunctionExpression$2,
153916
153926
  isLogicalExpression: isLogicalExpression$1,
153917
153927
  isIfStatement: isIfStatement$1,
153918
- } = requireLib$1();
153928
+ } = requireLib$2();
153919
153929
 
153920
153930
  const {chain} = chain$1;
153921
153931
  const {satisfy: satisfy$2} = is$5;
@@ -154345,7 +154355,7 @@ const {
154345
154355
  isStringLiteral: isStringLiteral$5,
154346
154356
  isTemplateLiteral: isTemplateLiteral$3,
154347
154357
  isBinaryExpression: isBinaryExpression$1,
154348
- } = requireLib$1();
154358
+ } = requireLib$2();
154349
154359
 
154350
154360
  const isStringLike = (a) => {
154351
154361
  if (isStringLiteral$5(a))
@@ -154447,7 +154457,7 @@ const {
154447
154457
  isIdentifier: isIdentifier$8,
154448
154458
  isObjectPattern: isObjectPattern$3,
154449
154459
  isAssignmentPattern: isAssignmentPattern$1,
154450
- } = requireLib$1();
154460
+ } = requireLib$2();
154451
154461
 
154452
154462
  const {wrongShorthand} = wrongShortand;
154453
154463
 
@@ -154663,7 +154673,7 @@ parens.maybeParenClose = (path, {maybe}) => {
154663
154673
  maybe.write(isParens$3(path), ')');
154664
154674
  };
154665
154675
 
154666
- const {isObjectPattern: isObjectPattern$2} = requireLib$1();
154676
+ const {isObjectPattern: isObjectPattern$2} = requireLib$2();
154667
154677
  const {isParens: isParens$2} = parens;
154668
154678
 
154669
154679
  assignmentExpression.AssignmentExpression = {
@@ -155333,7 +155343,7 @@ const {
155333
155343
  isNullLiteral: isNullLiteral$1,
155334
155344
  isStringLiteral: isStringLiteral$4,
155335
155345
  isSpreadElement: isSpreadElement$1,
155336
- } = requireLib$1();
155346
+ } = requireLib$2();
155337
155347
 
155338
155348
  const {
155339
155349
  isStringAndMember,
@@ -155613,7 +155623,7 @@ const {
155613
155623
  const {
155614
155624
  isObjectExpression: isObjectExpression$2,
155615
155625
  isStringLiteral: isStringLiteral$3,
155616
- } = requireLib$1();
155626
+ } = requireLib$2();
155617
155627
 
155618
155628
  const isNextObject = (a) => a.getNextSibling().isObjectExpression();
155619
155629
 
@@ -156034,7 +156044,7 @@ const {
156034
156044
  ExpressionStatement: ExpressionStatement$2,
156035
156045
  Program: Program$1,
156036
156046
  isStatement: isStatement$3,
156037
- } = requireLib$1();
156047
+ } = requireLib$2();
156038
156048
 
156039
156049
  const isFn$3 = (a) => typeof a === 'function';
156040
156050
 
@@ -156295,7 +156305,7 @@ const {
156295
156305
  } = is$5;
156296
156306
 
156297
156307
  const {hasPrevNewline: hasPrevNewline$2} = mark;
156298
- const {isExportDeclaration: isExportDeclaration$3} = requireLib$1();
156308
+ const {isExportDeclaration: isExportDeclaration$3} = requireLib$2();
156299
156309
  const {maybeSpaceAfterKeyword: maybeSpaceAfterKeyword$2} = maybeSpaceAfterKeyword$3;
156300
156310
 
156301
156311
  const {isConcatenation} = concatanate$1;
@@ -156654,7 +156664,7 @@ const {
156654
156664
  const {
156655
156665
  isArrowFunctionExpression: isArrowFunctionExpression$1,
156656
156666
  isObjectMethod: isObjectMethod$1,
156657
- } = requireLib$1();
156667
+ } = requireLib$2();
156658
156668
 
156659
156669
  const {markAfter: markAfter$5} = mark;
156660
156670
  const {parseComments: parseComments$2} = comment;
@@ -157141,7 +157151,7 @@ const {
157141
157151
  } = is$5;
157142
157152
 
157143
157153
  const {markAfter: markAfter$2, isMarkedAfter} = mark;
157144
- const {isExportNamespaceSpecifier: isExportNamespaceSpecifier$1} = requireLib$1();
157154
+ const {isExportNamespaceSpecifier: isExportNamespaceSpecifier$1} = requireLib$2();
157145
157155
  const isDeclarationNewline = (path) => isMarkedAfter(path.get('declaration'));
157146
157156
  const isInsideNamespace = (path) => path.parentPath.isTSModuleBlock();
157147
157157
 
@@ -157926,7 +157936,7 @@ const {isNext: isNext$2, isNextParent} = is$5;
157926
157936
  const {
157927
157937
  isTSTypeAliasDeclaration: isTSTypeAliasDeclaration$1,
157928
157938
  isExportDeclaration: isExportDeclaration$2,
157929
- } = requireLib$1();
157939
+ } = requireLib$2();
157930
157940
 
157931
157941
  tsInterfaceDeclaration.TSInterfaceDeclaration = {
157932
157942
  print(path, {print}) {
@@ -158801,7 +158811,7 @@ function initSemantics(semantics = {}) {
158801
158811
  const {round} = Math;
158802
158812
  const fullstore = fullstore$1;
158803
158813
  const isObject$3 = (a) => a && typeof a === 'object';
158804
- const babelTraverse$2 = requireLib$2().default;
158814
+ const babelTraverse$2 = requireLib$3().default;
158805
158815
  const expressions = expressions$1;
158806
158816
  const statements = statements$1;
158807
158817
  const literals = literals$1;
@@ -162361,296 +162371,306 @@ function isValidIdentifier(name, reserved = true) {
162361
162371
 
162362
162372
  var lib = {};
162363
162373
 
162364
- Object.defineProperty(lib, "__esModule", {
162365
- value: true
162366
- });
162367
- lib.readCodePoint = readCodePoint;
162368
- lib.readInt = readInt;
162369
- lib.readStringContents = readStringContents;
162370
- var _isDigit = function isDigit(code) {
162371
- return code >= 48 && code <= 57;
162372
- };
162373
- const forbiddenNumericSeparatorSiblings = {
162374
- decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
162375
- hex: new Set([46, 88, 95, 120])
162376
- };
162377
- const isAllowedNumericSeparatorSibling = {
162378
- bin: ch => ch === 48 || ch === 49,
162379
- oct: ch => ch >= 48 && ch <= 55,
162380
- dec: ch => ch >= 48 && ch <= 57,
162381
- hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
162382
- };
162383
- function readStringContents(type, input, pos, lineStart, curLine, errors) {
162384
- const initialPos = pos;
162385
- const initialLineStart = lineStart;
162386
- const initialCurLine = curLine;
162387
- let out = "";
162388
- let firstInvalidLoc = null;
162389
- let chunkStart = pos;
162390
- const {
162391
- length
162392
- } = input;
162393
- for (;;) {
162394
- if (pos >= length) {
162395
- errors.unterminated(initialPos, initialLineStart, initialCurLine);
162396
- out += input.slice(chunkStart, pos);
162397
- break;
162398
- }
162399
- const ch = input.charCodeAt(pos);
162400
- if (isStringEnd(type, ch, input, pos)) {
162401
- out += input.slice(chunkStart, pos);
162402
- break;
162403
- }
162404
- if (ch === 92) {
162405
- out += input.slice(chunkStart, pos);
162406
- const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
162407
- if (res.ch === null && !firstInvalidLoc) {
162408
- firstInvalidLoc = {
162409
- pos,
162410
- lineStart,
162411
- curLine
162412
- };
162413
- } else {
162414
- out += res.ch;
162415
- }
162416
- ({
162417
- pos,
162418
- lineStart,
162419
- curLine
162420
- } = res);
162421
- chunkStart = pos;
162422
- } else if (ch === 8232 || ch === 8233) {
162423
- ++pos;
162424
- ++curLine;
162425
- lineStart = pos;
162426
- } else if (ch === 10 || ch === 13) {
162427
- if (type === "template") {
162428
- out += input.slice(chunkStart, pos) + "\n";
162429
- ++pos;
162430
- if (ch === 13 && input.charCodeAt(pos) === 10) {
162431
- ++pos;
162432
- }
162433
- ++curLine;
162434
- chunkStart = lineStart = pos;
162435
- } else {
162436
- errors.unterminated(initialPos, initialLineStart, initialCurLine);
162437
- }
162438
- } else {
162439
- ++pos;
162440
- }
162441
- }
162442
- return {
162443
- pos,
162444
- str: out,
162445
- firstInvalidLoc,
162446
- lineStart,
162447
- curLine,
162448
- containsInvalid: !!firstInvalidLoc
162449
- };
162450
- }
162451
- function isStringEnd(type, ch, input, pos) {
162452
- if (type === "template") {
162453
- return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
162454
- }
162455
- return ch === (type === "double" ? 34 : 39);
162456
- }
162457
- function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
162458
- const throwOnInvalid = !inTemplate;
162459
- pos++;
162460
- const res = ch => ({
162461
- pos,
162462
- ch,
162463
- lineStart,
162464
- curLine
162465
- });
162466
- const ch = input.charCodeAt(pos++);
162467
- switch (ch) {
162468
- case 110:
162469
- return res("\n");
162470
- case 114:
162471
- return res("\r");
162472
- case 120:
162473
- {
162474
- let code;
162475
- ({
162476
- code,
162477
- pos
162478
- } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
162479
- return res(code === null ? null : String.fromCharCode(code));
162480
- }
162481
- case 117:
162482
- {
162483
- let code;
162484
- ({
162485
- code,
162486
- pos
162487
- } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
162488
- return res(code === null ? null : String.fromCodePoint(code));
162489
- }
162490
- case 116:
162491
- return res("\t");
162492
- case 98:
162493
- return res("\b");
162494
- case 118:
162495
- return res("\u000b");
162496
- case 102:
162497
- return res("\f");
162498
- case 13:
162499
- if (input.charCodeAt(pos) === 10) {
162500
- ++pos;
162501
- }
162502
- case 10:
162503
- lineStart = pos;
162504
- ++curLine;
162505
- case 8232:
162506
- case 8233:
162507
- return res("");
162508
- case 56:
162509
- case 57:
162510
- if (inTemplate) {
162511
- return res(null);
162512
- } else {
162513
- errors.strictNumericEscape(pos - 1, lineStart, curLine);
162514
- }
162515
- default:
162516
- if (ch >= 48 && ch <= 55) {
162517
- const startPos = pos - 1;
162518
- const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
162519
- let octalStr = match[0];
162520
- let octal = parseInt(octalStr, 8);
162521
- if (octal > 255) {
162522
- octalStr = octalStr.slice(0, -1);
162523
- octal = parseInt(octalStr, 8);
162524
- }
162525
- pos += octalStr.length - 1;
162526
- const next = input.charCodeAt(pos);
162527
- if (octalStr !== "0" || next === 56 || next === 57) {
162528
- if (inTemplate) {
162529
- return res(null);
162530
- } else {
162531
- errors.strictNumericEscape(startPos, lineStart, curLine);
162532
- }
162533
- }
162534
- return res(String.fromCharCode(octal));
162535
- }
162536
- return res(String.fromCharCode(ch));
162537
- }
162538
- }
162539
- function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
162540
- const initialPos = pos;
162541
- let n;
162542
- ({
162543
- n,
162544
- pos
162545
- } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
162546
- if (n === null) {
162547
- if (throwOnInvalid) {
162548
- errors.invalidEscapeSequence(initialPos, lineStart, curLine);
162549
- } else {
162550
- pos = initialPos - 1;
162551
- }
162552
- }
162553
- return {
162554
- code: n,
162555
- pos
162556
- };
162557
- }
162558
- function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
162559
- const start = pos;
162560
- const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
162561
- const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
162562
- let invalid = false;
162563
- let total = 0;
162564
- for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
162565
- const code = input.charCodeAt(pos);
162566
- let val;
162567
- if (code === 95 && allowNumSeparator !== "bail") {
162568
- const prev = input.charCodeAt(pos - 1);
162569
- const next = input.charCodeAt(pos + 1);
162570
- if (!allowNumSeparator) {
162571
- if (bailOnError) return {
162572
- n: null,
162573
- pos
162574
- };
162575
- errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
162576
- } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
162577
- if (bailOnError) return {
162578
- n: null,
162579
- pos
162580
- };
162581
- errors.unexpectedNumericSeparator(pos, lineStart, curLine);
162582
- }
162583
- ++pos;
162584
- continue;
162585
- }
162586
- if (code >= 97) {
162587
- val = code - 97 + 10;
162588
- } else if (code >= 65) {
162589
- val = code - 65 + 10;
162590
- } else if (_isDigit(code)) {
162591
- val = code - 48;
162592
- } else {
162593
- val = Infinity;
162594
- }
162595
- if (val >= radix) {
162596
- if (val <= 9 && bailOnError) {
162597
- return {
162598
- n: null,
162599
- pos
162600
- };
162601
- } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
162602
- val = 0;
162603
- } else if (forceLen) {
162604
- val = 0;
162605
- invalid = true;
162606
- } else {
162607
- break;
162608
- }
162609
- }
162610
- ++pos;
162611
- total = total * radix + val;
162612
- }
162613
- if (pos === start || len != null && pos - start !== len || invalid) {
162614
- return {
162615
- n: null,
162616
- pos
162617
- };
162618
- }
162619
- return {
162620
- n: total,
162621
- pos
162622
- };
162623
- }
162624
- function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
162625
- const ch = input.charCodeAt(pos);
162626
- let code;
162627
- if (ch === 123) {
162628
- ++pos;
162629
- ({
162630
- code,
162631
- pos
162632
- } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
162633
- ++pos;
162634
- if (code !== null && code > 0x10ffff) {
162635
- if (throwOnInvalid) {
162636
- errors.invalidCodePoint(pos, lineStart, curLine);
162637
- } else {
162638
- return {
162639
- code: null,
162640
- pos
162641
- };
162642
- }
162643
- }
162644
- } else {
162645
- ({
162646
- code,
162647
- pos
162648
- } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
162649
- }
162650
- return {
162651
- code,
162652
- pos
162653
- };
162374
+ var hasRequiredLib$1;
162375
+
162376
+ function requireLib$1 () {
162377
+ if (hasRequiredLib$1) return lib;
162378
+ hasRequiredLib$1 = 1;
162379
+
162380
+ Object.defineProperty(lib, "__esModule", {
162381
+ value: true
162382
+ });
162383
+ lib.readCodePoint = readCodePoint;
162384
+ lib.readInt = readInt;
162385
+ lib.readStringContents = readStringContents;
162386
+ var _isDigit = function isDigit(code) {
162387
+ return code >= 48 && code <= 57;
162388
+ };
162389
+ const forbiddenNumericSeparatorSiblings = {
162390
+ decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
162391
+ hex: new Set([46, 88, 95, 120])
162392
+ };
162393
+ const isAllowedNumericSeparatorSibling = {
162394
+ bin: ch => ch === 48 || ch === 49,
162395
+ oct: ch => ch >= 48 && ch <= 55,
162396
+ dec: ch => ch >= 48 && ch <= 57,
162397
+ hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
162398
+ };
162399
+ function readStringContents(type, input, pos, lineStart, curLine, errors) {
162400
+ const initialPos = pos;
162401
+ const initialLineStart = lineStart;
162402
+ const initialCurLine = curLine;
162403
+ let out = "";
162404
+ let firstInvalidLoc = null;
162405
+ let chunkStart = pos;
162406
+ const {
162407
+ length
162408
+ } = input;
162409
+ for (;;) {
162410
+ if (pos >= length) {
162411
+ errors.unterminated(initialPos, initialLineStart, initialCurLine);
162412
+ out += input.slice(chunkStart, pos);
162413
+ break;
162414
+ }
162415
+ const ch = input.charCodeAt(pos);
162416
+ if (isStringEnd(type, ch, input, pos)) {
162417
+ out += input.slice(chunkStart, pos);
162418
+ break;
162419
+ }
162420
+ if (ch === 92) {
162421
+ out += input.slice(chunkStart, pos);
162422
+ const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
162423
+ if (res.ch === null && !firstInvalidLoc) {
162424
+ firstInvalidLoc = {
162425
+ pos,
162426
+ lineStart,
162427
+ curLine
162428
+ };
162429
+ } else {
162430
+ out += res.ch;
162431
+ }
162432
+ ({
162433
+ pos,
162434
+ lineStart,
162435
+ curLine
162436
+ } = res);
162437
+ chunkStart = pos;
162438
+ } else if (ch === 8232 || ch === 8233) {
162439
+ ++pos;
162440
+ ++curLine;
162441
+ lineStart = pos;
162442
+ } else if (ch === 10 || ch === 13) {
162443
+ if (type === "template") {
162444
+ out += input.slice(chunkStart, pos) + "\n";
162445
+ ++pos;
162446
+ if (ch === 13 && input.charCodeAt(pos) === 10) {
162447
+ ++pos;
162448
+ }
162449
+ ++curLine;
162450
+ chunkStart = lineStart = pos;
162451
+ } else {
162452
+ errors.unterminated(initialPos, initialLineStart, initialCurLine);
162453
+ }
162454
+ } else {
162455
+ ++pos;
162456
+ }
162457
+ }
162458
+ return {
162459
+ pos,
162460
+ str: out,
162461
+ firstInvalidLoc,
162462
+ lineStart,
162463
+ curLine,
162464
+ containsInvalid: !!firstInvalidLoc
162465
+ };
162466
+ }
162467
+ function isStringEnd(type, ch, input, pos) {
162468
+ if (type === "template") {
162469
+ return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
162470
+ }
162471
+ return ch === (type === "double" ? 34 : 39);
162472
+ }
162473
+ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
162474
+ const throwOnInvalid = !inTemplate;
162475
+ pos++;
162476
+ const res = ch => ({
162477
+ pos,
162478
+ ch,
162479
+ lineStart,
162480
+ curLine
162481
+ });
162482
+ const ch = input.charCodeAt(pos++);
162483
+ switch (ch) {
162484
+ case 110:
162485
+ return res("\n");
162486
+ case 114:
162487
+ return res("\r");
162488
+ case 120:
162489
+ {
162490
+ let code;
162491
+ ({
162492
+ code,
162493
+ pos
162494
+ } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
162495
+ return res(code === null ? null : String.fromCharCode(code));
162496
+ }
162497
+ case 117:
162498
+ {
162499
+ let code;
162500
+ ({
162501
+ code,
162502
+ pos
162503
+ } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
162504
+ return res(code === null ? null : String.fromCodePoint(code));
162505
+ }
162506
+ case 116:
162507
+ return res("\t");
162508
+ case 98:
162509
+ return res("\b");
162510
+ case 118:
162511
+ return res("\u000b");
162512
+ case 102:
162513
+ return res("\f");
162514
+ case 13:
162515
+ if (input.charCodeAt(pos) === 10) {
162516
+ ++pos;
162517
+ }
162518
+ case 10:
162519
+ lineStart = pos;
162520
+ ++curLine;
162521
+ case 8232:
162522
+ case 8233:
162523
+ return res("");
162524
+ case 56:
162525
+ case 57:
162526
+ if (inTemplate) {
162527
+ return res(null);
162528
+ } else {
162529
+ errors.strictNumericEscape(pos - 1, lineStart, curLine);
162530
+ }
162531
+ default:
162532
+ if (ch >= 48 && ch <= 55) {
162533
+ const startPos = pos - 1;
162534
+ const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
162535
+ let octalStr = match[0];
162536
+ let octal = parseInt(octalStr, 8);
162537
+ if (octal > 255) {
162538
+ octalStr = octalStr.slice(0, -1);
162539
+ octal = parseInt(octalStr, 8);
162540
+ }
162541
+ pos += octalStr.length - 1;
162542
+ const next = input.charCodeAt(pos);
162543
+ if (octalStr !== "0" || next === 56 || next === 57) {
162544
+ if (inTemplate) {
162545
+ return res(null);
162546
+ } else {
162547
+ errors.strictNumericEscape(startPos, lineStart, curLine);
162548
+ }
162549
+ }
162550
+ return res(String.fromCharCode(octal));
162551
+ }
162552
+ return res(String.fromCharCode(ch));
162553
+ }
162554
+ }
162555
+ function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
162556
+ const initialPos = pos;
162557
+ let n;
162558
+ ({
162559
+ n,
162560
+ pos
162561
+ } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
162562
+ if (n === null) {
162563
+ if (throwOnInvalid) {
162564
+ errors.invalidEscapeSequence(initialPos, lineStart, curLine);
162565
+ } else {
162566
+ pos = initialPos - 1;
162567
+ }
162568
+ }
162569
+ return {
162570
+ code: n,
162571
+ pos
162572
+ };
162573
+ }
162574
+ function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
162575
+ const start = pos;
162576
+ const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
162577
+ const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
162578
+ let invalid = false;
162579
+ let total = 0;
162580
+ for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
162581
+ const code = input.charCodeAt(pos);
162582
+ let val;
162583
+ if (code === 95 && allowNumSeparator !== "bail") {
162584
+ const prev = input.charCodeAt(pos - 1);
162585
+ const next = input.charCodeAt(pos + 1);
162586
+ if (!allowNumSeparator) {
162587
+ if (bailOnError) return {
162588
+ n: null,
162589
+ pos
162590
+ };
162591
+ errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
162592
+ } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
162593
+ if (bailOnError) return {
162594
+ n: null,
162595
+ pos
162596
+ };
162597
+ errors.unexpectedNumericSeparator(pos, lineStart, curLine);
162598
+ }
162599
+ ++pos;
162600
+ continue;
162601
+ }
162602
+ if (code >= 97) {
162603
+ val = code - 97 + 10;
162604
+ } else if (code >= 65) {
162605
+ val = code - 65 + 10;
162606
+ } else if (_isDigit(code)) {
162607
+ val = code - 48;
162608
+ } else {
162609
+ val = Infinity;
162610
+ }
162611
+ if (val >= radix) {
162612
+ if (val <= 9 && bailOnError) {
162613
+ return {
162614
+ n: null,
162615
+ pos
162616
+ };
162617
+ } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
162618
+ val = 0;
162619
+ } else if (forceLen) {
162620
+ val = 0;
162621
+ invalid = true;
162622
+ } else {
162623
+ break;
162624
+ }
162625
+ }
162626
+ ++pos;
162627
+ total = total * radix + val;
162628
+ }
162629
+ if (pos === start || len != null && pos - start !== len || invalid) {
162630
+ return {
162631
+ n: null,
162632
+ pos
162633
+ };
162634
+ }
162635
+ return {
162636
+ n: total,
162637
+ pos
162638
+ };
162639
+ }
162640
+ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
162641
+ const ch = input.charCodeAt(pos);
162642
+ let code;
162643
+ if (ch === 123) {
162644
+ ++pos;
162645
+ ({
162646
+ code,
162647
+ pos
162648
+ } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
162649
+ ++pos;
162650
+ if (code !== null && code > 0x10ffff) {
162651
+ if (throwOnInvalid) {
162652
+ errors.invalidCodePoint(pos, lineStart, curLine);
162653
+ } else {
162654
+ return {
162655
+ code: null,
162656
+ pos
162657
+ };
162658
+ }
162659
+ }
162660
+ } else {
162661
+ ({
162662
+ code,
162663
+ pos
162664
+ } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
162665
+ }
162666
+ return {
162667
+ code,
162668
+ pos
162669
+ };
162670
+ }
162671
+
162672
+
162673
+ return lib;
162654
162674
  }
162655
162675
 
162656
162676
  var constants = {};
@@ -163005,7 +163025,7 @@ function requireCore () {
163005
163025
  var _is = requireIs();
163006
163026
  var _isValidIdentifier = isValidIdentifier$1;
163007
163027
  var _helperValidatorIdentifier = lib$1;
163008
- var _helperStringParser = lib;
163028
+ var _helperStringParser = requireLib$1();
163009
163029
  var _constants = constants;
163010
163030
  var _utils = requireUtils();
163011
163031
  const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -173594,7 +173614,7 @@ var getAst = (node) => {
173594
173614
  return ast;
173595
173615
  };
173596
173616
 
173597
- const traverse$b = requireLib$2().default;
173617
+ const traverse$b = requireLib$3().default;
173598
173618
  const {
173599
173619
  isObjectExpression,
173600
173620
  isExportDeclaration,