@vercel/next 4.2.0 → 4.2.2

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.
package/dist/index.js CHANGED
@@ -9005,6 +9005,2324 @@ var require_lib3 = __commonJS({
9005
9005
  }
9006
9006
  });
9007
9007
 
9008
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/base64.js
9009
+ var require_base64 = __commonJS({
9010
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/base64.js"(exports) {
9011
+ var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
9012
+ exports.encode = function(number) {
9013
+ if (0 <= number && number < intToCharMap.length) {
9014
+ return intToCharMap[number];
9015
+ }
9016
+ throw new TypeError("Must be between 0 and 63: " + number);
9017
+ };
9018
+ }
9019
+ });
9020
+
9021
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/base64-vlq.js
9022
+ var require_base64_vlq = __commonJS({
9023
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/base64-vlq.js"(exports) {
9024
+ var base64 = require_base64();
9025
+ var VLQ_BASE_SHIFT = 5;
9026
+ var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
9027
+ var VLQ_BASE_MASK = VLQ_BASE - 1;
9028
+ var VLQ_CONTINUATION_BIT = VLQ_BASE;
9029
+ function toVLQSigned(aValue) {
9030
+ return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
9031
+ }
9032
+ exports.encode = function base64VLQ_encode(aValue) {
9033
+ let encoded = "";
9034
+ let digit;
9035
+ let vlq = toVLQSigned(aValue);
9036
+ do {
9037
+ digit = vlq & VLQ_BASE_MASK;
9038
+ vlq >>>= VLQ_BASE_SHIFT;
9039
+ if (vlq > 0) {
9040
+ digit |= VLQ_CONTINUATION_BIT;
9041
+ }
9042
+ encoded += base64.encode(digit);
9043
+ } while (vlq > 0);
9044
+ return encoded;
9045
+ };
9046
+ }
9047
+ });
9048
+
9049
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/util.js
9050
+ var require_util = __commonJS({
9051
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/util.js"(exports) {
9052
+ function getArg(aArgs, aName, aDefaultValue) {
9053
+ if (aName in aArgs) {
9054
+ return aArgs[aName];
9055
+ } else if (arguments.length === 3) {
9056
+ return aDefaultValue;
9057
+ }
9058
+ throw new Error('"' + aName + '" is a required argument.');
9059
+ }
9060
+ exports.getArg = getArg;
9061
+ var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
9062
+ var dataUrlRegexp = /^data:.+\,.+$/;
9063
+ function urlParse(aUrl) {
9064
+ const match = aUrl.match(urlRegexp);
9065
+ if (!match) {
9066
+ return null;
9067
+ }
9068
+ return {
9069
+ scheme: match[1],
9070
+ auth: match[2],
9071
+ host: match[3],
9072
+ port: match[4],
9073
+ path: match[5]
9074
+ };
9075
+ }
9076
+ exports.urlParse = urlParse;
9077
+ function urlGenerate(aParsedUrl) {
9078
+ let url3 = "";
9079
+ if (aParsedUrl.scheme) {
9080
+ url3 += aParsedUrl.scheme + ":";
9081
+ }
9082
+ url3 += "//";
9083
+ if (aParsedUrl.auth) {
9084
+ url3 += aParsedUrl.auth + "@";
9085
+ }
9086
+ if (aParsedUrl.host) {
9087
+ url3 += aParsedUrl.host;
9088
+ }
9089
+ if (aParsedUrl.port) {
9090
+ url3 += ":" + aParsedUrl.port;
9091
+ }
9092
+ if (aParsedUrl.path) {
9093
+ url3 += aParsedUrl.path;
9094
+ }
9095
+ return url3;
9096
+ }
9097
+ exports.urlGenerate = urlGenerate;
9098
+ var MAX_CACHED_INPUTS = 32;
9099
+ function lruMemoize(f) {
9100
+ const cache = [];
9101
+ return function(input) {
9102
+ for (let i = 0; i < cache.length; i++) {
9103
+ if (cache[i].input === input) {
9104
+ const temp = cache[0];
9105
+ cache[0] = cache[i];
9106
+ cache[i] = temp;
9107
+ return cache[0].result;
9108
+ }
9109
+ }
9110
+ const result = f(input);
9111
+ cache.unshift({
9112
+ input,
9113
+ result
9114
+ });
9115
+ if (cache.length > MAX_CACHED_INPUTS) {
9116
+ cache.pop();
9117
+ }
9118
+ return result;
9119
+ };
9120
+ }
9121
+ var normalize = lruMemoize(function normalize2(aPath) {
9122
+ let path5 = aPath;
9123
+ const url3 = urlParse(aPath);
9124
+ if (url3) {
9125
+ if (!url3.path) {
9126
+ return aPath;
9127
+ }
9128
+ path5 = url3.path;
9129
+ }
9130
+ const isAbsolute = exports.isAbsolute(path5);
9131
+ const parts = [];
9132
+ let start = 0;
9133
+ let i = 0;
9134
+ while (true) {
9135
+ start = i;
9136
+ i = path5.indexOf("/", start);
9137
+ if (i === -1) {
9138
+ parts.push(path5.slice(start));
9139
+ break;
9140
+ } else {
9141
+ parts.push(path5.slice(start, i));
9142
+ while (i < path5.length && path5[i] === "/") {
9143
+ i++;
9144
+ }
9145
+ }
9146
+ }
9147
+ let up = 0;
9148
+ for (i = parts.length - 1; i >= 0; i--) {
9149
+ const part = parts[i];
9150
+ if (part === ".") {
9151
+ parts.splice(i, 1);
9152
+ } else if (part === "..") {
9153
+ up++;
9154
+ } else if (up > 0) {
9155
+ if (part === "") {
9156
+ parts.splice(i + 1, up);
9157
+ up = 0;
9158
+ } else {
9159
+ parts.splice(i, 2);
9160
+ up--;
9161
+ }
9162
+ }
9163
+ }
9164
+ path5 = parts.join("/");
9165
+ if (path5 === "") {
9166
+ path5 = isAbsolute ? "/" : ".";
9167
+ }
9168
+ if (url3) {
9169
+ url3.path = path5;
9170
+ return urlGenerate(url3);
9171
+ }
9172
+ return path5;
9173
+ });
9174
+ exports.normalize = normalize;
9175
+ function join2(aRoot, aPath) {
9176
+ if (aRoot === "") {
9177
+ aRoot = ".";
9178
+ }
9179
+ if (aPath === "") {
9180
+ aPath = ".";
9181
+ }
9182
+ const aPathUrl = urlParse(aPath);
9183
+ const aRootUrl = urlParse(aRoot);
9184
+ if (aRootUrl) {
9185
+ aRoot = aRootUrl.path || "/";
9186
+ }
9187
+ if (aPathUrl && !aPathUrl.scheme) {
9188
+ if (aRootUrl) {
9189
+ aPathUrl.scheme = aRootUrl.scheme;
9190
+ }
9191
+ return urlGenerate(aPathUrl);
9192
+ }
9193
+ if (aPathUrl || aPath.match(dataUrlRegexp)) {
9194
+ return aPath;
9195
+ }
9196
+ if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
9197
+ aRootUrl.host = aPath;
9198
+ return urlGenerate(aRootUrl);
9199
+ }
9200
+ const joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
9201
+ if (aRootUrl) {
9202
+ aRootUrl.path = joined;
9203
+ return urlGenerate(aRootUrl);
9204
+ }
9205
+ return joined;
9206
+ }
9207
+ exports.join = join2;
9208
+ exports.isAbsolute = function(aPath) {
9209
+ return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
9210
+ };
9211
+ function relative(aRoot, aPath) {
9212
+ if (aRoot === "") {
9213
+ aRoot = ".";
9214
+ }
9215
+ aRoot = aRoot.replace(/\/$/, "");
9216
+ let level = 0;
9217
+ while (aPath.indexOf(aRoot + "/") !== 0) {
9218
+ const index = aRoot.lastIndexOf("/");
9219
+ if (index < 0) {
9220
+ return aPath;
9221
+ }
9222
+ aRoot = aRoot.slice(0, index);
9223
+ if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
9224
+ return aPath;
9225
+ }
9226
+ ++level;
9227
+ }
9228
+ return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
9229
+ }
9230
+ exports.relative = relative;
9231
+ var supportsNullProto = function() {
9232
+ const obj = /* @__PURE__ */ Object.create(null);
9233
+ return !("__proto__" in obj);
9234
+ }();
9235
+ function identity(s) {
9236
+ return s;
9237
+ }
9238
+ function toSetString(aStr) {
9239
+ if (isProtoString(aStr)) {
9240
+ return "$" + aStr;
9241
+ }
9242
+ return aStr;
9243
+ }
9244
+ exports.toSetString = supportsNullProto ? identity : toSetString;
9245
+ function fromSetString(aStr) {
9246
+ if (isProtoString(aStr)) {
9247
+ return aStr.slice(1);
9248
+ }
9249
+ return aStr;
9250
+ }
9251
+ exports.fromSetString = supportsNullProto ? identity : fromSetString;
9252
+ function isProtoString(s) {
9253
+ if (!s) {
9254
+ return false;
9255
+ }
9256
+ const length = s.length;
9257
+ if (length < 9) {
9258
+ return false;
9259
+ }
9260
+ if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
9261
+ return false;
9262
+ }
9263
+ for (let i = length - 10; i >= 0; i--) {
9264
+ if (s.charCodeAt(i) !== 36) {
9265
+ return false;
9266
+ }
9267
+ }
9268
+ return true;
9269
+ }
9270
+ function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
9271
+ let cmp = strcmp(mappingA.source, mappingB.source);
9272
+ if (cmp !== 0) {
9273
+ return cmp;
9274
+ }
9275
+ cmp = mappingA.originalLine - mappingB.originalLine;
9276
+ if (cmp !== 0) {
9277
+ return cmp;
9278
+ }
9279
+ cmp = mappingA.originalColumn - mappingB.originalColumn;
9280
+ if (cmp !== 0 || onlyCompareOriginal) {
9281
+ return cmp;
9282
+ }
9283
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn;
9284
+ if (cmp !== 0) {
9285
+ return cmp;
9286
+ }
9287
+ cmp = mappingA.generatedLine - mappingB.generatedLine;
9288
+ if (cmp !== 0) {
9289
+ return cmp;
9290
+ }
9291
+ return strcmp(mappingA.name, mappingB.name);
9292
+ }
9293
+ exports.compareByOriginalPositions = compareByOriginalPositions;
9294
+ function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
9295
+ let cmp = mappingA.generatedLine - mappingB.generatedLine;
9296
+ if (cmp !== 0) {
9297
+ return cmp;
9298
+ }
9299
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn;
9300
+ if (cmp !== 0 || onlyCompareGenerated) {
9301
+ return cmp;
9302
+ }
9303
+ cmp = strcmp(mappingA.source, mappingB.source);
9304
+ if (cmp !== 0) {
9305
+ return cmp;
9306
+ }
9307
+ cmp = mappingA.originalLine - mappingB.originalLine;
9308
+ if (cmp !== 0) {
9309
+ return cmp;
9310
+ }
9311
+ cmp = mappingA.originalColumn - mappingB.originalColumn;
9312
+ if (cmp !== 0) {
9313
+ return cmp;
9314
+ }
9315
+ return strcmp(mappingA.name, mappingB.name);
9316
+ }
9317
+ exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
9318
+ function strcmp(aStr1, aStr2) {
9319
+ if (aStr1 === aStr2) {
9320
+ return 0;
9321
+ }
9322
+ if (aStr1 === null) {
9323
+ return 1;
9324
+ }
9325
+ if (aStr2 === null) {
9326
+ return -1;
9327
+ }
9328
+ if (aStr1 > aStr2) {
9329
+ return 1;
9330
+ }
9331
+ return -1;
9332
+ }
9333
+ function compareByGeneratedPositionsInflated(mappingA, mappingB) {
9334
+ let cmp = mappingA.generatedLine - mappingB.generatedLine;
9335
+ if (cmp !== 0) {
9336
+ return cmp;
9337
+ }
9338
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn;
9339
+ if (cmp !== 0) {
9340
+ return cmp;
9341
+ }
9342
+ cmp = strcmp(mappingA.source, mappingB.source);
9343
+ if (cmp !== 0) {
9344
+ return cmp;
9345
+ }
9346
+ cmp = mappingA.originalLine - mappingB.originalLine;
9347
+ if (cmp !== 0) {
9348
+ return cmp;
9349
+ }
9350
+ cmp = mappingA.originalColumn - mappingB.originalColumn;
9351
+ if (cmp !== 0) {
9352
+ return cmp;
9353
+ }
9354
+ return strcmp(mappingA.name, mappingB.name);
9355
+ }
9356
+ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
9357
+ function parseSourceMapInput(str) {
9358
+ return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
9359
+ }
9360
+ exports.parseSourceMapInput = parseSourceMapInput;
9361
+ function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
9362
+ sourceURL = sourceURL || "";
9363
+ if (sourceRoot) {
9364
+ if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
9365
+ sourceRoot += "/";
9366
+ }
9367
+ sourceURL = sourceRoot + sourceURL;
9368
+ }
9369
+ if (sourceMapURL) {
9370
+ const parsed = urlParse(sourceMapURL);
9371
+ if (!parsed) {
9372
+ throw new Error("sourceMapURL could not be parsed");
9373
+ }
9374
+ if (parsed.path) {
9375
+ const index = parsed.path.lastIndexOf("/");
9376
+ if (index >= 0) {
9377
+ parsed.path = parsed.path.substring(0, index + 1);
9378
+ }
9379
+ }
9380
+ sourceURL = join2(urlGenerate(parsed), sourceURL);
9381
+ }
9382
+ return normalize(sourceURL);
9383
+ }
9384
+ exports.computeSourceURL = computeSourceURL;
9385
+ }
9386
+ });
9387
+
9388
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/array-set.js
9389
+ var require_array_set = __commonJS({
9390
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/array-set.js"(exports) {
9391
+ var ArraySet = class _ArraySet {
9392
+ constructor() {
9393
+ this._array = [];
9394
+ this._set = /* @__PURE__ */ new Map();
9395
+ }
9396
+ /**
9397
+ * Static method for creating ArraySet instances from an existing array.
9398
+ */
9399
+ static fromArray(aArray, aAllowDuplicates) {
9400
+ const set = new _ArraySet();
9401
+ for (let i = 0, len = aArray.length; i < len; i++) {
9402
+ set.add(aArray[i], aAllowDuplicates);
9403
+ }
9404
+ return set;
9405
+ }
9406
+ /**
9407
+ * Return how many unique items are in this ArraySet. If duplicates have been
9408
+ * added, than those do not count towards the size.
9409
+ *
9410
+ * @returns Number
9411
+ */
9412
+ size() {
9413
+ return this._set.size;
9414
+ }
9415
+ /**
9416
+ * Add the given string to this set.
9417
+ *
9418
+ * @param String aStr
9419
+ */
9420
+ add(aStr, aAllowDuplicates) {
9421
+ const isDuplicate = this.has(aStr);
9422
+ const idx = this._array.length;
9423
+ if (!isDuplicate || aAllowDuplicates) {
9424
+ this._array.push(aStr);
9425
+ }
9426
+ if (!isDuplicate) {
9427
+ this._set.set(aStr, idx);
9428
+ }
9429
+ }
9430
+ /**
9431
+ * Is the given string a member of this set?
9432
+ *
9433
+ * @param String aStr
9434
+ */
9435
+ has(aStr) {
9436
+ return this._set.has(aStr);
9437
+ }
9438
+ /**
9439
+ * What is the index of the given string in the array?
9440
+ *
9441
+ * @param String aStr
9442
+ */
9443
+ indexOf(aStr) {
9444
+ const idx = this._set.get(aStr);
9445
+ if (idx >= 0) {
9446
+ return idx;
9447
+ }
9448
+ throw new Error('"' + aStr + '" is not in the set.');
9449
+ }
9450
+ /**
9451
+ * What is the element at the given index?
9452
+ *
9453
+ * @param Number aIdx
9454
+ */
9455
+ at(aIdx) {
9456
+ if (aIdx >= 0 && aIdx < this._array.length) {
9457
+ return this._array[aIdx];
9458
+ }
9459
+ throw new Error("No element indexed by " + aIdx);
9460
+ }
9461
+ /**
9462
+ * Returns the array representation of this set (which has the proper indices
9463
+ * indicated by indexOf). Note that this is a copy of the internal array used
9464
+ * for storing the members so that no one can mess with internal state.
9465
+ */
9466
+ toArray() {
9467
+ return this._array.slice();
9468
+ }
9469
+ };
9470
+ exports.ArraySet = ArraySet;
9471
+ }
9472
+ });
9473
+
9474
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/mapping-list.js
9475
+ var require_mapping_list = __commonJS({
9476
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/mapping-list.js"(exports) {
9477
+ var util = require_util();
9478
+ function generatedPositionAfter(mappingA, mappingB) {
9479
+ const lineA = mappingA.generatedLine;
9480
+ const lineB = mappingB.generatedLine;
9481
+ const columnA = mappingA.generatedColumn;
9482
+ const columnB = mappingB.generatedColumn;
9483
+ return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
9484
+ }
9485
+ var MappingList = class {
9486
+ constructor() {
9487
+ this._array = [];
9488
+ this._sorted = true;
9489
+ this._last = { generatedLine: -1, generatedColumn: 0 };
9490
+ }
9491
+ /**
9492
+ * Iterate through internal items. This method takes the same arguments that
9493
+ * `Array.prototype.forEach` takes.
9494
+ *
9495
+ * NOTE: The order of the mappings is NOT guaranteed.
9496
+ */
9497
+ unsortedForEach(aCallback, aThisArg) {
9498
+ this._array.forEach(aCallback, aThisArg);
9499
+ }
9500
+ /**
9501
+ * Add the given source mapping.
9502
+ *
9503
+ * @param Object aMapping
9504
+ */
9505
+ add(aMapping) {
9506
+ if (generatedPositionAfter(this._last, aMapping)) {
9507
+ this._last = aMapping;
9508
+ this._array.push(aMapping);
9509
+ } else {
9510
+ this._sorted = false;
9511
+ this._array.push(aMapping);
9512
+ }
9513
+ }
9514
+ /**
9515
+ * Returns the flat, sorted array of mappings. The mappings are sorted by
9516
+ * generated position.
9517
+ *
9518
+ * WARNING: This method returns internal data without copying, for
9519
+ * performance. The return value must NOT be mutated, and should be treated as
9520
+ * an immutable borrow. If you want to take ownership, you must make your own
9521
+ * copy.
9522
+ */
9523
+ toArray() {
9524
+ if (!this._sorted) {
9525
+ this._array.sort(util.compareByGeneratedPositionsInflated);
9526
+ this._sorted = true;
9527
+ }
9528
+ return this._array;
9529
+ }
9530
+ };
9531
+ exports.MappingList = MappingList;
9532
+ }
9533
+ });
9534
+
9535
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/source-map-generator.js
9536
+ var require_source_map_generator = __commonJS({
9537
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/source-map-generator.js"(exports) {
9538
+ var base64VLQ = require_base64_vlq();
9539
+ var util = require_util();
9540
+ var ArraySet = require_array_set().ArraySet;
9541
+ var MappingList = require_mapping_list().MappingList;
9542
+ var SourceMapGenerator2 = class _SourceMapGenerator {
9543
+ constructor(aArgs) {
9544
+ if (!aArgs) {
9545
+ aArgs = {};
9546
+ }
9547
+ this._file = util.getArg(aArgs, "file", null);
9548
+ this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
9549
+ this._skipValidation = util.getArg(aArgs, "skipValidation", false);
9550
+ this._sources = new ArraySet();
9551
+ this._names = new ArraySet();
9552
+ this._mappings = new MappingList();
9553
+ this._sourcesContents = null;
9554
+ }
9555
+ /**
9556
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
9557
+ *
9558
+ * @param aSourceMapConsumer The SourceMap.
9559
+ */
9560
+ static fromSourceMap(aSourceMapConsumer) {
9561
+ const sourceRoot = aSourceMapConsumer.sourceRoot;
9562
+ const generator = new _SourceMapGenerator({
9563
+ file: aSourceMapConsumer.file,
9564
+ sourceRoot
9565
+ });
9566
+ aSourceMapConsumer.eachMapping(function(mapping) {
9567
+ const newMapping = {
9568
+ generated: {
9569
+ line: mapping.generatedLine,
9570
+ column: mapping.generatedColumn
9571
+ }
9572
+ };
9573
+ if (mapping.source != null) {
9574
+ newMapping.source = mapping.source;
9575
+ if (sourceRoot != null) {
9576
+ newMapping.source = util.relative(sourceRoot, newMapping.source);
9577
+ }
9578
+ newMapping.original = {
9579
+ line: mapping.originalLine,
9580
+ column: mapping.originalColumn
9581
+ };
9582
+ if (mapping.name != null) {
9583
+ newMapping.name = mapping.name;
9584
+ }
9585
+ }
9586
+ generator.addMapping(newMapping);
9587
+ });
9588
+ aSourceMapConsumer.sources.forEach(function(sourceFile) {
9589
+ let sourceRelative = sourceFile;
9590
+ if (sourceRoot !== null) {
9591
+ sourceRelative = util.relative(sourceRoot, sourceFile);
9592
+ }
9593
+ if (!generator._sources.has(sourceRelative)) {
9594
+ generator._sources.add(sourceRelative);
9595
+ }
9596
+ const content = aSourceMapConsumer.sourceContentFor(sourceFile);
9597
+ if (content != null) {
9598
+ generator.setSourceContent(sourceFile, content);
9599
+ }
9600
+ });
9601
+ return generator;
9602
+ }
9603
+ /**
9604
+ * Add a single mapping from original source line and column to the generated
9605
+ * source's line and column for this source map being created. The mapping
9606
+ * object should have the following properties:
9607
+ *
9608
+ * - generated: An object with the generated line and column positions.
9609
+ * - original: An object with the original line and column positions.
9610
+ * - source: The original source file (relative to the sourceRoot).
9611
+ * - name: An optional original token name for this mapping.
9612
+ */
9613
+ addMapping(aArgs) {
9614
+ const generated = util.getArg(aArgs, "generated");
9615
+ const original = util.getArg(aArgs, "original", null);
9616
+ let source = util.getArg(aArgs, "source", null);
9617
+ let name = util.getArg(aArgs, "name", null);
9618
+ if (!this._skipValidation) {
9619
+ this._validateMapping(generated, original, source, name);
9620
+ }
9621
+ if (source != null) {
9622
+ source = String(source);
9623
+ if (!this._sources.has(source)) {
9624
+ this._sources.add(source);
9625
+ }
9626
+ }
9627
+ if (name != null) {
9628
+ name = String(name);
9629
+ if (!this._names.has(name)) {
9630
+ this._names.add(name);
9631
+ }
9632
+ }
9633
+ this._mappings.add({
9634
+ generatedLine: generated.line,
9635
+ generatedColumn: generated.column,
9636
+ originalLine: original != null && original.line,
9637
+ originalColumn: original != null && original.column,
9638
+ source,
9639
+ name
9640
+ });
9641
+ }
9642
+ /**
9643
+ * Set the source content for a source file.
9644
+ */
9645
+ setSourceContent(aSourceFile, aSourceContent) {
9646
+ let source = aSourceFile;
9647
+ if (this._sourceRoot != null) {
9648
+ source = util.relative(this._sourceRoot, source);
9649
+ }
9650
+ if (aSourceContent != null) {
9651
+ if (!this._sourcesContents) {
9652
+ this._sourcesContents = /* @__PURE__ */ Object.create(null);
9653
+ }
9654
+ this._sourcesContents[util.toSetString(source)] = aSourceContent;
9655
+ } else if (this._sourcesContents) {
9656
+ delete this._sourcesContents[util.toSetString(source)];
9657
+ if (Object.keys(this._sourcesContents).length === 0) {
9658
+ this._sourcesContents = null;
9659
+ }
9660
+ }
9661
+ }
9662
+ /**
9663
+ * Applies the mappings of a sub-source-map for a specific source file to the
9664
+ * source map being generated. Each mapping to the supplied source file is
9665
+ * rewritten using the supplied source map. Note: The resolution for the
9666
+ * resulting mappings is the minimium of this map and the supplied map.
9667
+ *
9668
+ * @param aSourceMapConsumer The source map to be applied.
9669
+ * @param aSourceFile Optional. The filename of the source file.
9670
+ * If omitted, SourceMapConsumer's file property will be used.
9671
+ * @param aSourceMapPath Optional. The dirname of the path to the source map
9672
+ * to be applied. If relative, it is relative to the SourceMapConsumer.
9673
+ * This parameter is needed when the two source maps aren't in the same
9674
+ * directory, and the source map to be applied contains relative source
9675
+ * paths. If so, those relative source paths need to be rewritten
9676
+ * relative to the SourceMapGenerator.
9677
+ */
9678
+ applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
9679
+ let sourceFile = aSourceFile;
9680
+ if (aSourceFile == null) {
9681
+ if (aSourceMapConsumer.file == null) {
9682
+ throw new Error(
9683
+ `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`
9684
+ );
9685
+ }
9686
+ sourceFile = aSourceMapConsumer.file;
9687
+ }
9688
+ const sourceRoot = this._sourceRoot;
9689
+ if (sourceRoot != null) {
9690
+ sourceFile = util.relative(sourceRoot, sourceFile);
9691
+ }
9692
+ const newSources = this._mappings.toArray().length > 0 ? new ArraySet() : this._sources;
9693
+ const newNames = new ArraySet();
9694
+ this._mappings.unsortedForEach(function(mapping) {
9695
+ if (mapping.source === sourceFile && mapping.originalLine != null) {
9696
+ const original = aSourceMapConsumer.originalPositionFor({
9697
+ line: mapping.originalLine,
9698
+ column: mapping.originalColumn
9699
+ });
9700
+ if (original.source != null) {
9701
+ mapping.source = original.source;
9702
+ if (aSourceMapPath != null) {
9703
+ mapping.source = util.join(aSourceMapPath, mapping.source);
9704
+ }
9705
+ if (sourceRoot != null) {
9706
+ mapping.source = util.relative(sourceRoot, mapping.source);
9707
+ }
9708
+ mapping.originalLine = original.line;
9709
+ mapping.originalColumn = original.column;
9710
+ if (original.name != null) {
9711
+ mapping.name = original.name;
9712
+ }
9713
+ }
9714
+ }
9715
+ const source = mapping.source;
9716
+ if (source != null && !newSources.has(source)) {
9717
+ newSources.add(source);
9718
+ }
9719
+ const name = mapping.name;
9720
+ if (name != null && !newNames.has(name)) {
9721
+ newNames.add(name);
9722
+ }
9723
+ }, this);
9724
+ this._sources = newSources;
9725
+ this._names = newNames;
9726
+ aSourceMapConsumer.sources.forEach(function(srcFile) {
9727
+ const content = aSourceMapConsumer.sourceContentFor(srcFile);
9728
+ if (content != null) {
9729
+ if (aSourceMapPath != null) {
9730
+ srcFile = util.join(aSourceMapPath, srcFile);
9731
+ }
9732
+ if (sourceRoot != null) {
9733
+ srcFile = util.relative(sourceRoot, srcFile);
9734
+ }
9735
+ this.setSourceContent(srcFile, content);
9736
+ }
9737
+ }, this);
9738
+ }
9739
+ /**
9740
+ * A mapping can have one of the three levels of data:
9741
+ *
9742
+ * 1. Just the generated position.
9743
+ * 2. The Generated position, original position, and original source.
9744
+ * 3. Generated and original position, original source, as well as a name
9745
+ * token.
9746
+ *
9747
+ * To maintain consistency, we validate that any new mapping being added falls
9748
+ * in to one of these categories.
9749
+ */
9750
+ _validateMapping(aGenerated, aOriginal, aSource, aName) {
9751
+ if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
9752
+ throw new Error(
9753
+ "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values."
9754
+ );
9755
+ }
9756
+ if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
9757
+ } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
9758
+ } else {
9759
+ throw new Error("Invalid mapping: " + JSON.stringify({
9760
+ generated: aGenerated,
9761
+ source: aSource,
9762
+ original: aOriginal,
9763
+ name: aName
9764
+ }));
9765
+ }
9766
+ }
9767
+ /**
9768
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
9769
+ * specified by the source map format.
9770
+ */
9771
+ _serializeMappings() {
9772
+ let previousGeneratedColumn = 0;
9773
+ let previousGeneratedLine = 1;
9774
+ let previousOriginalColumn = 0;
9775
+ let previousOriginalLine = 0;
9776
+ let previousName = 0;
9777
+ let previousSource = 0;
9778
+ let result = "";
9779
+ let next;
9780
+ let mapping;
9781
+ let nameIdx;
9782
+ let sourceIdx;
9783
+ const mappings = this._mappings.toArray();
9784
+ for (let i = 0, len = mappings.length; i < len; i++) {
9785
+ mapping = mappings[i];
9786
+ next = "";
9787
+ if (mapping.generatedLine !== previousGeneratedLine) {
9788
+ previousGeneratedColumn = 0;
9789
+ while (mapping.generatedLine !== previousGeneratedLine) {
9790
+ next += ";";
9791
+ previousGeneratedLine++;
9792
+ }
9793
+ } else if (i > 0) {
9794
+ if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
9795
+ continue;
9796
+ }
9797
+ next += ",";
9798
+ }
9799
+ next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
9800
+ previousGeneratedColumn = mapping.generatedColumn;
9801
+ if (mapping.source != null) {
9802
+ sourceIdx = this._sources.indexOf(mapping.source);
9803
+ next += base64VLQ.encode(sourceIdx - previousSource);
9804
+ previousSource = sourceIdx;
9805
+ next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
9806
+ previousOriginalLine = mapping.originalLine - 1;
9807
+ next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
9808
+ previousOriginalColumn = mapping.originalColumn;
9809
+ if (mapping.name != null) {
9810
+ nameIdx = this._names.indexOf(mapping.name);
9811
+ next += base64VLQ.encode(nameIdx - previousName);
9812
+ previousName = nameIdx;
9813
+ }
9814
+ }
9815
+ result += next;
9816
+ }
9817
+ return result;
9818
+ }
9819
+ _generateSourcesContent(aSources, aSourceRoot) {
9820
+ return aSources.map(function(source) {
9821
+ if (!this._sourcesContents) {
9822
+ return null;
9823
+ }
9824
+ if (aSourceRoot != null) {
9825
+ source = util.relative(aSourceRoot, source);
9826
+ }
9827
+ const key = util.toSetString(source);
9828
+ return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
9829
+ }, this);
9830
+ }
9831
+ /**
9832
+ * Externalize the source map.
9833
+ */
9834
+ toJSON() {
9835
+ const map = {
9836
+ version: this._version,
9837
+ sources: this._sources.toArray(),
9838
+ names: this._names.toArray(),
9839
+ mappings: this._serializeMappings()
9840
+ };
9841
+ if (this._file != null) {
9842
+ map.file = this._file;
9843
+ }
9844
+ if (this._sourceRoot != null) {
9845
+ map.sourceRoot = this._sourceRoot;
9846
+ }
9847
+ if (this._sourcesContents) {
9848
+ map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
9849
+ }
9850
+ return map;
9851
+ }
9852
+ /**
9853
+ * Render the source map being generated to a string.
9854
+ */
9855
+ toString() {
9856
+ return JSON.stringify(this.toJSON());
9857
+ }
9858
+ };
9859
+ SourceMapGenerator2.prototype._version = 3;
9860
+ exports.SourceMapGenerator = SourceMapGenerator2;
9861
+ }
9862
+ });
9863
+
9864
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/binary-search.js
9865
+ var require_binary_search = __commonJS({
9866
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/binary-search.js"(exports) {
9867
+ exports.GREATEST_LOWER_BOUND = 1;
9868
+ exports.LEAST_UPPER_BOUND = 2;
9869
+ function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
9870
+ const mid = Math.floor((aHigh - aLow) / 2) + aLow;
9871
+ const cmp = aCompare(aNeedle, aHaystack[mid], true);
9872
+ if (cmp === 0) {
9873
+ return mid;
9874
+ } else if (cmp > 0) {
9875
+ if (aHigh - mid > 1) {
9876
+ return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
9877
+ }
9878
+ if (aBias == exports.LEAST_UPPER_BOUND) {
9879
+ return aHigh < aHaystack.length ? aHigh : -1;
9880
+ }
9881
+ return mid;
9882
+ }
9883
+ if (mid - aLow > 1) {
9884
+ return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
9885
+ }
9886
+ if (aBias == exports.LEAST_UPPER_BOUND) {
9887
+ return mid;
9888
+ }
9889
+ return aLow < 0 ? -1 : aLow;
9890
+ }
9891
+ exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
9892
+ if (aHaystack.length === 0) {
9893
+ return -1;
9894
+ }
9895
+ let index = recursiveSearch(
9896
+ -1,
9897
+ aHaystack.length,
9898
+ aNeedle,
9899
+ aHaystack,
9900
+ aCompare,
9901
+ aBias || exports.GREATEST_LOWER_BOUND
9902
+ );
9903
+ if (index < 0) {
9904
+ return -1;
9905
+ }
9906
+ while (index - 1 >= 0) {
9907
+ if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
9908
+ break;
9909
+ }
9910
+ --index;
9911
+ }
9912
+ return index;
9913
+ };
9914
+ }
9915
+ });
9916
+
9917
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/read-wasm.js
9918
+ var require_read_wasm = __commonJS({
9919
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/read-wasm.js"(exports, module2) {
9920
+ var isBrowserEnvironment = function() {
9921
+ return typeof window !== "undefined" && this === window;
9922
+ }.call();
9923
+ if (isBrowserEnvironment) {
9924
+ let mappingsWasm = null;
9925
+ module2.exports = function readWasm() {
9926
+ if (typeof mappingsWasm === "string") {
9927
+ return fetch(mappingsWasm).then((response) => response.arrayBuffer());
9928
+ }
9929
+ if (mappingsWasm instanceof ArrayBuffer) {
9930
+ return Promise.resolve(mappingsWasm);
9931
+ }
9932
+ throw new Error("You must provide the string URL or ArrayBuffer contents of lib/mappings.wasm by calling SourceMapConsumer.initialize({ 'lib/mappings.wasm': ... }) before using SourceMapConsumer");
9933
+ };
9934
+ module2.exports.initialize = (input) => mappingsWasm = input;
9935
+ } else {
9936
+ const fs5 = require("fs");
9937
+ const path5 = require("path");
9938
+ module2.exports = function readWasm() {
9939
+ return new Promise((resolve, reject) => {
9940
+ const wasmPath = path5.join(__dirname, "mappings.wasm");
9941
+ fs5.readFile(wasmPath, null, (error, data) => {
9942
+ if (error) {
9943
+ reject(error);
9944
+ return;
9945
+ }
9946
+ resolve(data.buffer);
9947
+ });
9948
+ });
9949
+ };
9950
+ module2.exports.initialize = (_) => {
9951
+ console.debug("SourceMapConsumer.initialize is a no-op when running in node.js");
9952
+ };
9953
+ }
9954
+ }
9955
+ });
9956
+
9957
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/wasm.js
9958
+ var require_wasm = __commonJS({
9959
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/wasm.js"(exports, module2) {
9960
+ var readWasm = require_read_wasm();
9961
+ function Mapping() {
9962
+ this.generatedLine = 0;
9963
+ this.generatedColumn = 0;
9964
+ this.lastGeneratedColumn = null;
9965
+ this.source = null;
9966
+ this.originalLine = null;
9967
+ this.originalColumn = null;
9968
+ this.name = null;
9969
+ }
9970
+ var cachedWasm = null;
9971
+ module2.exports = function wasm() {
9972
+ if (cachedWasm) {
9973
+ return cachedWasm;
9974
+ }
9975
+ const callbackStack = [];
9976
+ cachedWasm = readWasm().then((buffer) => {
9977
+ return WebAssembly.instantiate(buffer, {
9978
+ env: {
9979
+ mapping_callback(generatedLine, generatedColumn, hasLastGeneratedColumn, lastGeneratedColumn, hasOriginal, source, originalLine, originalColumn, hasName, name) {
9980
+ const mapping = new Mapping();
9981
+ mapping.generatedLine = generatedLine + 1;
9982
+ mapping.generatedColumn = generatedColumn;
9983
+ if (hasLastGeneratedColumn) {
9984
+ mapping.lastGeneratedColumn = lastGeneratedColumn - 1;
9985
+ }
9986
+ if (hasOriginal) {
9987
+ mapping.source = source;
9988
+ mapping.originalLine = originalLine + 1;
9989
+ mapping.originalColumn = originalColumn;
9990
+ if (hasName) {
9991
+ mapping.name = name;
9992
+ }
9993
+ }
9994
+ callbackStack[callbackStack.length - 1](mapping);
9995
+ },
9996
+ start_all_generated_locations_for() {
9997
+ console.time("all_generated_locations_for");
9998
+ },
9999
+ end_all_generated_locations_for() {
10000
+ console.timeEnd("all_generated_locations_for");
10001
+ },
10002
+ start_compute_column_spans() {
10003
+ console.time("compute_column_spans");
10004
+ },
10005
+ end_compute_column_spans() {
10006
+ console.timeEnd("compute_column_spans");
10007
+ },
10008
+ start_generated_location_for() {
10009
+ console.time("generated_location_for");
10010
+ },
10011
+ end_generated_location_for() {
10012
+ console.timeEnd("generated_location_for");
10013
+ },
10014
+ start_original_location_for() {
10015
+ console.time("original_location_for");
10016
+ },
10017
+ end_original_location_for() {
10018
+ console.timeEnd("original_location_for");
10019
+ },
10020
+ start_parse_mappings() {
10021
+ console.time("parse_mappings");
10022
+ },
10023
+ end_parse_mappings() {
10024
+ console.timeEnd("parse_mappings");
10025
+ },
10026
+ start_sort_by_generated_location() {
10027
+ console.time("sort_by_generated_location");
10028
+ },
10029
+ end_sort_by_generated_location() {
10030
+ console.timeEnd("sort_by_generated_location");
10031
+ },
10032
+ start_sort_by_original_location() {
10033
+ console.time("sort_by_original_location");
10034
+ },
10035
+ end_sort_by_original_location() {
10036
+ console.timeEnd("sort_by_original_location");
10037
+ }
10038
+ }
10039
+ });
10040
+ }).then((Wasm) => {
10041
+ return {
10042
+ exports: Wasm.instance.exports,
10043
+ withMappingCallback: (mappingCallback, f) => {
10044
+ callbackStack.push(mappingCallback);
10045
+ try {
10046
+ f();
10047
+ } finally {
10048
+ callbackStack.pop();
10049
+ }
10050
+ }
10051
+ };
10052
+ }).then(null, (e) => {
10053
+ cachedWasm = null;
10054
+ throw e;
10055
+ });
10056
+ return cachedWasm;
10057
+ };
10058
+ }
10059
+ });
10060
+
10061
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/source-map-consumer.js
10062
+ var require_source_map_consumer = __commonJS({
10063
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/source-map-consumer.js"(exports) {
10064
+ var util = require_util();
10065
+ var binarySearch = require_binary_search();
10066
+ var ArraySet = require_array_set().ArraySet;
10067
+ var base64VLQ = require_base64_vlq();
10068
+ var readWasm = require_read_wasm();
10069
+ var wasm = require_wasm();
10070
+ var INTERNAL = Symbol("smcInternal");
10071
+ var SourceMapConsumer2 = class _SourceMapConsumer {
10072
+ constructor(aSourceMap, aSourceMapURL) {
10073
+ if (aSourceMap == INTERNAL) {
10074
+ return Promise.resolve(this);
10075
+ }
10076
+ return _factory(aSourceMap, aSourceMapURL);
10077
+ }
10078
+ static initialize(opts) {
10079
+ readWasm.initialize(opts["lib/mappings.wasm"]);
10080
+ }
10081
+ static fromSourceMap(aSourceMap, aSourceMapURL) {
10082
+ return _factoryBSM(aSourceMap, aSourceMapURL);
10083
+ }
10084
+ /**
10085
+ * Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
10086
+ * (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
10087
+ * function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
10088
+ * for `f` to complete, call `destroy` on the consumer, and return `f`'s return
10089
+ * value.
10090
+ *
10091
+ * You must not use the consumer after `f` completes!
10092
+ *
10093
+ * By using `with`, you do not have to remember to manually call `destroy` on
10094
+ * the consumer, since it will be called automatically once `f` completes.
10095
+ *
10096
+ * ```js
10097
+ * const xSquared = await SourceMapConsumer.with(
10098
+ * myRawSourceMap,
10099
+ * null,
10100
+ * async function (consumer) {
10101
+ * // Use `consumer` inside here and don't worry about remembering
10102
+ * // to call `destroy`.
10103
+ *
10104
+ * const x = await whatever(consumer);
10105
+ * return x * x;
10106
+ * }
10107
+ * );
10108
+ *
10109
+ * // You may not use that `consumer` anymore out here; it has
10110
+ * // been destroyed. But you can use `xSquared`.
10111
+ * console.log(xSquared);
10112
+ * ```
10113
+ */
10114
+ static async with(rawSourceMap, sourceMapUrl, f) {
10115
+ const consumer = await new _SourceMapConsumer(rawSourceMap, sourceMapUrl);
10116
+ try {
10117
+ return await f(consumer);
10118
+ } finally {
10119
+ consumer.destroy();
10120
+ }
10121
+ }
10122
+ /**
10123
+ * Parse the mappings in a string in to a data structure which we can easily
10124
+ * query (the ordered arrays in the `this.__generatedMappings` and
10125
+ * `this.__originalMappings` properties).
10126
+ */
10127
+ _parseMappings(aStr, aSourceRoot) {
10128
+ throw new Error("Subclasses must implement _parseMappings");
10129
+ }
10130
+ /**
10131
+ * Iterate over each mapping between an original source/line/column and a
10132
+ * generated line/column in this source map.
10133
+ *
10134
+ * @param Function aCallback
10135
+ * The function that is called with each mapping.
10136
+ * @param Object aContext
10137
+ * Optional. If specified, this object will be the value of `this` every
10138
+ * time that `aCallback` is called.
10139
+ * @param aOrder
10140
+ * Either `SourceMapConsumer.GENERATED_ORDER` or
10141
+ * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
10142
+ * iterate over the mappings sorted by the generated file's line/column
10143
+ * order or the original's source/line/column order, respectively. Defaults to
10144
+ * `SourceMapConsumer.GENERATED_ORDER`.
10145
+ */
10146
+ eachMapping(aCallback, aContext, aOrder) {
10147
+ throw new Error("Subclasses must implement eachMapping");
10148
+ }
10149
+ /**
10150
+ * Returns all generated line and column information for the original source,
10151
+ * line, and column provided. If no column is provided, returns all mappings
10152
+ * corresponding to a either the line we are searching for or the next
10153
+ * closest line that has any mappings. Otherwise, returns all mappings
10154
+ * corresponding to the given line and either the column we are searching for
10155
+ * or the next closest column that has any offsets.
10156
+ *
10157
+ * The only argument is an object with the following properties:
10158
+ *
10159
+ * - source: The filename of the original source.
10160
+ * - line: The line number in the original source. The line number is 1-based.
10161
+ * - column: Optional. the column number in the original source.
10162
+ * The column number is 0-based.
10163
+ *
10164
+ * and an array of objects is returned, each with the following properties:
10165
+ *
10166
+ * - line: The line number in the generated source, or null. The
10167
+ * line number is 1-based.
10168
+ * - column: The column number in the generated source, or null.
10169
+ * The column number is 0-based.
10170
+ */
10171
+ allGeneratedPositionsFor(aArgs) {
10172
+ throw new Error("Subclasses must implement allGeneratedPositionsFor");
10173
+ }
10174
+ destroy() {
10175
+ throw new Error("Subclasses must implement destroy");
10176
+ }
10177
+ };
10178
+ SourceMapConsumer2.prototype._version = 3;
10179
+ SourceMapConsumer2.GENERATED_ORDER = 1;
10180
+ SourceMapConsumer2.ORIGINAL_ORDER = 2;
10181
+ SourceMapConsumer2.GREATEST_LOWER_BOUND = 1;
10182
+ SourceMapConsumer2.LEAST_UPPER_BOUND = 2;
10183
+ exports.SourceMapConsumer = SourceMapConsumer2;
10184
+ var BasicSourceMapConsumer = class _BasicSourceMapConsumer extends SourceMapConsumer2 {
10185
+ constructor(aSourceMap, aSourceMapURL) {
10186
+ return super(INTERNAL).then((that) => {
10187
+ let sourceMap = aSourceMap;
10188
+ if (typeof aSourceMap === "string") {
10189
+ sourceMap = util.parseSourceMapInput(aSourceMap);
10190
+ }
10191
+ const version2 = util.getArg(sourceMap, "version");
10192
+ let sources = util.getArg(sourceMap, "sources");
10193
+ const names = util.getArg(sourceMap, "names", []);
10194
+ let sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
10195
+ const sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
10196
+ const mappings = util.getArg(sourceMap, "mappings");
10197
+ const file = util.getArg(sourceMap, "file", null);
10198
+ if (version2 != that._version) {
10199
+ throw new Error("Unsupported version: " + version2);
10200
+ }
10201
+ if (sourceRoot) {
10202
+ sourceRoot = util.normalize(sourceRoot);
10203
+ }
10204
+ sources = sources.map(String).map(util.normalize).map(function(source) {
10205
+ return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
10206
+ });
10207
+ that._names = ArraySet.fromArray(names.map(String), true);
10208
+ that._sources = ArraySet.fromArray(sources, true);
10209
+ that._absoluteSources = that._sources.toArray().map(function(s) {
10210
+ return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
10211
+ });
10212
+ that.sourceRoot = sourceRoot;
10213
+ that.sourcesContent = sourcesContent;
10214
+ that._mappings = mappings;
10215
+ that._sourceMapURL = aSourceMapURL;
10216
+ that.file = file;
10217
+ that._computedColumnSpans = false;
10218
+ that._mappingsPtr = 0;
10219
+ that._wasm = null;
10220
+ return wasm().then((w) => {
10221
+ that._wasm = w;
10222
+ return that;
10223
+ });
10224
+ });
10225
+ }
10226
+ /**
10227
+ * Utility function to find the index of a source. Returns -1 if not
10228
+ * found.
10229
+ */
10230
+ _findSourceIndex(aSource) {
10231
+ let relativeSource = aSource;
10232
+ if (this.sourceRoot != null) {
10233
+ relativeSource = util.relative(this.sourceRoot, relativeSource);
10234
+ }
10235
+ if (this._sources.has(relativeSource)) {
10236
+ return this._sources.indexOf(relativeSource);
10237
+ }
10238
+ for (let i = 0; i < this._absoluteSources.length; ++i) {
10239
+ if (this._absoluteSources[i] == aSource) {
10240
+ return i;
10241
+ }
10242
+ }
10243
+ return -1;
10244
+ }
10245
+ /**
10246
+ * Create a BasicSourceMapConsumer from a SourceMapGenerator.
10247
+ *
10248
+ * @param SourceMapGenerator aSourceMap
10249
+ * The source map that will be consumed.
10250
+ * @param String aSourceMapURL
10251
+ * The URL at which the source map can be found (optional)
10252
+ * @returns BasicSourceMapConsumer
10253
+ */
10254
+ static fromSourceMap(aSourceMap, aSourceMapURL) {
10255
+ return new _BasicSourceMapConsumer(aSourceMap.toString());
10256
+ }
10257
+ get sources() {
10258
+ return this._absoluteSources.slice();
10259
+ }
10260
+ _getMappingsPtr() {
10261
+ if (this._mappingsPtr === 0) {
10262
+ this._parseMappings(this._mappings, this.sourceRoot);
10263
+ }
10264
+ return this._mappingsPtr;
10265
+ }
10266
+ /**
10267
+ * Parse the mappings in a string in to a data structure which we can easily
10268
+ * query (the ordered arrays in the `this.__generatedMappings` and
10269
+ * `this.__originalMappings` properties).
10270
+ */
10271
+ _parseMappings(aStr, aSourceRoot) {
10272
+ const size = aStr.length;
10273
+ const mappingsBufPtr = this._wasm.exports.allocate_mappings(size);
10274
+ const mappingsBuf = new Uint8Array(this._wasm.exports.memory.buffer, mappingsBufPtr, size);
10275
+ for (let i = 0; i < size; i++) {
10276
+ mappingsBuf[i] = aStr.charCodeAt(i);
10277
+ }
10278
+ const mappingsPtr = this._wasm.exports.parse_mappings(mappingsBufPtr);
10279
+ if (!mappingsPtr) {
10280
+ const error = this._wasm.exports.get_last_error();
10281
+ let msg = `Error parsing mappings (code ${error}): `;
10282
+ switch (error) {
10283
+ case 1:
10284
+ msg += "the mappings contained a negative line, column, source index, or name index";
10285
+ break;
10286
+ case 2:
10287
+ msg += "the mappings contained a number larger than 2**32";
10288
+ break;
10289
+ case 3:
10290
+ msg += "reached EOF while in the middle of parsing a VLQ";
10291
+ break;
10292
+ case 4:
10293
+ msg += "invalid base 64 character while parsing a VLQ";
10294
+ break;
10295
+ default:
10296
+ msg += "unknown error code";
10297
+ break;
10298
+ }
10299
+ throw new Error(msg);
10300
+ }
10301
+ this._mappingsPtr = mappingsPtr;
10302
+ }
10303
+ eachMapping(aCallback, aContext, aOrder) {
10304
+ const context = aContext || null;
10305
+ const order = aOrder || SourceMapConsumer2.GENERATED_ORDER;
10306
+ const sourceRoot = this.sourceRoot;
10307
+ this._wasm.withMappingCallback(
10308
+ (mapping) => {
10309
+ if (mapping.source !== null) {
10310
+ mapping.source = this._sources.at(mapping.source);
10311
+ mapping.source = util.computeSourceURL(sourceRoot, mapping.source, this._sourceMapURL);
10312
+ if (mapping.name !== null) {
10313
+ mapping.name = this._names.at(mapping.name);
10314
+ }
10315
+ }
10316
+ aCallback.call(context, mapping);
10317
+ },
10318
+ () => {
10319
+ switch (order) {
10320
+ case SourceMapConsumer2.GENERATED_ORDER:
10321
+ this._wasm.exports.by_generated_location(this._getMappingsPtr());
10322
+ break;
10323
+ case SourceMapConsumer2.ORIGINAL_ORDER:
10324
+ this._wasm.exports.by_original_location(this._getMappingsPtr());
10325
+ break;
10326
+ default:
10327
+ throw new Error("Unknown order of iteration.");
10328
+ }
10329
+ }
10330
+ );
10331
+ }
10332
+ allGeneratedPositionsFor(aArgs) {
10333
+ let source = util.getArg(aArgs, "source");
10334
+ const originalLine = util.getArg(aArgs, "line");
10335
+ const originalColumn = aArgs.column || 0;
10336
+ source = this._findSourceIndex(source);
10337
+ if (source < 0) {
10338
+ return [];
10339
+ }
10340
+ if (originalLine < 1) {
10341
+ throw new Error("Line numbers must be >= 1");
10342
+ }
10343
+ if (originalColumn < 0) {
10344
+ throw new Error("Column numbers must be >= 0");
10345
+ }
10346
+ const mappings = [];
10347
+ this._wasm.withMappingCallback(
10348
+ (m) => {
10349
+ let lastColumn = m.lastGeneratedColumn;
10350
+ if (this._computedColumnSpans && lastColumn === null) {
10351
+ lastColumn = Infinity;
10352
+ }
10353
+ mappings.push({
10354
+ line: m.generatedLine,
10355
+ column: m.generatedColumn,
10356
+ lastColumn
10357
+ });
10358
+ },
10359
+ () => {
10360
+ this._wasm.exports.all_generated_locations_for(
10361
+ this._getMappingsPtr(),
10362
+ source,
10363
+ originalLine - 1,
10364
+ "column" in aArgs,
10365
+ originalColumn
10366
+ );
10367
+ }
10368
+ );
10369
+ return mappings;
10370
+ }
10371
+ destroy() {
10372
+ if (this._mappingsPtr !== 0) {
10373
+ this._wasm.exports.free_mappings(this._mappingsPtr);
10374
+ this._mappingsPtr = 0;
10375
+ }
10376
+ }
10377
+ /**
10378
+ * Compute the last column for each generated mapping. The last column is
10379
+ * inclusive.
10380
+ */
10381
+ computeColumnSpans() {
10382
+ if (this._computedColumnSpans) {
10383
+ return;
10384
+ }
10385
+ this._wasm.exports.compute_column_spans(this._getMappingsPtr());
10386
+ this._computedColumnSpans = true;
10387
+ }
10388
+ /**
10389
+ * Returns the original source, line, and column information for the generated
10390
+ * source's line and column positions provided. The only argument is an object
10391
+ * with the following properties:
10392
+ *
10393
+ * - line: The line number in the generated source. The line number
10394
+ * is 1-based.
10395
+ * - column: The column number in the generated source. The column
10396
+ * number is 0-based.
10397
+ * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
10398
+ * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
10399
+ * closest element that is smaller than or greater than the one we are
10400
+ * searching for, respectively, if the exact element cannot be found.
10401
+ * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
10402
+ *
10403
+ * and an object is returned with the following properties:
10404
+ *
10405
+ * - source: The original source file, or null.
10406
+ * - line: The line number in the original source, or null. The
10407
+ * line number is 1-based.
10408
+ * - column: The column number in the original source, or null. The
10409
+ * column number is 0-based.
10410
+ * - name: The original identifier, or null.
10411
+ */
10412
+ originalPositionFor(aArgs) {
10413
+ const needle = {
10414
+ generatedLine: util.getArg(aArgs, "line"),
10415
+ generatedColumn: util.getArg(aArgs, "column")
10416
+ };
10417
+ if (needle.generatedLine < 1) {
10418
+ throw new Error("Line numbers must be >= 1");
10419
+ }
10420
+ if (needle.generatedColumn < 0) {
10421
+ throw new Error("Column numbers must be >= 0");
10422
+ }
10423
+ let bias = util.getArg(aArgs, "bias", SourceMapConsumer2.GREATEST_LOWER_BOUND);
10424
+ if (bias == null) {
10425
+ bias = SourceMapConsumer2.GREATEST_LOWER_BOUND;
10426
+ }
10427
+ let mapping;
10428
+ this._wasm.withMappingCallback((m) => mapping = m, () => {
10429
+ this._wasm.exports.original_location_for(
10430
+ this._getMappingsPtr(),
10431
+ needle.generatedLine - 1,
10432
+ needle.generatedColumn,
10433
+ bias
10434
+ );
10435
+ });
10436
+ if (mapping) {
10437
+ if (mapping.generatedLine === needle.generatedLine) {
10438
+ let source = util.getArg(mapping, "source", null);
10439
+ if (source !== null) {
10440
+ source = this._sources.at(source);
10441
+ source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
10442
+ }
10443
+ let name = util.getArg(mapping, "name", null);
10444
+ if (name !== null) {
10445
+ name = this._names.at(name);
10446
+ }
10447
+ return {
10448
+ source,
10449
+ line: util.getArg(mapping, "originalLine", null),
10450
+ column: util.getArg(mapping, "originalColumn", null),
10451
+ name
10452
+ };
10453
+ }
10454
+ }
10455
+ return {
10456
+ source: null,
10457
+ line: null,
10458
+ column: null,
10459
+ name: null
10460
+ };
10461
+ }
10462
+ /**
10463
+ * Return true if we have the source content for every source in the source
10464
+ * map, false otherwise.
10465
+ */
10466
+ hasContentsOfAllSources() {
10467
+ if (!this.sourcesContent) {
10468
+ return false;
10469
+ }
10470
+ return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
10471
+ return sc == null;
10472
+ });
10473
+ }
10474
+ /**
10475
+ * Returns the original source content. The only argument is the url of the
10476
+ * original source file. Returns null if no original source content is
10477
+ * available.
10478
+ */
10479
+ sourceContentFor(aSource, nullOnMissing) {
10480
+ if (!this.sourcesContent) {
10481
+ return null;
10482
+ }
10483
+ const index = this._findSourceIndex(aSource);
10484
+ if (index >= 0) {
10485
+ return this.sourcesContent[index];
10486
+ }
10487
+ let relativeSource = aSource;
10488
+ if (this.sourceRoot != null) {
10489
+ relativeSource = util.relative(this.sourceRoot, relativeSource);
10490
+ }
10491
+ let url3;
10492
+ if (this.sourceRoot != null && (url3 = util.urlParse(this.sourceRoot))) {
10493
+ const fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
10494
+ if (url3.scheme == "file" && this._sources.has(fileUriAbsPath)) {
10495
+ return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
10496
+ }
10497
+ if ((!url3.path || url3.path == "/") && this._sources.has("/" + relativeSource)) {
10498
+ return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
10499
+ }
10500
+ }
10501
+ if (nullOnMissing) {
10502
+ return null;
10503
+ }
10504
+ throw new Error('"' + relativeSource + '" is not in the SourceMap.');
10505
+ }
10506
+ /**
10507
+ * Returns the generated line and column information for the original source,
10508
+ * line, and column positions provided. The only argument is an object with
10509
+ * the following properties:
10510
+ *
10511
+ * - source: The filename of the original source.
10512
+ * - line: The line number in the original source. The line number
10513
+ * is 1-based.
10514
+ * - column: The column number in the original source. The column
10515
+ * number is 0-based.
10516
+ * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
10517
+ * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
10518
+ * closest element that is smaller than or greater than the one we are
10519
+ * searching for, respectively, if the exact element cannot be found.
10520
+ * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
10521
+ *
10522
+ * and an object is returned with the following properties:
10523
+ *
10524
+ * - line: The line number in the generated source, or null. The
10525
+ * line number is 1-based.
10526
+ * - column: The column number in the generated source, or null.
10527
+ * The column number is 0-based.
10528
+ */
10529
+ generatedPositionFor(aArgs) {
10530
+ let source = util.getArg(aArgs, "source");
10531
+ source = this._findSourceIndex(source);
10532
+ if (source < 0) {
10533
+ return {
10534
+ line: null,
10535
+ column: null,
10536
+ lastColumn: null
10537
+ };
10538
+ }
10539
+ const needle = {
10540
+ source,
10541
+ originalLine: util.getArg(aArgs, "line"),
10542
+ originalColumn: util.getArg(aArgs, "column")
10543
+ };
10544
+ if (needle.originalLine < 1) {
10545
+ throw new Error("Line numbers must be >= 1");
10546
+ }
10547
+ if (needle.originalColumn < 0) {
10548
+ throw new Error("Column numbers must be >= 0");
10549
+ }
10550
+ let bias = util.getArg(aArgs, "bias", SourceMapConsumer2.GREATEST_LOWER_BOUND);
10551
+ if (bias == null) {
10552
+ bias = SourceMapConsumer2.GREATEST_LOWER_BOUND;
10553
+ }
10554
+ let mapping;
10555
+ this._wasm.withMappingCallback((m) => mapping = m, () => {
10556
+ this._wasm.exports.generated_location_for(
10557
+ this._getMappingsPtr(),
10558
+ needle.source,
10559
+ needle.originalLine - 1,
10560
+ needle.originalColumn,
10561
+ bias
10562
+ );
10563
+ });
10564
+ if (mapping) {
10565
+ if (mapping.source === needle.source) {
10566
+ let lastColumn = mapping.lastGeneratedColumn;
10567
+ if (this._computedColumnSpans && lastColumn === null) {
10568
+ lastColumn = Infinity;
10569
+ }
10570
+ return {
10571
+ line: util.getArg(mapping, "generatedLine", null),
10572
+ column: util.getArg(mapping, "generatedColumn", null),
10573
+ lastColumn
10574
+ };
10575
+ }
10576
+ }
10577
+ return {
10578
+ line: null,
10579
+ column: null,
10580
+ lastColumn: null
10581
+ };
10582
+ }
10583
+ };
10584
+ BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer2;
10585
+ exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
10586
+ var IndexedSourceMapConsumer = class extends SourceMapConsumer2 {
10587
+ constructor(aSourceMap, aSourceMapURL) {
10588
+ return super(INTERNAL).then((that) => {
10589
+ let sourceMap = aSourceMap;
10590
+ if (typeof aSourceMap === "string") {
10591
+ sourceMap = util.parseSourceMapInput(aSourceMap);
10592
+ }
10593
+ const version2 = util.getArg(sourceMap, "version");
10594
+ const sections = util.getArg(sourceMap, "sections");
10595
+ if (version2 != that._version) {
10596
+ throw new Error("Unsupported version: " + version2);
10597
+ }
10598
+ that._sources = new ArraySet();
10599
+ that._names = new ArraySet();
10600
+ that.__generatedMappings = null;
10601
+ that.__originalMappings = null;
10602
+ that.__generatedMappingsUnsorted = null;
10603
+ that.__originalMappingsUnsorted = null;
10604
+ let lastOffset = {
10605
+ line: -1,
10606
+ column: 0
10607
+ };
10608
+ return Promise.all(sections.map((s) => {
10609
+ if (s.url) {
10610
+ throw new Error("Support for url field in sections not implemented.");
10611
+ }
10612
+ const offset = util.getArg(s, "offset");
10613
+ const offsetLine = util.getArg(offset, "line");
10614
+ const offsetColumn = util.getArg(offset, "column");
10615
+ if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
10616
+ throw new Error("Section offsets must be ordered and non-overlapping.");
10617
+ }
10618
+ lastOffset = offset;
10619
+ const cons = new SourceMapConsumer2(util.getArg(s, "map"), aSourceMapURL);
10620
+ return cons.then((consumer) => {
10621
+ return {
10622
+ generatedOffset: {
10623
+ // The offset fields are 0-based, but we use 1-based indices when
10624
+ // encoding/decoding from VLQ.
10625
+ generatedLine: offsetLine + 1,
10626
+ generatedColumn: offsetColumn + 1
10627
+ },
10628
+ consumer
10629
+ };
10630
+ });
10631
+ })).then((s) => {
10632
+ that._sections = s;
10633
+ return that;
10634
+ });
10635
+ });
10636
+ }
10637
+ // `__generatedMappings` and `__originalMappings` are arrays that hold the
10638
+ // parsed mapping coordinates from the source map's "mappings" attribute. They
10639
+ // are lazily instantiated, accessed via the `_generatedMappings` and
10640
+ // `_originalMappings` getters respectively, and we only parse the mappings
10641
+ // and create these arrays once queried for a source location. We jump through
10642
+ // these hoops because there can be many thousands of mappings, and parsing
10643
+ // them is expensive, so we only want to do it if we must.
10644
+ //
10645
+ // Each object in the arrays is of the form:
10646
+ //
10647
+ // {
10648
+ // generatedLine: The line number in the generated code,
10649
+ // generatedColumn: The column number in the generated code,
10650
+ // source: The path to the original source file that generated this
10651
+ // chunk of code,
10652
+ // originalLine: The line number in the original source that
10653
+ // corresponds to this chunk of generated code,
10654
+ // originalColumn: The column number in the original source that
10655
+ // corresponds to this chunk of generated code,
10656
+ // name: The name of the original symbol which generated this chunk of
10657
+ // code.
10658
+ // }
10659
+ //
10660
+ // All properties except for `generatedLine` and `generatedColumn` can be
10661
+ // `null`.
10662
+ //
10663
+ // `_generatedMappings` is ordered by the generated positions.
10664
+ //
10665
+ // `_originalMappings` is ordered by the original positions.
10666
+ get _generatedMappings() {
10667
+ if (!this.__generatedMappings) {
10668
+ this._sortGeneratedMappings();
10669
+ }
10670
+ return this.__generatedMappings;
10671
+ }
10672
+ get _originalMappings() {
10673
+ if (!this.__originalMappings) {
10674
+ this._sortOriginalMappings();
10675
+ }
10676
+ return this.__originalMappings;
10677
+ }
10678
+ get _generatedMappingsUnsorted() {
10679
+ if (!this.__generatedMappingsUnsorted) {
10680
+ this._parseMappings(this._mappings, this.sourceRoot);
10681
+ }
10682
+ return this.__generatedMappingsUnsorted;
10683
+ }
10684
+ get _originalMappingsUnsorted() {
10685
+ if (!this.__originalMappingsUnsorted) {
10686
+ this._parseMappings(this._mappings, this.sourceRoot);
10687
+ }
10688
+ return this.__originalMappingsUnsorted;
10689
+ }
10690
+ _sortGeneratedMappings() {
10691
+ const mappings = this._generatedMappingsUnsorted;
10692
+ mappings.sort(util.compareByGeneratedPositionsDeflated);
10693
+ this.__generatedMappings = mappings;
10694
+ }
10695
+ _sortOriginalMappings() {
10696
+ const mappings = this._originalMappingsUnsorted;
10697
+ mappings.sort(util.compareByOriginalPositions);
10698
+ this.__originalMappings = mappings;
10699
+ }
10700
+ /**
10701
+ * The list of original sources.
10702
+ */
10703
+ get sources() {
10704
+ const sources = [];
10705
+ for (let i = 0; i < this._sections.length; i++) {
10706
+ for (let j = 0; j < this._sections[i].consumer.sources.length; j++) {
10707
+ sources.push(this._sections[i].consumer.sources[j]);
10708
+ }
10709
+ }
10710
+ return sources;
10711
+ }
10712
+ /**
10713
+ * Returns the original source, line, and column information for the generated
10714
+ * source's line and column positions provided. The only argument is an object
10715
+ * with the following properties:
10716
+ *
10717
+ * - line: The line number in the generated source. The line number
10718
+ * is 1-based.
10719
+ * - column: The column number in the generated source. The column
10720
+ * number is 0-based.
10721
+ *
10722
+ * and an object is returned with the following properties:
10723
+ *
10724
+ * - source: The original source file, or null.
10725
+ * - line: The line number in the original source, or null. The
10726
+ * line number is 1-based.
10727
+ * - column: The column number in the original source, or null. The
10728
+ * column number is 0-based.
10729
+ * - name: The original identifier, or null.
10730
+ */
10731
+ originalPositionFor(aArgs) {
10732
+ const needle = {
10733
+ generatedLine: util.getArg(aArgs, "line"),
10734
+ generatedColumn: util.getArg(aArgs, "column")
10735
+ };
10736
+ const sectionIndex = binarySearch.search(
10737
+ needle,
10738
+ this._sections,
10739
+ function(aNeedle, section2) {
10740
+ const cmp = aNeedle.generatedLine - section2.generatedOffset.generatedLine;
10741
+ if (cmp) {
10742
+ return cmp;
10743
+ }
10744
+ return aNeedle.generatedColumn - section2.generatedOffset.generatedColumn;
10745
+ }
10746
+ );
10747
+ const section = this._sections[sectionIndex];
10748
+ if (!section) {
10749
+ return {
10750
+ source: null,
10751
+ line: null,
10752
+ column: null,
10753
+ name: null
10754
+ };
10755
+ }
10756
+ return section.consumer.originalPositionFor({
10757
+ line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
10758
+ column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
10759
+ bias: aArgs.bias
10760
+ });
10761
+ }
10762
+ /**
10763
+ * Return true if we have the source content for every source in the source
10764
+ * map, false otherwise.
10765
+ */
10766
+ hasContentsOfAllSources() {
10767
+ return this._sections.every(function(s) {
10768
+ return s.consumer.hasContentsOfAllSources();
10769
+ });
10770
+ }
10771
+ /**
10772
+ * Returns the original source content. The only argument is the url of the
10773
+ * original source file. Returns null if no original source content is
10774
+ * available.
10775
+ */
10776
+ sourceContentFor(aSource, nullOnMissing) {
10777
+ for (let i = 0; i < this._sections.length; i++) {
10778
+ const section = this._sections[i];
10779
+ const content = section.consumer.sourceContentFor(aSource, true);
10780
+ if (content) {
10781
+ return content;
10782
+ }
10783
+ }
10784
+ if (nullOnMissing) {
10785
+ return null;
10786
+ }
10787
+ throw new Error('"' + aSource + '" is not in the SourceMap.');
10788
+ }
10789
+ /**
10790
+ * Returns the generated line and column information for the original source,
10791
+ * line, and column positions provided. The only argument is an object with
10792
+ * the following properties:
10793
+ *
10794
+ * - source: The filename of the original source.
10795
+ * - line: The line number in the original source. The line number
10796
+ * is 1-based.
10797
+ * - column: The column number in the original source. The column
10798
+ * number is 0-based.
10799
+ *
10800
+ * and an object is returned with the following properties:
10801
+ *
10802
+ * - line: The line number in the generated source, or null. The
10803
+ * line number is 1-based.
10804
+ * - column: The column number in the generated source, or null.
10805
+ * The column number is 0-based.
10806
+ */
10807
+ generatedPositionFor(aArgs) {
10808
+ for (let i = 0; i < this._sections.length; i++) {
10809
+ const section = this._sections[i];
10810
+ if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
10811
+ continue;
10812
+ }
10813
+ const generatedPosition = section.consumer.generatedPositionFor(aArgs);
10814
+ if (generatedPosition) {
10815
+ const ret = {
10816
+ line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
10817
+ column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
10818
+ };
10819
+ return ret;
10820
+ }
10821
+ }
10822
+ return {
10823
+ line: null,
10824
+ column: null
10825
+ };
10826
+ }
10827
+ /**
10828
+ * Parse the mappings in a string in to a data structure which we can easily
10829
+ * query (the ordered arrays in the `this.__generatedMappings` and
10830
+ * `this.__originalMappings` properties).
10831
+ */
10832
+ _parseMappings(aStr, aSourceRoot) {
10833
+ const generatedMappings = this.__generatedMappingsUnsorted = [];
10834
+ const originalMappings = this.__originalMappingsUnsorted = [];
10835
+ for (let i = 0; i < this._sections.length; i++) {
10836
+ const section = this._sections[i];
10837
+ const sectionMappings = [];
10838
+ section.consumer.eachMapping((m) => sectionMappings.push(m));
10839
+ for (let j = 0; j < sectionMappings.length; j++) {
10840
+ const mapping = sectionMappings[j];
10841
+ let source = util.computeSourceURL(section.consumer.sourceRoot, null, this._sourceMapURL);
10842
+ this._sources.add(source);
10843
+ source = this._sources.indexOf(source);
10844
+ let name = null;
10845
+ if (mapping.name) {
10846
+ this._names.add(mapping.name);
10847
+ name = this._names.indexOf(mapping.name);
10848
+ }
10849
+ const adjustedMapping = {
10850
+ source,
10851
+ generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
10852
+ generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
10853
+ originalLine: mapping.originalLine,
10854
+ originalColumn: mapping.originalColumn,
10855
+ name
10856
+ };
10857
+ generatedMappings.push(adjustedMapping);
10858
+ if (typeof adjustedMapping.originalLine === "number") {
10859
+ originalMappings.push(adjustedMapping);
10860
+ }
10861
+ }
10862
+ }
10863
+ }
10864
+ eachMapping(aCallback, aContext, aOrder) {
10865
+ const context = aContext || null;
10866
+ const order = aOrder || SourceMapConsumer2.GENERATED_ORDER;
10867
+ let mappings;
10868
+ switch (order) {
10869
+ case SourceMapConsumer2.GENERATED_ORDER:
10870
+ mappings = this._generatedMappings;
10871
+ break;
10872
+ case SourceMapConsumer2.ORIGINAL_ORDER:
10873
+ mappings = this._originalMappings;
10874
+ break;
10875
+ default:
10876
+ throw new Error("Unknown order of iteration.");
10877
+ }
10878
+ const sourceRoot = this.sourceRoot;
10879
+ mappings.map(function(mapping) {
10880
+ let source = null;
10881
+ if (mapping.source !== null) {
10882
+ source = this._sources.at(mapping.source);
10883
+ source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
10884
+ }
10885
+ return {
10886
+ source,
10887
+ generatedLine: mapping.generatedLine,
10888
+ generatedColumn: mapping.generatedColumn,
10889
+ originalLine: mapping.originalLine,
10890
+ originalColumn: mapping.originalColumn,
10891
+ name: mapping.name === null ? null : this._names.at(mapping.name)
10892
+ };
10893
+ }, this).forEach(aCallback, context);
10894
+ }
10895
+ /**
10896
+ * Find the mapping that best matches the hypothetical "needle" mapping that
10897
+ * we are searching for in the given "haystack" of mappings.
10898
+ */
10899
+ _findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
10900
+ if (aNeedle[aLineName] <= 0) {
10901
+ throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
10902
+ }
10903
+ if (aNeedle[aColumnName] < 0) {
10904
+ throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
10905
+ }
10906
+ return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
10907
+ }
10908
+ allGeneratedPositionsFor(aArgs) {
10909
+ const line = util.getArg(aArgs, "line");
10910
+ const needle = {
10911
+ source: util.getArg(aArgs, "source"),
10912
+ originalLine: line,
10913
+ originalColumn: util.getArg(aArgs, "column", 0)
10914
+ };
10915
+ needle.source = this._findSourceIndex(needle.source);
10916
+ if (needle.source < 0) {
10917
+ return [];
10918
+ }
10919
+ if (needle.originalLine < 1) {
10920
+ throw new Error("Line numbers must be >= 1");
10921
+ }
10922
+ if (needle.originalColumn < 0) {
10923
+ throw new Error("Column numbers must be >= 0");
10924
+ }
10925
+ const mappings = [];
10926
+ let index = this._findMapping(
10927
+ needle,
10928
+ this._originalMappings,
10929
+ "originalLine",
10930
+ "originalColumn",
10931
+ util.compareByOriginalPositions,
10932
+ binarySearch.LEAST_UPPER_BOUND
10933
+ );
10934
+ if (index >= 0) {
10935
+ let mapping = this._originalMappings[index];
10936
+ if (aArgs.column === void 0) {
10937
+ const originalLine = mapping.originalLine;
10938
+ while (mapping && mapping.originalLine === originalLine) {
10939
+ let lastColumn = mapping.lastGeneratedColumn;
10940
+ if (this._computedColumnSpans && lastColumn === null) {
10941
+ lastColumn = Infinity;
10942
+ }
10943
+ mappings.push({
10944
+ line: util.getArg(mapping, "generatedLine", null),
10945
+ column: util.getArg(mapping, "generatedColumn", null),
10946
+ lastColumn
10947
+ });
10948
+ mapping = this._originalMappings[++index];
10949
+ }
10950
+ } else {
10951
+ const originalColumn = mapping.originalColumn;
10952
+ while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
10953
+ let lastColumn = mapping.lastGeneratedColumn;
10954
+ if (this._computedColumnSpans && lastColumn === null) {
10955
+ lastColumn = Infinity;
10956
+ }
10957
+ mappings.push({
10958
+ line: util.getArg(mapping, "generatedLine", null),
10959
+ column: util.getArg(mapping, "generatedColumn", null),
10960
+ lastColumn
10961
+ });
10962
+ mapping = this._originalMappings[++index];
10963
+ }
10964
+ }
10965
+ }
10966
+ return mappings;
10967
+ }
10968
+ destroy() {
10969
+ for (let i = 0; i < this._sections.length; i++) {
10970
+ this._sections[i].consumer.destroy();
10971
+ }
10972
+ }
10973
+ };
10974
+ exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
10975
+ function _factory(aSourceMap, aSourceMapURL) {
10976
+ let sourceMap = aSourceMap;
10977
+ if (typeof aSourceMap === "string") {
10978
+ sourceMap = util.parseSourceMapInput(aSourceMap);
10979
+ }
10980
+ const consumer = sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
10981
+ return Promise.resolve(consumer);
10982
+ }
10983
+ function _factoryBSM(aSourceMap, aSourceMapURL) {
10984
+ return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
10985
+ }
10986
+ }
10987
+ });
10988
+
10989
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/source-node.js
10990
+ var require_source_node = __commonJS({
10991
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/lib/source-node.js"(exports) {
10992
+ var SourceMapGenerator2 = require_source_map_generator().SourceMapGenerator;
10993
+ var util = require_util();
10994
+ var REGEX_NEWLINE = /(\r?\n)/;
10995
+ var NEWLINE_CODE = 10;
10996
+ var isSourceNode = "$$$isSourceNode$$$";
10997
+ var SourceNode = class _SourceNode {
10998
+ constructor(aLine, aColumn, aSource, aChunks, aName) {
10999
+ this.children = [];
11000
+ this.sourceContents = {};
11001
+ this.line = aLine == null ? null : aLine;
11002
+ this.column = aColumn == null ? null : aColumn;
11003
+ this.source = aSource == null ? null : aSource;
11004
+ this.name = aName == null ? null : aName;
11005
+ this[isSourceNode] = true;
11006
+ if (aChunks != null)
11007
+ this.add(aChunks);
11008
+ }
11009
+ /**
11010
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
11011
+ *
11012
+ * @param aGeneratedCode The generated code
11013
+ * @param aSourceMapConsumer The SourceMap for the generated code
11014
+ * @param aRelativePath Optional. The path that relative sources in the
11015
+ * SourceMapConsumer should be relative to.
11016
+ */
11017
+ static fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
11018
+ const node = new _SourceNode();
11019
+ const remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
11020
+ let remainingLinesIndex = 0;
11021
+ const shiftNextLine = function() {
11022
+ const lineContents = getNextLine();
11023
+ const newLine = getNextLine() || "";
11024
+ return lineContents + newLine;
11025
+ function getNextLine() {
11026
+ return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
11027
+ }
11028
+ };
11029
+ let lastGeneratedLine = 1, lastGeneratedColumn = 0;
11030
+ let lastMapping = null;
11031
+ let nextLine;
11032
+ aSourceMapConsumer.eachMapping(function(mapping) {
11033
+ if (lastMapping !== null) {
11034
+ if (lastGeneratedLine < mapping.generatedLine) {
11035
+ addMappingWithCode(lastMapping, shiftNextLine());
11036
+ lastGeneratedLine++;
11037
+ lastGeneratedColumn = 0;
11038
+ } else {
11039
+ nextLine = remainingLines[remainingLinesIndex] || "";
11040
+ const code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
11041
+ remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
11042
+ lastGeneratedColumn = mapping.generatedColumn;
11043
+ addMappingWithCode(lastMapping, code);
11044
+ lastMapping = mapping;
11045
+ return;
11046
+ }
11047
+ }
11048
+ while (lastGeneratedLine < mapping.generatedLine) {
11049
+ node.add(shiftNextLine());
11050
+ lastGeneratedLine++;
11051
+ }
11052
+ if (lastGeneratedColumn < mapping.generatedColumn) {
11053
+ nextLine = remainingLines[remainingLinesIndex] || "";
11054
+ node.add(nextLine.substr(0, mapping.generatedColumn));
11055
+ remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
11056
+ lastGeneratedColumn = mapping.generatedColumn;
11057
+ }
11058
+ lastMapping = mapping;
11059
+ }, this);
11060
+ if (remainingLinesIndex < remainingLines.length) {
11061
+ if (lastMapping) {
11062
+ addMappingWithCode(lastMapping, shiftNextLine());
11063
+ }
11064
+ node.add(remainingLines.splice(remainingLinesIndex).join(""));
11065
+ }
11066
+ aSourceMapConsumer.sources.forEach(function(sourceFile) {
11067
+ const content = aSourceMapConsumer.sourceContentFor(sourceFile);
11068
+ if (content != null) {
11069
+ if (aRelativePath != null) {
11070
+ sourceFile = util.join(aRelativePath, sourceFile);
11071
+ }
11072
+ node.setSourceContent(sourceFile, content);
11073
+ }
11074
+ });
11075
+ return node;
11076
+ function addMappingWithCode(mapping, code) {
11077
+ if (mapping === null || mapping.source === void 0) {
11078
+ node.add(code);
11079
+ } else {
11080
+ const source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
11081
+ node.add(new _SourceNode(
11082
+ mapping.originalLine,
11083
+ mapping.originalColumn,
11084
+ source,
11085
+ code,
11086
+ mapping.name
11087
+ ));
11088
+ }
11089
+ }
11090
+ }
11091
+ /**
11092
+ * Add a chunk of generated JS to this source node.
11093
+ *
11094
+ * @param aChunk A string snippet of generated JS code, another instance of
11095
+ * SourceNode, or an array where each member is one of those things.
11096
+ */
11097
+ add(aChunk) {
11098
+ if (Array.isArray(aChunk)) {
11099
+ aChunk.forEach(function(chunk) {
11100
+ this.add(chunk);
11101
+ }, this);
11102
+ } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
11103
+ if (aChunk) {
11104
+ this.children.push(aChunk);
11105
+ }
11106
+ } else {
11107
+ throw new TypeError(
11108
+ "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
11109
+ );
11110
+ }
11111
+ return this;
11112
+ }
11113
+ /**
11114
+ * Add a chunk of generated JS to the beginning of this source node.
11115
+ *
11116
+ * @param aChunk A string snippet of generated JS code, another instance of
11117
+ * SourceNode, or an array where each member is one of those things.
11118
+ */
11119
+ prepend(aChunk) {
11120
+ if (Array.isArray(aChunk)) {
11121
+ for (let i = aChunk.length - 1; i >= 0; i--) {
11122
+ this.prepend(aChunk[i]);
11123
+ }
11124
+ } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
11125
+ this.children.unshift(aChunk);
11126
+ } else {
11127
+ throw new TypeError(
11128
+ "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
11129
+ );
11130
+ }
11131
+ return this;
11132
+ }
11133
+ /**
11134
+ * Walk over the tree of JS snippets in this node and its children. The
11135
+ * walking function is called once for each snippet of JS and is passed that
11136
+ * snippet and the its original associated source's line/column location.
11137
+ *
11138
+ * @param aFn The traversal function.
11139
+ */
11140
+ walk(aFn) {
11141
+ let chunk;
11142
+ for (let i = 0, len = this.children.length; i < len; i++) {
11143
+ chunk = this.children[i];
11144
+ if (chunk[isSourceNode]) {
11145
+ chunk.walk(aFn);
11146
+ } else if (chunk !== "") {
11147
+ aFn(chunk, {
11148
+ source: this.source,
11149
+ line: this.line,
11150
+ column: this.column,
11151
+ name: this.name
11152
+ });
11153
+ }
11154
+ }
11155
+ }
11156
+ /**
11157
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
11158
+ * each of `this.children`.
11159
+ *
11160
+ * @param aSep The separator.
11161
+ */
11162
+ join(aSep) {
11163
+ let newChildren;
11164
+ let i;
11165
+ const len = this.children.length;
11166
+ if (len > 0) {
11167
+ newChildren = [];
11168
+ for (i = 0; i < len - 1; i++) {
11169
+ newChildren.push(this.children[i]);
11170
+ newChildren.push(aSep);
11171
+ }
11172
+ newChildren.push(this.children[i]);
11173
+ this.children = newChildren;
11174
+ }
11175
+ return this;
11176
+ }
11177
+ /**
11178
+ * Call String.prototype.replace on the very right-most source snippet. Useful
11179
+ * for trimming whitespace from the end of a source node, etc.
11180
+ *
11181
+ * @param aPattern The pattern to replace.
11182
+ * @param aReplacement The thing to replace the pattern with.
11183
+ */
11184
+ replaceRight(aPattern, aReplacement) {
11185
+ const lastChild = this.children[this.children.length - 1];
11186
+ if (lastChild[isSourceNode]) {
11187
+ lastChild.replaceRight(aPattern, aReplacement);
11188
+ } else if (typeof lastChild === "string") {
11189
+ this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
11190
+ } else {
11191
+ this.children.push("".replace(aPattern, aReplacement));
11192
+ }
11193
+ return this;
11194
+ }
11195
+ /**
11196
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
11197
+ * in the sourcesContent field.
11198
+ *
11199
+ * @param aSourceFile The filename of the source file
11200
+ * @param aSourceContent The content of the source file
11201
+ */
11202
+ setSourceContent(aSourceFile, aSourceContent) {
11203
+ this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
11204
+ }
11205
+ /**
11206
+ * Walk over the tree of SourceNodes. The walking function is called for each
11207
+ * source file content and is passed the filename and source content.
11208
+ *
11209
+ * @param aFn The traversal function.
11210
+ */
11211
+ walkSourceContents(aFn) {
11212
+ for (let i = 0, len = this.children.length; i < len; i++) {
11213
+ if (this.children[i][isSourceNode]) {
11214
+ this.children[i].walkSourceContents(aFn);
11215
+ }
11216
+ }
11217
+ const sources = Object.keys(this.sourceContents);
11218
+ for (let i = 0, len = sources.length; i < len; i++) {
11219
+ aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
11220
+ }
11221
+ }
11222
+ /**
11223
+ * Return the string representation of this source node. Walks over the tree
11224
+ * and concatenates all the various snippets together to one string.
11225
+ */
11226
+ toString() {
11227
+ let str = "";
11228
+ this.walk(function(chunk) {
11229
+ str += chunk;
11230
+ });
11231
+ return str;
11232
+ }
11233
+ /**
11234
+ * Returns the string representation of this source node along with a source
11235
+ * map.
11236
+ */
11237
+ toStringWithSourceMap(aArgs) {
11238
+ const generated = {
11239
+ code: "",
11240
+ line: 1,
11241
+ column: 0
11242
+ };
11243
+ const map = new SourceMapGenerator2(aArgs);
11244
+ let sourceMappingActive = false;
11245
+ let lastOriginalSource = null;
11246
+ let lastOriginalLine = null;
11247
+ let lastOriginalColumn = null;
11248
+ let lastOriginalName = null;
11249
+ this.walk(function(chunk, original) {
11250
+ generated.code += chunk;
11251
+ if (original.source !== null && original.line !== null && original.column !== null) {
11252
+ if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
11253
+ map.addMapping({
11254
+ source: original.source,
11255
+ original: {
11256
+ line: original.line,
11257
+ column: original.column
11258
+ },
11259
+ generated: {
11260
+ line: generated.line,
11261
+ column: generated.column
11262
+ },
11263
+ name: original.name
11264
+ });
11265
+ }
11266
+ lastOriginalSource = original.source;
11267
+ lastOriginalLine = original.line;
11268
+ lastOriginalColumn = original.column;
11269
+ lastOriginalName = original.name;
11270
+ sourceMappingActive = true;
11271
+ } else if (sourceMappingActive) {
11272
+ map.addMapping({
11273
+ generated: {
11274
+ line: generated.line,
11275
+ column: generated.column
11276
+ }
11277
+ });
11278
+ lastOriginalSource = null;
11279
+ sourceMappingActive = false;
11280
+ }
11281
+ for (let idx = 0, length = chunk.length; idx < length; idx++) {
11282
+ if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
11283
+ generated.line++;
11284
+ generated.column = 0;
11285
+ if (idx + 1 === length) {
11286
+ lastOriginalSource = null;
11287
+ sourceMappingActive = false;
11288
+ } else if (sourceMappingActive) {
11289
+ map.addMapping({
11290
+ source: original.source,
11291
+ original: {
11292
+ line: original.line,
11293
+ column: original.column
11294
+ },
11295
+ generated: {
11296
+ line: generated.line,
11297
+ column: generated.column
11298
+ },
11299
+ name: original.name
11300
+ });
11301
+ }
11302
+ } else {
11303
+ generated.column++;
11304
+ }
11305
+ }
11306
+ });
11307
+ this.walkSourceContents(function(sourceFile, sourceContent) {
11308
+ map.setSourceContent(sourceFile, sourceContent);
11309
+ });
11310
+ return { code: generated.code, map };
11311
+ }
11312
+ };
11313
+ exports.SourceNode = SourceNode;
11314
+ }
11315
+ });
11316
+
11317
+ // ../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/source-map.js
11318
+ var require_source_map = __commonJS({
11319
+ "../../node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/source-map.js"(exports) {
11320
+ exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
11321
+ exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
11322
+ exports.SourceNode = require_source_node().SourceNode;
11323
+ }
11324
+ });
11325
+
9008
11326
  // ../../node_modules/.pnpm/safe-buffer@5.1.2/node_modules/safe-buffer/index.js
9009
11327
  var require_safe_buffer = __commonJS({
9010
11328
  "../../node_modules/.pnpm/safe-buffer@5.1.2/node_modules/safe-buffer/index.js"(exports, module2) {
@@ -9408,7 +11726,6 @@ var import_buffer_crc32 = __toESM(require_buffer_crc32());
9408
11726
  var import_fs_extra3 = __toESM(require_lib2());
9409
11727
  var import_path2 = __toESM(require("path"));
9410
11728
  var import_semver = __toESM(require_semver());
9411
- var import_zlib2 = __toESM(require("zlib"));
9412
11729
  var import_url = __toESM(require("url"));
9413
11730
  var import_module = require("module");
9414
11731
  var import_escape_string_regexp = __toESM(require_escape_string_regexp());
@@ -9419,6 +11736,7 @@ var import_fs_extra2 = __toESM(require_lib2());
9419
11736
  var import_webpack_sources2 = __toESM(require_lib3());
9420
11737
 
9421
11738
  // src/sourcemapped.ts
11739
+ var import_source_map = __toESM(require_source_map());
9422
11740
  var import_convert_source_map = __toESM(require_convert_source_map());
9423
11741
  var import_fs_extra = __toESM(require_lib2());
9424
11742
  var import_webpack_sources = __toESM(require_lib3());
@@ -9443,15 +11761,24 @@ async function fileToSource(content, sourceName, fullFilePath) {
9443
11761
  return sourcemap ? new import_webpack_sources.SourceMapSource(cleanContent, sourceName, sourcemap) : new import_webpack_sources.OriginalSource(cleanContent, sourceName);
9444
11762
  }
9445
11763
  async function getSourceMap(content, fullFilePath) {
11764
+ let map;
9446
11765
  try {
9447
11766
  if (fullFilePath && await import_fs_extra.default.pathExists(`${fullFilePath}.map`)) {
9448
11767
  const mapJson = await import_fs_extra.default.readFile(`${fullFilePath}.map`, "utf8");
9449
- return import_convert_source_map.default.fromJSON(mapJson).toObject();
11768
+ map = import_convert_source_map.default.fromJSON(mapJson).toObject();
11769
+ } else {
11770
+ map = import_convert_source_map.default.fromComment(content).toObject();
9450
11771
  }
9451
- return import_convert_source_map.default.fromComment(content).toObject();
9452
11772
  } catch {
9453
11773
  return null;
9454
11774
  }
11775
+ if ("sections" in map) {
11776
+ return flattenSourceMap(map);
11777
+ }
11778
+ return map;
11779
+ }
11780
+ async function flattenSourceMap(map) {
11781
+ return new import_source_map.SourceMapGenerator(await new import_source_map.SourceMapConsumer(map)).toJSON();
9455
11782
  }
9456
11783
  function stringifySourceMap(sourceMap) {
9457
11784
  if (!sourceMap)
@@ -9485,9 +11812,8 @@ var import_path = require("path");
9485
11812
  var KIB = 1024;
9486
11813
  var MIB = 1024 * KIB;
9487
11814
  var EDGE_FUNCTION_SIZE_LIMIT = 4 * MIB;
9488
- var MAX_UNCOMPRESSED_LAMBDA_SIZE = 250 * MIB;
9489
- var LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 2.5 * MIB;
9490
- var LAMBDA_RESERVED_COMPRESSED_SIZE = 250 * KIB;
11815
+ var DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE = 250 * MIB;
11816
+ var LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 25 * MIB;
9491
11817
 
9492
11818
  // src/edge-function-source/get-edge-function-source.ts
9493
11819
  var import_zlib = __toESM(require("zlib"));
@@ -9554,6 +11880,9 @@ async function validateSize(script, wasmFiles) {
9554
11880
  var require_ = (0, import_module.createRequire)(__filename);
9555
11881
  var RSC_CONTENT_TYPE = "x-component";
9556
11882
  var RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
11883
+ var MAX_UNCOMPRESSED_LAMBDA_SIZE = !isNaN(
11884
+ Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE)
11885
+ ) ? Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE) : DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE;
9557
11886
  var TEST_DYNAMIC_ROUTE = /\/\[[^\/]+?\](?=\/|$)/;
9558
11887
  function isDynamicRoute(route) {
9559
11888
  route = route.startsWith("/") ? route : `/${route}`;
@@ -9937,19 +12266,6 @@ var collectTracedFiles = (baseDir, lstatResults, lstatSema, reasons, files) => a
9937
12266
  });
9938
12267
  };
9939
12268
  var ExperimentalTraceVersion = `9.0.4-canary.1`;
9940
- var compressBuffer = (buf) => {
9941
- return new Promise((resolve, reject) => {
9942
- import_zlib2.default.deflateRaw(
9943
- buf,
9944
- { level: import_zlib2.default.constants.Z_BEST_COMPRESSION },
9945
- (err, compBuf) => {
9946
- if (err)
9947
- return reject(err);
9948
- resolve(compBuf);
9949
- }
9950
- );
9951
- });
9952
- };
9953
12269
  async function createPseudoLayer(files) {
9954
12270
  const pseudoLayer = {};
9955
12271
  let pseudoLayerBytes = 0;
@@ -9964,11 +12280,9 @@ async function createPseudoLayer(files) {
9964
12280
  };
9965
12281
  } else {
9966
12282
  const origBuffer = await (0, import_build_utils.streamToBuffer)(file.toStream());
9967
- const compBuffer = await compressBuffer(origBuffer);
9968
- pseudoLayerBytes += compBuffer.byteLength;
12283
+ pseudoLayerBytes += origBuffer.byteLength;
9969
12284
  pseudoLayer[fileName] = {
9970
12285
  file,
9971
- compBuffer,
9972
12286
  isSymlink: false,
9973
12287
  crc32: import_buffer_crc32.default.unsigned(origBuffer),
9974
12288
  uncompressedSize: origBuffer.byteLength
@@ -10376,7 +12690,6 @@ async function getPageLambdaGroups({
10376
12690
  tracedPseudoLayer,
10377
12691
  initialPseudoLayer,
10378
12692
  initialPseudoLayerUncompressed,
10379
- lambdaCompressedByteLimit,
10380
12693
  internalPages,
10381
12694
  pageExtensions,
10382
12695
  inversedAppPathManifest,
@@ -10410,22 +12723,18 @@ async function getPageLambdaGroups({
10410
12723
  let matchingGroup = experimentalAllowBundling ? void 0 : groups.find((group) => {
10411
12724
  const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute && group.isExperimentalPPR === isExperimentalPPR;
10412
12725
  if (matches) {
10413
- let newTracedFilesSize = group.pseudoLayerBytes;
10414
12726
  let newTracedFilesUncompressedSize = group.pseudoLayerUncompressedBytes;
10415
12727
  for (const newPage of newPages) {
10416
12728
  Object.keys(pageTraces[newPage] || {}).map((file) => {
10417
12729
  if (!group.pseudoLayer[file]) {
10418
12730
  const item = tracedPseudoLayer[file];
10419
- newTracedFilesSize += item.compBuffer?.byteLength || 0;
10420
12731
  newTracedFilesUncompressedSize += item.uncompressedSize || 0;
10421
12732
  }
10422
12733
  });
10423
- newTracedFilesSize += compressedPages[newPage].compBuffer.byteLength;
10424
12734
  newTracedFilesUncompressedSize += compressedPages[newPage].uncompressedSize;
10425
12735
  }
10426
12736
  const underUncompressedLimit = newTracedFilesUncompressedSize < MAX_UNCOMPRESSED_LAMBDA_SIZE - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
10427
- const underCompressedLimit = newTracedFilesSize < lambdaCompressedByteLimit - LAMBDA_RESERVED_COMPRESSED_SIZE;
10428
- return underUncompressedLimit && underCompressedLimit;
12737
+ return underUncompressedLimit;
10429
12738
  }
10430
12739
  return false;
10431
12740
  });
@@ -10448,31 +12757,24 @@ async function getPageLambdaGroups({
10448
12757
  for (const newPage of newPages) {
10449
12758
  Object.keys(pageTraces[newPage] || {}).map((file) => {
10450
12759
  const pseudoItem = tracedPseudoLayer[file];
10451
- const compressedSize = pseudoItem?.compBuffer?.byteLength || 0;
10452
12760
  if (!matchingGroup.pseudoLayer[file]) {
10453
12761
  matchingGroup.pseudoLayer[file] = pseudoItem;
10454
- matchingGroup.pseudoLayerBytes += compressedSize;
10455
12762
  matchingGroup.pseudoLayerUncompressedBytes += pseudoItem.uncompressedSize || 0;
10456
12763
  }
10457
12764
  });
10458
- matchingGroup.pseudoLayerBytes += compressedPages[newPage].compBuffer.byteLength;
10459
12765
  matchingGroup.pseudoLayerUncompressedBytes += compressedPages[newPage].uncompressedSize;
10460
12766
  }
10461
12767
  }
10462
12768
  return groups;
10463
12769
  }
10464
- var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLayerUncompressedBytes, compressedPages) => {
12770
+ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerUncompressedBytes, compressedPages) => {
10465
12771
  const exceededLimitOutput = [];
10466
12772
  console.log(
10467
12773
  `Serverless Function's page${pages.length === 1 ? "" : "s"}: ${pages.join(
10468
12774
  ", "
10469
12775
  )}`
10470
12776
  );
10471
- exceededLimitOutput.push([
10472
- "Large Dependencies",
10473
- "Uncompressed size",
10474
- "Compressed size"
10475
- ]);
12777
+ exceededLimitOutput.push(["Large Dependencies", "Uncompressed size"]);
10476
12778
  const dependencies = {};
10477
12779
  for (const fileKey of Object.keys(pseudoLayer)) {
10478
12780
  if (!pseudoLayer[fileKey].isSymlink) {
@@ -10480,17 +12782,14 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLa
10480
12782
  const depKey = fileKey.split("/").slice(0, 3).join("/");
10481
12783
  if (!dependencies[depKey]) {
10482
12784
  dependencies[depKey] = {
10483
- compressed: 0,
10484
12785
  uncompressed: 0
10485
12786
  };
10486
12787
  }
10487
- dependencies[depKey].compressed += fileItem.compBuffer.byteLength;
10488
12788
  dependencies[depKey].uncompressed += fileItem.uncompressedSize;
10489
12789
  }
10490
12790
  }
10491
12791
  for (const page of pages) {
10492
12792
  dependencies[`pages/${page}`] = {
10493
- compressed: compressedPages[page].compBuffer.byteLength,
10494
12793
  uncompressed: compressedPages[page].uncompressedSize
10495
12794
  };
10496
12795
  }
@@ -10498,51 +12797,45 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLa
10498
12797
  Object.keys(dependencies).sort((a, b) => {
10499
12798
  const aDep = dependencies[a];
10500
12799
  const bDep = dependencies[b];
10501
- if (aDep.compressed > bDep.compressed) {
12800
+ if (aDep.uncompressed > bDep.uncompressed) {
10502
12801
  return -1;
10503
12802
  }
10504
- if (aDep.compressed < bDep.compressed) {
12803
+ if (aDep.uncompressed < bDep.uncompressed) {
10505
12804
  return 1;
10506
12805
  }
10507
12806
  return 0;
10508
12807
  }).forEach((depKey) => {
10509
12808
  const dep = dependencies[depKey];
10510
- if (dep.compressed < 100 * KIB && dep.uncompressed < 500 * KIB) {
12809
+ if (dep.uncompressed < 500 * KIB) {
10511
12810
  return;
10512
12811
  }
10513
- exceededLimitOutput.push([
10514
- depKey,
10515
- prettyBytes(dep.uncompressed),
10516
- prettyBytes(dep.compressed)
10517
- ]);
12812
+ exceededLimitOutput.push([depKey, prettyBytes(dep.uncompressed)]);
10518
12813
  numLargeDependencies += 1;
10519
12814
  });
10520
12815
  if (numLargeDependencies === 0) {
10521
12816
  exceededLimitOutput.push([
10522
- "No large dependencies found (> 100KB compressed)"
12817
+ "No large dependencies found (> 500KB compressed)"
10523
12818
  ]);
10524
12819
  }
10525
12820
  exceededLimitOutput.push([]);
10526
12821
  exceededLimitOutput.push([
10527
12822
  "All dependencies",
10528
- prettyBytes(pseudoLayerUncompressedBytes),
10529
- prettyBytes(pseudoLayerBytes)
12823
+ prettyBytes(pseudoLayerUncompressedBytes)
10530
12824
  ]);
10531
12825
  console.log(
10532
12826
  (0, import_text_table.default)(exceededLimitOutput, {
10533
- align: ["l", "r", "r"]
12827
+ align: ["l", "r"]
10534
12828
  })
10535
12829
  );
10536
12830
  };
10537
- var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compressedPages) => {
10538
- const COMPRESSED_SIZE_LIMIT_CLOSE = compressedSizeLimit - 5 * MIB;
12831
+ var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
10539
12832
  const UNCOMPRESSED_SIZE_LIMIT_CLOSE = MAX_UNCOMPRESSED_LAMBDA_SIZE - 5 * MIB;
10540
12833
  let numExceededLimit = 0;
10541
12834
  let numCloseToLimit = 0;
10542
12835
  let loggedHeadInfo = false;
10543
12836
  const filteredGroups = lambdaGroups.filter((group) => {
10544
- const exceededLimit = group.pseudoLayerBytes > compressedSizeLimit || group.pseudoLayerUncompressedBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE;
10545
- const closeToLimit = group.pseudoLayerBytes > COMPRESSED_SIZE_LIMIT_CLOSE || group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
12837
+ const exceededLimit = group.pseudoLayerUncompressedBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE;
12838
+ const closeToLimit = group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
10546
12839
  if (closeToLimit || exceededLimit || (0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG") || process.env.NEXT_DEBUG_FUNCTION_SIZE) {
10547
12840
  if (exceededLimit) {
10548
12841
  numExceededLimit += 1;
@@ -10558,8 +12851,6 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compr
10558
12851
  if (numExceededLimit || numCloseToLimit) {
10559
12852
  console.log(
10560
12853
  `Warning: Max serverless function size of ${prettyBytes(
10561
- compressedSizeLimit
10562
- )} compressed or ${prettyBytes(
10563
12854
  MAX_UNCOMPRESSED_LAMBDA_SIZE
10564
12855
  )} uncompressed${numExceededLimit ? "" : " almost"} reached`
10565
12856
  );
@@ -10571,7 +12862,6 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compr
10571
12862
  outputFunctionFileSizeInfo(
10572
12863
  group.pages,
10573
12864
  group.pseudoLayer,
10574
- group.pseudoLayerBytes,
10575
12865
  group.pseudoLayerUncompressedBytes,
10576
12866
  compressedPages
10577
12867
  );
@@ -12081,7 +14371,6 @@ async function serverBuild({
12081
14371
  omittedPrerenderRoutes,
12082
14372
  trailingSlashRedirects,
12083
14373
  isCorrectLocaleAPIRoutes,
12084
- lambdaCompressedByteLimit,
12085
14374
  requiredServerFilesManifest,
12086
14375
  variantsManifest,
12087
14376
  experimentalPPRRoutes
@@ -12423,23 +14712,20 @@ async function serverBuild({
12423
14712
  2
12424
14713
  )
12425
14714
  );
12426
- if (initialPseudoLayer.pseudoLayerBytes > lambdaCompressedByteLimit || uncompressedInitialSize > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
14715
+ if (uncompressedInitialSize > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
12427
14716
  console.log(
12428
14717
  `Warning: Max serverless function size of ${(0, import_pretty_bytes3.default)(
12429
- lambdaCompressedByteLimit
12430
- )} compressed or ${(0, import_pretty_bytes3.default)(
12431
14718
  MAX_UNCOMPRESSED_LAMBDA_SIZE
12432
14719
  )} uncompressed reached`
12433
14720
  );
12434
14721
  outputFunctionFileSizeInfo(
12435
14722
  [],
12436
14723
  initialPseudoLayer.pseudoLayer,
12437
- initialPseudoLayer.pseudoLayerBytes,
12438
14724
  uncompressedInitialSize,
12439
14725
  {}
12440
14726
  );
12441
14727
  throw new import_build_utils2.NowBuildError({
12442
- message: `Required files read using Node.js fs library and node_modules exceed max lambda size of ${lambdaCompressedByteLimit} bytes`,
14728
+ message: `Required files read using Node.js fs library and node_modules exceed max lambda size of ${MAX_UNCOMPRESSED_LAMBDA_SIZE} bytes`,
12443
14729
  code: "NEXT_REQUIRED_FILES_LIMIT",
12444
14730
  link: "https://vercel.com/docs/platform/limits#serverless-function-size"
12445
14731
  });
@@ -12601,7 +14887,6 @@ async function serverBuild({
12601
14887
  experimentalPPRRoutes: void 0,
12602
14888
  tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
12603
14889
  initialPseudoLayer,
12604
- lambdaCompressedByteLimit,
12605
14890
  initialPseudoLayerUncompressed: uncompressedInitialSize,
12606
14891
  internalPages,
12607
14892
  pageExtensions
@@ -12621,7 +14906,6 @@ async function serverBuild({
12621
14906
  experimentalPPRRoutes,
12622
14907
  tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
12623
14908
  initialPseudoLayer,
12624
- lambdaCompressedByteLimit,
12625
14909
  initialPseudoLayerUncompressed: uncompressedInitialSize,
12626
14910
  internalPages,
12627
14911
  pageExtensions,
@@ -12639,7 +14923,6 @@ async function serverBuild({
12639
14923
  experimentalPPRRoutes: void 0,
12640
14924
  tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
12641
14925
  initialPseudoLayer,
12642
- lambdaCompressedByteLimit,
12643
14926
  initialPseudoLayerUncompressed: uncompressedInitialSize,
12644
14927
  internalPages,
12645
14928
  pageExtensions,
@@ -12670,7 +14953,6 @@ async function serverBuild({
12670
14953
  tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
12671
14954
  initialPseudoLayer,
12672
14955
  initialPseudoLayerUncompressed: uncompressedInitialSize,
12673
- lambdaCompressedByteLimit,
12674
14956
  internalPages,
12675
14957
  pageExtensions
12676
14958
  });
@@ -12718,14 +15000,16 @@ async function serverBuild({
12718
15000
  ...apiLambdaGroups,
12719
15001
  ...appRouteHandlersLambdaGroups
12720
15002
  ];
12721
- await detectLambdaLimitExceeding(
12722
- combinedGroups,
12723
- lambdaCompressedByteLimit,
12724
- compressedPages
12725
- );
15003
+ await detectLambdaLimitExceeding(combinedGroups, compressedPages);
15004
+ const appNotFoundTraces = pageTraces["_not-found.js"];
15005
+ const appNotFoundPsuedoLayer = appNotFoundTraces && await createPseudoLayer(appNotFoundTraces);
12726
15006
  for (const group of combinedGroups) {
12727
15007
  const groupPageFiles = {};
12728
- for (const page of [...group.pages, ...internalPages]) {
15008
+ for (const page of [
15009
+ ...group.pages,
15010
+ ...internalPages,
15011
+ ...group.isAppRouter && appNotFoundTraces ? ["_not-found.js"] : []
15012
+ ]) {
12729
15013
  const pageFileName = import_path4.default.normalize(
12730
15014
  import_path4.default.relative(baseDir, lambdaPages[page].fsPath)
12731
15015
  );
@@ -12831,6 +15115,9 @@ async function serverBuild({
12831
15115
  nextVersion,
12832
15116
  experimentalAllowBundling
12833
15117
  };
15118
+ if (group.isAppRouter && appNotFoundPsuedoLayer) {
15119
+ options.layers.push(appNotFoundPsuedoLayer.pseudoLayer);
15120
+ }
12834
15121
  const lambda = await createLambdaFromPseudoLayers(options);
12835
15122
  const isPPR = experimental.ppr && group.isAppRouter && !group.isAppRouteHandler;
12836
15123
  let revalidate;
@@ -13827,7 +16114,6 @@ var build = async ({
13827
16114
  meta = {}
13828
16115
  }) => {
13829
16116
  validateEntrypoint(entrypoint);
13830
- const lambdaCompressedByteLimit = config.maxLambdaSize || 50 * MIB;
13831
16117
  let entryDirectory = import_path5.default.dirname(entrypoint);
13832
16118
  let entryPath = import_path5.default.join(workPath, entryDirectory);
13833
16119
  if (config.rootDirectory) {
@@ -13932,6 +16218,20 @@ var build = async ({
13932
16218
  } else {
13933
16219
  await (0, import_build_utils3.runNpmInstall)(entryPath, [], spawnOpts, meta, nodeVersion);
13934
16220
  }
16221
+ if (spawnOpts.env.VERCEL_ANALYTICS_ID) {
16222
+ (0, import_build_utils3.debug)("Found VERCEL_ANALYTICS_ID in environment");
16223
+ const version2 = await (0, import_build_utils3.getInstalledPackageVersion)(
16224
+ "@vercel/speed-insights",
16225
+ entryPath
16226
+ );
16227
+ if (version2) {
16228
+ delete spawnOpts.env.VERCEL_ANALYTICS_ID;
16229
+ delete process.env.VERCEL_ANALYTICS_ID;
16230
+ (0, import_build_utils3.debug)(
16231
+ "@vercel/speed-insights is installed, removing VERCEL_ANALYTICS_ID from environment"
16232
+ );
16233
+ }
16234
+ }
13935
16235
  const nextVersion = getRealNextVersion(entryPath);
13936
16236
  if (!nextVersion) {
13937
16237
  throw new import_build_utils3.NowBuildError({
@@ -14686,7 +16986,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14686
16986
  escapedBuildId,
14687
16987
  outputDirectory,
14688
16988
  trailingSlashRedirects,
14689
- lambdaCompressedByteLimit,
14690
16989
  requiredServerFilesManifest,
14691
16990
  privateOutputs,
14692
16991
  hasIsr404Page,
@@ -14858,7 +17157,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14858
17157
  tracedPseudoLayer: tracedPseudoLayer?.pseudoLayer || {},
14859
17158
  initialPseudoLayer: { pseudoLayer: {}, pseudoLayerBytes: 0 },
14860
17159
  initialPseudoLayerUncompressed: 0,
14861
- lambdaCompressedByteLimit,
14862
17160
  // internal pages are already referenced in traces for serverless
14863
17161
  // like builds
14864
17162
  internalPages: [],
@@ -14875,7 +17173,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14875
17173
  tracedPseudoLayer: tracedPseudoLayer?.pseudoLayer || {},
14876
17174
  initialPseudoLayer: { pseudoLayer: {}, pseudoLayerBytes: 0 },
14877
17175
  initialPseudoLayerUncompressed: 0,
14878
- lambdaCompressedByteLimit,
14879
17176
  internalPages: [],
14880
17177
  experimentalPPRRoutes: void 0
14881
17178
  });
@@ -14906,7 +17203,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
14906
17203
  ];
14907
17204
  await detectLambdaLimitExceeding(
14908
17205
  combinedInitialLambdaGroups,
14909
- lambdaCompressedByteLimit,
14910
17206
  compressedPages
14911
17207
  );
14912
17208
  let apiLambdaGroupIndex = 0;