3002 lines
92 KiB
JavaScript
3002 lines
92 KiB
JavaScript
/******/ (() => { // webpackBootstrap
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
/***/ 963:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
/**
|
|
* A data structure which is a combination of an array and a set. Adding a new
|
|
* member is O(1), testing for membership is O(1), and finding the index of an
|
|
* element is O(1). Removing elements from the set is not supported. Only
|
|
* strings are supported for membership.
|
|
*/
|
|
class ArraySet {
|
|
constructor() {
|
|
this._array = [];
|
|
this._set = new Map();
|
|
}
|
|
|
|
/**
|
|
* Static method for creating ArraySet instances from an existing array.
|
|
*/
|
|
static fromArray(aArray, aAllowDuplicates) {
|
|
const set = new ArraySet();
|
|
for (let i = 0, len = aArray.length; i < len; i++) {
|
|
set.add(aArray[i], aAllowDuplicates);
|
|
}
|
|
return set;
|
|
}
|
|
|
|
/**
|
|
* Return how many unique items are in this ArraySet. If duplicates have been
|
|
* added, than those do not count towards the size.
|
|
*
|
|
* @returns Number
|
|
*/
|
|
size() {
|
|
return this._set.size;
|
|
}
|
|
|
|
/**
|
|
* Add the given string to this set.
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
add(aStr, aAllowDuplicates) {
|
|
const isDuplicate = this.has(aStr);
|
|
const idx = this._array.length;
|
|
if (!isDuplicate || aAllowDuplicates) {
|
|
this._array.push(aStr);
|
|
}
|
|
if (!isDuplicate) {
|
|
this._set.set(aStr, idx);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Is the given string a member of this set?
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
has(aStr) {
|
|
return this._set.has(aStr);
|
|
}
|
|
|
|
/**
|
|
* What is the index of the given string in the array?
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
indexOf(aStr) {
|
|
const idx = this._set.get(aStr);
|
|
if (idx >= 0) {
|
|
return idx;
|
|
}
|
|
throw new Error('"' + aStr + '" is not in the set.');
|
|
}
|
|
|
|
/**
|
|
* What is the element at the given index?
|
|
*
|
|
* @param Number aIdx
|
|
*/
|
|
at(aIdx) {
|
|
if (aIdx >= 0 && aIdx < this._array.length) {
|
|
return this._array[aIdx];
|
|
}
|
|
throw new Error("No element indexed by " + aIdx);
|
|
}
|
|
|
|
/**
|
|
* Returns the array representation of this set (which has the proper indices
|
|
* indicated by indexOf). Note that this is a copy of the internal array used
|
|
* for storing the members so that no one can mess with internal state.
|
|
*/
|
|
toArray() {
|
|
return this._array.slice();
|
|
}
|
|
}
|
|
exports.I = ArraySet;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 344:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*
|
|
* Based on the Base 64 VLQ implementation in Closure Compiler:
|
|
* https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
|
|
*
|
|
* Copyright 2011 The Closure Compiler Authors. All rights reserved.
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of Google Inc. nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
const base64 = __nccwpck_require__(209);
|
|
|
|
// A single base 64 digit can contain 6 bits of data. For the base 64 variable
|
|
// length quantities we use in the source map spec, the first bit is the sign,
|
|
// the next four bits are the actual value, and the 6th bit is the
|
|
// continuation bit. The continuation bit tells us whether there are more
|
|
// digits in this value following this digit.
|
|
//
|
|
// Continuation
|
|
// | Sign
|
|
// | |
|
|
// V V
|
|
// 101011
|
|
|
|
const VLQ_BASE_SHIFT = 5;
|
|
|
|
// binary: 100000
|
|
const VLQ_BASE = 1 << VLQ_BASE_SHIFT;
|
|
|
|
// binary: 011111
|
|
const VLQ_BASE_MASK = VLQ_BASE - 1;
|
|
|
|
// binary: 100000
|
|
const VLQ_CONTINUATION_BIT = VLQ_BASE;
|
|
|
|
/**
|
|
* Converts from a two-complement value to a value where the sign bit is
|
|
* placed in the least significant bit. For example, as decimals:
|
|
* 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
|
|
* 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
|
|
*/
|
|
function toVLQSigned(aValue) {
|
|
return aValue < 0
|
|
? ((-aValue) << 1) + 1
|
|
: (aValue << 1) + 0;
|
|
}
|
|
|
|
/**
|
|
* Converts to a two-complement value from a value where the sign bit is
|
|
* placed in the least significant bit. For example, as decimals:
|
|
* 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
|
|
* 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
|
|
*/
|
|
// eslint-disable-next-line no-unused-vars
|
|
function fromVLQSigned(aValue) {
|
|
const isNegative = (aValue & 1) === 1;
|
|
const shifted = aValue >> 1;
|
|
return isNegative
|
|
? -shifted
|
|
: shifted;
|
|
}
|
|
|
|
/**
|
|
* Returns the base 64 VLQ encoded value.
|
|
*/
|
|
exports.encode = function base64VLQ_encode(aValue) {
|
|
let encoded = "";
|
|
let digit;
|
|
|
|
let vlq = toVLQSigned(aValue);
|
|
|
|
do {
|
|
digit = vlq & VLQ_BASE_MASK;
|
|
vlq >>>= VLQ_BASE_SHIFT;
|
|
if (vlq > 0) {
|
|
// There are still more digits in this value, so we must make sure the
|
|
// continuation bit is marked.
|
|
digit |= VLQ_CONTINUATION_BIT;
|
|
}
|
|
encoded += base64.encode(digit);
|
|
} while (vlq > 0);
|
|
|
|
return encoded;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 209:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
const intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
|
|
|
|
/**
|
|
* Encode an integer in the range of 0 to 63 to a single base 64 digit.
|
|
*/
|
|
exports.encode = function(number) {
|
|
if (0 <= number && number < intToCharMap.length) {
|
|
return intToCharMap[number];
|
|
}
|
|
throw new TypeError("Must be between 0 and 63: " + number);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 700:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
exports.GREATEST_LOWER_BOUND = 1;
|
|
exports.LEAST_UPPER_BOUND = 2;
|
|
|
|
/**
|
|
* Recursive implementation of binary search.
|
|
*
|
|
* @param aLow Indices here and lower do not contain the needle.
|
|
* @param aHigh Indices here and higher do not contain the needle.
|
|
* @param aNeedle The element being searched for.
|
|
* @param aHaystack The non-empty array being searched.
|
|
* @param aCompare Function which takes two elements and returns -1, 0, or 1.
|
|
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
|
|
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
|
|
* closest element that is smaller than or greater than the one we are
|
|
* searching for, respectively, if the exact element cannot be found.
|
|
*/
|
|
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
|
|
// This function terminates when one of the following is true:
|
|
//
|
|
// 1. We find the exact element we are looking for.
|
|
//
|
|
// 2. We did not find the exact element, but we can return the index of
|
|
// the next-closest element.
|
|
//
|
|
// 3. We did not find the exact element, and there is no next-closest
|
|
// element than the one we are searching for, so we return -1.
|
|
const mid = Math.floor((aHigh - aLow) / 2) + aLow;
|
|
const cmp = aCompare(aNeedle, aHaystack[mid], true);
|
|
if (cmp === 0) {
|
|
// Found the element we are looking for.
|
|
return mid;
|
|
} else if (cmp > 0) {
|
|
// Our needle is greater than aHaystack[mid].
|
|
if (aHigh - mid > 1) {
|
|
// The element is in the upper half.
|
|
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
|
|
}
|
|
|
|
// The exact needle element was not found in this haystack. Determine if
|
|
// we are in termination case (3) or (2) and return the appropriate thing.
|
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
|
return aHigh < aHaystack.length ? aHigh : -1;
|
|
}
|
|
return mid;
|
|
}
|
|
|
|
// Our needle is less than aHaystack[mid].
|
|
if (mid - aLow > 1) {
|
|
// The element is in the lower half.
|
|
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
|
|
}
|
|
|
|
// we are in termination case (3) or (2) and return the appropriate thing.
|
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
|
return mid;
|
|
}
|
|
return aLow < 0 ? -1 : aLow;
|
|
}
|
|
|
|
/**
|
|
* This is an implementation of binary search which will always try and return
|
|
* the index of the closest element if there is no exact hit. This is because
|
|
* mappings between original and generated line/col pairs are single points,
|
|
* and there is an implicit region between each of them, so a miss just means
|
|
* that you aren't on the very start of a region.
|
|
*
|
|
* @param aNeedle The element you are looking for.
|
|
* @param aHaystack The array that is being searched.
|
|
* @param aCompare A function which takes the needle and an element in the
|
|
* array and returns -1, 0, or 1 depending on whether the needle is less
|
|
* than, equal to, or greater than the element, respectively.
|
|
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
|
|
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
|
|
* closest element that is smaller than or greater than the one we are
|
|
* searching for, respectively, if the exact element cannot be found.
|
|
* Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
|
|
*/
|
|
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
|
|
if (aHaystack.length === 0) {
|
|
return -1;
|
|
}
|
|
|
|
let index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
|
|
aCompare, aBias || exports.GREATEST_LOWER_BOUND);
|
|
if (index < 0) {
|
|
return -1;
|
|
}
|
|
|
|
// We have found either the exact element, or the next-closest element than
|
|
// the one we are searching for. However, there may be more than one such
|
|
// element. Make sure we always return the smallest of these.
|
|
while (index - 1 >= 0) {
|
|
if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
|
|
break;
|
|
}
|
|
--index;
|
|
}
|
|
|
|
return index;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 371:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2014 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
const util = __nccwpck_require__(354);
|
|
|
|
/**
|
|
* Determine whether mappingB is after mappingA with respect to generated
|
|
* position.
|
|
*/
|
|
function generatedPositionAfter(mappingA, mappingB) {
|
|
// Optimized for most common case
|
|
const lineA = mappingA.generatedLine;
|
|
const lineB = mappingB.generatedLine;
|
|
const columnA = mappingA.generatedColumn;
|
|
const columnB = mappingB.generatedColumn;
|
|
return lineB > lineA || lineB == lineA && columnB >= columnA ||
|
|
util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
|
|
}
|
|
|
|
/**
|
|
* A data structure to provide a sorted view of accumulated mappings in a
|
|
* performance conscious manner. It trades a negligible overhead in general
|
|
* case for a large speedup in case of mappings being added in order.
|
|
*/
|
|
class MappingList {
|
|
constructor() {
|
|
this._array = [];
|
|
this._sorted = true;
|
|
// Serves as infimum
|
|
this._last = {generatedLine: -1, generatedColumn: 0};
|
|
}
|
|
|
|
/**
|
|
* Iterate through internal items. This method takes the same arguments that
|
|
* `Array.prototype.forEach` takes.
|
|
*
|
|
* NOTE: The order of the mappings is NOT guaranteed.
|
|
*/
|
|
unsortedForEach(aCallback, aThisArg) {
|
|
this._array.forEach(aCallback, aThisArg);
|
|
}
|
|
|
|
/**
|
|
* Add the given source mapping.
|
|
*
|
|
* @param Object aMapping
|
|
*/
|
|
add(aMapping) {
|
|
if (generatedPositionAfter(this._last, aMapping)) {
|
|
this._last = aMapping;
|
|
this._array.push(aMapping);
|
|
} else {
|
|
this._sorted = false;
|
|
this._array.push(aMapping);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the flat, sorted array of mappings. The mappings are sorted by
|
|
* generated position.
|
|
*
|
|
* WARNING: This method returns internal data without copying, for
|
|
* performance. The return value must NOT be mutated, and should be treated as
|
|
* an immutable borrow. If you want to take ownership, you must make your own
|
|
* copy.
|
|
*/
|
|
toArray() {
|
|
if (!this._sorted) {
|
|
this._array.sort(util.compareByGeneratedPositionsInflated);
|
|
this._sorted = true;
|
|
}
|
|
return this._array;
|
|
}
|
|
}
|
|
|
|
exports.H = MappingList;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 799:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
// Note: This file is replaced with "read-wasm-browser.js" when this module is
|
|
// bundled with a packager that takes package.json#browser fields into account.
|
|
|
|
const fs = __nccwpck_require__(147);
|
|
const path = __nccwpck_require__(17);
|
|
|
|
module.exports = function readWasm() {
|
|
return new Promise((resolve, reject) => {
|
|
const wasmPath = __nccwpck_require__.ab + "mappings.wasm";
|
|
fs.readFile(__nccwpck_require__.ab + "mappings.wasm", null, (error, data) => {
|
|
if (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
|
|
resolve(data.buffer);
|
|
});
|
|
});
|
|
};
|
|
|
|
module.exports.initialize = _ => {
|
|
console.debug("SourceMapConsumer.initialize is a no-op when running in node.js");
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 886:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
var __webpack_unused_export__;
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
const util = __nccwpck_require__(354);
|
|
const binarySearch = __nccwpck_require__(700);
|
|
const ArraySet = (__nccwpck_require__(963)/* .ArraySet */ .I);
|
|
const base64VLQ = __nccwpck_require__(344); // eslint-disable-line no-unused-vars
|
|
const readWasm = __nccwpck_require__(799);
|
|
const wasm = __nccwpck_require__(776);
|
|
|
|
const INTERNAL = Symbol("smcInternal");
|
|
|
|
class SourceMapConsumer {
|
|
constructor(aSourceMap, aSourceMapURL) {
|
|
// If the constructor was called by super(), just return Promise<this>.
|
|
// Yes, this is a hack to retain the pre-existing API of the base-class
|
|
// constructor also being an async factory function.
|
|
if (aSourceMap == INTERNAL) {
|
|
return Promise.resolve(this);
|
|
}
|
|
|
|
return _factory(aSourceMap, aSourceMapURL);
|
|
}
|
|
|
|
static initialize(opts) {
|
|
readWasm.initialize(opts["lib/mappings.wasm"]);
|
|
}
|
|
|
|
static fromSourceMap(aSourceMap, aSourceMapURL) {
|
|
return _factoryBSM(aSourceMap, aSourceMapURL);
|
|
}
|
|
|
|
/**
|
|
* Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
|
|
* (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
|
|
* function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
|
|
* for `f` to complete, call `destroy` on the consumer, and return `f`'s return
|
|
* value.
|
|
*
|
|
* You must not use the consumer after `f` completes!
|
|
*
|
|
* By using `with`, you do not have to remember to manually call `destroy` on
|
|
* the consumer, since it will be called automatically once `f` completes.
|
|
*
|
|
* ```js
|
|
* const xSquared = await SourceMapConsumer.with(
|
|
* myRawSourceMap,
|
|
* null,
|
|
* async function (consumer) {
|
|
* // Use `consumer` inside here and don't worry about remembering
|
|
* // to call `destroy`.
|
|
*
|
|
* const x = await whatever(consumer);
|
|
* return x * x;
|
|
* }
|
|
* );
|
|
*
|
|
* // You may not use that `consumer` anymore out here; it has
|
|
* // been destroyed. But you can use `xSquared`.
|
|
* console.log(xSquared);
|
|
* ```
|
|
*/
|
|
static async with(rawSourceMap, sourceMapUrl, f) {
|
|
const consumer = await new SourceMapConsumer(rawSourceMap, sourceMapUrl);
|
|
try {
|
|
return await f(consumer);
|
|
} finally {
|
|
consumer.destroy();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Iterate over each mapping between an original source/line/column and a
|
|
* generated line/column in this source map.
|
|
*
|
|
* @param Function aCallback
|
|
* The function that is called with each mapping.
|
|
* @param Object aContext
|
|
* Optional. If specified, this object will be the value of `this` every
|
|
* time that `aCallback` is called.
|
|
* @param aOrder
|
|
* Either `SourceMapConsumer.GENERATED_ORDER` or
|
|
* `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
|
|
* iterate over the mappings sorted by the generated file's line/column
|
|
* order or the original's source/line/column order, respectively. Defaults to
|
|
* `SourceMapConsumer.GENERATED_ORDER`.
|
|
*/
|
|
eachMapping(aCallback, aContext, aOrder) {
|
|
throw new Error("Subclasses must implement eachMapping");
|
|
}
|
|
|
|
/**
|
|
* Returns all generated line and column information for the original source,
|
|
* line, and column provided. If no column is provided, returns all mappings
|
|
* corresponding to a either the line we are searching for or the next
|
|
* closest line that has any mappings. Otherwise, returns all mappings
|
|
* corresponding to the given line and either the column we are searching for
|
|
* or the next closest column that has any offsets.
|
|
*
|
|
* The only argument is an object with the following properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source. The line number is 1-based.
|
|
* - column: Optional. the column number in the original source.
|
|
* The column number is 0-based.
|
|
*
|
|
* and an array of objects is returned, each with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null. The
|
|
* line number is 1-based.
|
|
* - column: The column number in the generated source, or null.
|
|
* The column number is 0-based.
|
|
*/
|
|
allGeneratedPositionsFor(aArgs) {
|
|
throw new Error("Subclasses must implement allGeneratedPositionsFor");
|
|
}
|
|
|
|
destroy() {
|
|
throw new Error("Subclasses must implement destroy");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The version of the source mapping spec that we are consuming.
|
|
*/
|
|
SourceMapConsumer.prototype._version = 3;
|
|
SourceMapConsumer.GENERATED_ORDER = 1;
|
|
SourceMapConsumer.ORIGINAL_ORDER = 2;
|
|
|
|
SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
|
|
SourceMapConsumer.LEAST_UPPER_BOUND = 2;
|
|
|
|
exports.SourceMapConsumer = SourceMapConsumer;
|
|
|
|
/**
|
|
* A BasicSourceMapConsumer instance represents a parsed source map which we can
|
|
* query for information about the original file positions by giving it a file
|
|
* position in the generated source.
|
|
*
|
|
* The first parameter is the raw source map (either as a JSON string, or
|
|
* already parsed to an object). According to the spec, source maps have the
|
|
* following attributes:
|
|
*
|
|
* - version: Which version of the source map spec this map is following.
|
|
* - sources: An array of URLs to the original source files.
|
|
* - names: An array of identifiers which can be referenced by individual mappings.
|
|
* - sourceRoot: Optional. The URL root from which all sources are relative.
|
|
* - sourcesContent: Optional. An array of contents of the original source files.
|
|
* - mappings: A string of base64 VLQs which contain the actual mappings.
|
|
* - file: Optional. The generated file this source map is associated with.
|
|
*
|
|
* Here is an example source map, taken from the source map spec[0]:
|
|
*
|
|
* {
|
|
* version : 3,
|
|
* file: "out.js",
|
|
* sourceRoot : "",
|
|
* sources: ["foo.js", "bar.js"],
|
|
* names: ["src", "maps", "are", "fun"],
|
|
* mappings: "AA,AB;;ABCDE;"
|
|
* }
|
|
*
|
|
* The second parameter, if given, is a string whose value is the URL
|
|
* at which the source map was found. This URL is used to compute the
|
|
* sources array.
|
|
*
|
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
|
|
*/
|
|
class BasicSourceMapConsumer extends SourceMapConsumer {
|
|
constructor(aSourceMap, aSourceMapURL) {
|
|
return super(INTERNAL).then(that => {
|
|
let sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === "string") {
|
|
sourceMap = util.parseSourceMapInput(aSourceMap);
|
|
}
|
|
|
|
const version = util.getArg(sourceMap, "version");
|
|
const sources = util.getArg(sourceMap, "sources").map(String);
|
|
// Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
|
|
// requires the array) to play nice here.
|
|
const names = util.getArg(sourceMap, "names", []);
|
|
const sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
|
|
const sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
|
|
const mappings = util.getArg(sourceMap, "mappings");
|
|
const file = util.getArg(sourceMap, "file", null);
|
|
|
|
// Once again, Sass deviates from the spec and supplies the version as a
|
|
// string rather than a number, so we use loose equality checking here.
|
|
if (version != that._version) {
|
|
throw new Error("Unsupported version: " + version);
|
|
}
|
|
|
|
that._sourceLookupCache = new Map();
|
|
|
|
// Pass `true` below to allow duplicate names and sources. While source maps
|
|
// are intended to be compressed and deduplicated, the TypeScript compiler
|
|
// sometimes generates source maps with duplicates in them. See Github issue
|
|
// #72 and bugzil.la/889492.
|
|
that._names = ArraySet.fromArray(names.map(String), true);
|
|
that._sources = ArraySet.fromArray(sources, true);
|
|
|
|
that._absoluteSources = ArraySet.fromArray(that._sources.toArray().map(function(s) {
|
|
return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
|
|
}), true);
|
|
|
|
that.sourceRoot = sourceRoot;
|
|
that.sourcesContent = sourcesContent;
|
|
that._mappings = mappings;
|
|
that._sourceMapURL = aSourceMapURL;
|
|
that.file = file;
|
|
|
|
that._computedColumnSpans = false;
|
|
that._mappingsPtr = 0;
|
|
that._wasm = null;
|
|
|
|
return wasm().then(w => {
|
|
that._wasm = w;
|
|
return that;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Utility function to find the index of a source. Returns -1 if not
|
|
* found.
|
|
*/
|
|
_findSourceIndex(aSource) {
|
|
// In the most common usecases, we'll be constantly looking up the index for the same source
|
|
// files, so we cache the index lookup to avoid constantly recomputing the full URLs.
|
|
const cachedIndex = this._sourceLookupCache.get(aSource);
|
|
if (typeof cachedIndex === "number") {
|
|
return cachedIndex;
|
|
}
|
|
|
|
// Treat the source as map-relative overall by default.
|
|
const sourceAsMapRelative = util.computeSourceURL(null, aSource, this._sourceMapURL);
|
|
if (this._absoluteSources.has(sourceAsMapRelative)) {
|
|
const index = this._absoluteSources.indexOf(sourceAsMapRelative);
|
|
this._sourceLookupCache.set(aSource, index);
|
|
return index;
|
|
}
|
|
|
|
// Fall back to treating the source as sourceRoot-relative.
|
|
const sourceAsSourceRootRelative = util.computeSourceURL(this.sourceRoot, aSource, this._sourceMapURL);
|
|
if (this._absoluteSources.has(sourceAsSourceRootRelative)) {
|
|
const index = this._absoluteSources.indexOf(sourceAsSourceRootRelative);
|
|
this._sourceLookupCache.set(aSource, index);
|
|
return index;
|
|
}
|
|
|
|
// To avoid this cache growing forever, we do not cache lookup misses.
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Create a BasicSourceMapConsumer from a SourceMapGenerator.
|
|
*
|
|
* @param SourceMapGenerator aSourceMap
|
|
* The source map that will be consumed.
|
|
* @param String aSourceMapURL
|
|
* The URL at which the source map can be found (optional)
|
|
* @returns BasicSourceMapConsumer
|
|
*/
|
|
static fromSourceMap(aSourceMap, aSourceMapURL) {
|
|
return new BasicSourceMapConsumer(aSourceMap.toString());
|
|
}
|
|
|
|
get sources() {
|
|
return this._absoluteSources.toArray();
|
|
}
|
|
|
|
_getMappingsPtr() {
|
|
if (this._mappingsPtr === 0) {
|
|
this._parseMappings();
|
|
}
|
|
|
|
return this._mappingsPtr;
|
|
}
|
|
|
|
/**
|
|
* Parse the mappings in a string in to a data structure which we can easily
|
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
|
* `this.__originalMappings` properties).
|
|
*/
|
|
_parseMappings() {
|
|
const aStr = this._mappings;
|
|
const size = aStr.length;
|
|
|
|
const mappingsBufPtr = this._wasm.exports.allocate_mappings(size);
|
|
const mappingsBuf = new Uint8Array(this._wasm.exports.memory.buffer, mappingsBufPtr, size);
|
|
for (let i = 0; i < size; i++) {
|
|
mappingsBuf[i] = aStr.charCodeAt(i);
|
|
}
|
|
|
|
const mappingsPtr = this._wasm.exports.parse_mappings(mappingsBufPtr);
|
|
|
|
if (!mappingsPtr) {
|
|
const error = this._wasm.exports.get_last_error();
|
|
let msg = `Error parsing mappings (code ${error}): `;
|
|
|
|
// XXX: keep these error codes in sync with `fitzgen/source-map-mappings`.
|
|
switch (error) {
|
|
case 1:
|
|
msg += "the mappings contained a negative line, column, source index, or name index";
|
|
break;
|
|
case 2:
|
|
msg += "the mappings contained a number larger than 2**32";
|
|
break;
|
|
case 3:
|
|
msg += "reached EOF while in the middle of parsing a VLQ";
|
|
break;
|
|
case 4:
|
|
msg += "invalid base 64 character while parsing a VLQ";
|
|
break;
|
|
default:
|
|
msg += "unknown error code";
|
|
break;
|
|
}
|
|
|
|
throw new Error(msg);
|
|
}
|
|
|
|
this._mappingsPtr = mappingsPtr;
|
|
}
|
|
|
|
eachMapping(aCallback, aContext, aOrder) {
|
|
const context = aContext || null;
|
|
const order = aOrder || SourceMapConsumer.GENERATED_ORDER;
|
|
|
|
this._wasm.withMappingCallback(
|
|
mapping => {
|
|
if (mapping.source !== null) {
|
|
mapping.source = this._absoluteSources.at(mapping.source);
|
|
|
|
if (mapping.name !== null) {
|
|
mapping.name = this._names.at(mapping.name);
|
|
}
|
|
}
|
|
if (this._computedColumnSpans && mapping.lastGeneratedColumn === null) {
|
|
mapping.lastGeneratedColumn = Infinity;
|
|
}
|
|
|
|
aCallback.call(context, mapping);
|
|
},
|
|
() => {
|
|
switch (order) {
|
|
case SourceMapConsumer.GENERATED_ORDER:
|
|
this._wasm.exports.by_generated_location(this._getMappingsPtr());
|
|
break;
|
|
case SourceMapConsumer.ORIGINAL_ORDER:
|
|
this._wasm.exports.by_original_location(this._getMappingsPtr());
|
|
break;
|
|
default:
|
|
throw new Error("Unknown order of iteration.");
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
allGeneratedPositionsFor(aArgs) {
|
|
let source = util.getArg(aArgs, "source");
|
|
const originalLine = util.getArg(aArgs, "line");
|
|
const originalColumn = aArgs.column || 0;
|
|
|
|
source = this._findSourceIndex(source);
|
|
if (source < 0) {
|
|
return [];
|
|
}
|
|
|
|
if (originalLine < 1) {
|
|
throw new Error("Line numbers must be >= 1");
|
|
}
|
|
|
|
if (originalColumn < 0) {
|
|
throw new Error("Column numbers must be >= 0");
|
|
}
|
|
|
|
const mappings = [];
|
|
|
|
this._wasm.withMappingCallback(
|
|
m => {
|
|
let lastColumn = m.lastGeneratedColumn;
|
|
if (this._computedColumnSpans && lastColumn === null) {
|
|
lastColumn = Infinity;
|
|
}
|
|
mappings.push({
|
|
line: m.generatedLine,
|
|
column: m.generatedColumn,
|
|
lastColumn,
|
|
});
|
|
}, () => {
|
|
this._wasm.exports.all_generated_locations_for(
|
|
this._getMappingsPtr(),
|
|
source,
|
|
originalLine - 1,
|
|
"column" in aArgs,
|
|
originalColumn
|
|
);
|
|
}
|
|
);
|
|
|
|
return mappings;
|
|
}
|
|
|
|
destroy() {
|
|
if (this._mappingsPtr !== 0) {
|
|
this._wasm.exports.free_mappings(this._mappingsPtr);
|
|
this._mappingsPtr = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compute the last column for each generated mapping. The last column is
|
|
* inclusive.
|
|
*/
|
|
computeColumnSpans() {
|
|
if (this._computedColumnSpans) {
|
|
return;
|
|
}
|
|
|
|
this._wasm.exports.compute_column_spans(this._getMappingsPtr());
|
|
this._computedColumnSpans = true;
|
|
}
|
|
|
|
/**
|
|
* Returns the original source, line, and column information for the generated
|
|
* source's line and column positions provided. The only argument is an object
|
|
* with the following properties:
|
|
*
|
|
* - line: The line number in the generated source. The line number
|
|
* is 1-based.
|
|
* - column: The column number in the generated source. The column
|
|
* number is 0-based.
|
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
|
* closest element that is smaller than or greater than the one we are
|
|
* searching for, respectively, if the exact element cannot be found.
|
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - source: The original source file, or null.
|
|
* - line: The line number in the original source, or null. The
|
|
* line number is 1-based.
|
|
* - column: The column number in the original source, or null. The
|
|
* column number is 0-based.
|
|
* - name: The original identifier, or null.
|
|
*/
|
|
originalPositionFor(aArgs) {
|
|
const needle = {
|
|
generatedLine: util.getArg(aArgs, "line"),
|
|
generatedColumn: util.getArg(aArgs, "column")
|
|
};
|
|
|
|
if (needle.generatedLine < 1) {
|
|
throw new Error("Line numbers must be >= 1");
|
|
}
|
|
|
|
if (needle.generatedColumn < 0) {
|
|
throw new Error("Column numbers must be >= 0");
|
|
}
|
|
|
|
let bias = util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND);
|
|
if (bias == null) {
|
|
bias = SourceMapConsumer.GREATEST_LOWER_BOUND;
|
|
}
|
|
|
|
let mapping;
|
|
this._wasm.withMappingCallback(m => mapping = m, () => {
|
|
this._wasm.exports.original_location_for(
|
|
this._getMappingsPtr(),
|
|
needle.generatedLine - 1,
|
|
needle.generatedColumn,
|
|
bias
|
|
);
|
|
});
|
|
|
|
if (mapping) {
|
|
if (mapping.generatedLine === needle.generatedLine) {
|
|
let source = util.getArg(mapping, "source", null);
|
|
if (source !== null) {
|
|
source = this._absoluteSources.at(source);
|
|
}
|
|
|
|
let name = util.getArg(mapping, "name", null);
|
|
if (name !== null) {
|
|
name = this._names.at(name);
|
|
}
|
|
|
|
return {
|
|
source,
|
|
line: util.getArg(mapping, "originalLine", null),
|
|
column: util.getArg(mapping, "originalColumn", null),
|
|
name
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
source: null,
|
|
line: null,
|
|
column: null,
|
|
name: null
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Return true if we have the source content for every source in the source
|
|
* map, false otherwise.
|
|
*/
|
|
hasContentsOfAllSources() {
|
|
if (!this.sourcesContent) {
|
|
return false;
|
|
}
|
|
return this.sourcesContent.length >= this._sources.size() &&
|
|
!this.sourcesContent.some(function(sc) { return sc == null; });
|
|
}
|
|
|
|
/**
|
|
* Returns the original source content. The only argument is the url of the
|
|
* original source file. Returns null if no original source content is
|
|
* available.
|
|
*/
|
|
sourceContentFor(aSource, nullOnMissing) {
|
|
if (!this.sourcesContent) {
|
|
return null;
|
|
}
|
|
|
|
const index = this._findSourceIndex(aSource);
|
|
if (index >= 0) {
|
|
return this.sourcesContent[index];
|
|
}
|
|
|
|
// This function is used recursively from
|
|
// IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
|
|
// don't want to throw if we can't find the source - we just want to
|
|
// return null, so we provide a flag to exit gracefully.
|
|
if (nullOnMissing) {
|
|
return null;
|
|
}
|
|
|
|
throw new Error('"' + aSource + '" is not in the SourceMap.');
|
|
}
|
|
|
|
/**
|
|
* Returns the generated line and column information for the original source,
|
|
* line, and column positions provided. The only argument is an object with
|
|
* the following properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source. The line number
|
|
* is 1-based.
|
|
* - column: The column number in the original source. The column
|
|
* number is 0-based.
|
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
|
* closest element that is smaller than or greater than the one we are
|
|
* searching for, respectively, if the exact element cannot be found.
|
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null. The
|
|
* line number is 1-based.
|
|
* - column: The column number in the generated source, or null.
|
|
* The column number is 0-based.
|
|
*/
|
|
generatedPositionFor(aArgs) {
|
|
let source = util.getArg(aArgs, "source");
|
|
source = this._findSourceIndex(source);
|
|
if (source < 0) {
|
|
return {
|
|
line: null,
|
|
column: null,
|
|
lastColumn: null
|
|
};
|
|
}
|
|
|
|
const needle = {
|
|
source,
|
|
originalLine: util.getArg(aArgs, "line"),
|
|
originalColumn: util.getArg(aArgs, "column")
|
|
};
|
|
|
|
if (needle.originalLine < 1) {
|
|
throw new Error("Line numbers must be >= 1");
|
|
}
|
|
|
|
if (needle.originalColumn < 0) {
|
|
throw new Error("Column numbers must be >= 0");
|
|
}
|
|
|
|
let bias = util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND);
|
|
if (bias == null) {
|
|
bias = SourceMapConsumer.GREATEST_LOWER_BOUND;
|
|
}
|
|
|
|
let mapping;
|
|
this._wasm.withMappingCallback(m => mapping = m, () => {
|
|
this._wasm.exports.generated_location_for(
|
|
this._getMappingsPtr(),
|
|
needle.source,
|
|
needle.originalLine - 1,
|
|
needle.originalColumn,
|
|
bias
|
|
);
|
|
});
|
|
|
|
if (mapping) {
|
|
if (mapping.source === needle.source) {
|
|
let lastColumn = mapping.lastGeneratedColumn;
|
|
if (this._computedColumnSpans && lastColumn === null) {
|
|
lastColumn = Infinity;
|
|
}
|
|
return {
|
|
line: util.getArg(mapping, "generatedLine", null),
|
|
column: util.getArg(mapping, "generatedColumn", null),
|
|
lastColumn,
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
line: null,
|
|
column: null,
|
|
lastColumn: null
|
|
};
|
|
}
|
|
}
|
|
|
|
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
|
|
__webpack_unused_export__ = BasicSourceMapConsumer;
|
|
|
|
/**
|
|
* An IndexedSourceMapConsumer instance represents a parsed source map which
|
|
* we can query for information. It differs from BasicSourceMapConsumer in
|
|
* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
|
|
* input.
|
|
*
|
|
* The first parameter is a raw source map (either as a JSON string, or already
|
|
* parsed to an object). According to the spec for indexed source maps, they
|
|
* have the following attributes:
|
|
*
|
|
* - version: Which version of the source map spec this map is following.
|
|
* - file: Optional. The generated file this source map is associated with.
|
|
* - sections: A list of section definitions.
|
|
*
|
|
* Each value under the "sections" field has two fields:
|
|
* - offset: The offset into the original specified at which this section
|
|
* begins to apply, defined as an object with a "line" and "column"
|
|
* field.
|
|
* - map: A source map definition. This source map could also be indexed,
|
|
* but doesn't have to be.
|
|
*
|
|
* Instead of the "map" field, it's also possible to have a "url" field
|
|
* specifying a URL to retrieve a source map from, but that's currently
|
|
* unsupported.
|
|
*
|
|
* Here's an example source map, taken from the source map spec[0], but
|
|
* modified to omit a section which uses the "url" field.
|
|
*
|
|
* {
|
|
* version : 3,
|
|
* file: "app.js",
|
|
* sections: [{
|
|
* offset: {line:100, column:10},
|
|
* map: {
|
|
* version : 3,
|
|
* file: "section.js",
|
|
* sources: ["foo.js", "bar.js"],
|
|
* names: ["src", "maps", "are", "fun"],
|
|
* mappings: "AAAA,E;;ABCDE;"
|
|
* }
|
|
* }],
|
|
* }
|
|
*
|
|
* The second parameter, if given, is a string whose value is the URL
|
|
* at which the source map was found. This URL is used to compute the
|
|
* sources array.
|
|
*
|
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
|
|
*/
|
|
class IndexedSourceMapConsumer extends SourceMapConsumer {
|
|
constructor(aSourceMap, aSourceMapURL) {
|
|
return super(INTERNAL).then(that => {
|
|
let sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === "string") {
|
|
sourceMap = util.parseSourceMapInput(aSourceMap);
|
|
}
|
|
|
|
const version = util.getArg(sourceMap, "version");
|
|
const sections = util.getArg(sourceMap, "sections");
|
|
|
|
if (version != that._version) {
|
|
throw new Error("Unsupported version: " + version);
|
|
}
|
|
|
|
let lastOffset = {
|
|
line: -1,
|
|
column: 0
|
|
};
|
|
return Promise.all(sections.map(s => {
|
|
if (s.url) {
|
|
// The url field will require support for asynchronicity.
|
|
// See https://github.com/mozilla/source-map/issues/16
|
|
throw new Error("Support for url field in sections not implemented.");
|
|
}
|
|
const offset = util.getArg(s, "offset");
|
|
const offsetLine = util.getArg(offset, "line");
|
|
const offsetColumn = util.getArg(offset, "column");
|
|
|
|
if (offsetLine < lastOffset.line ||
|
|
(offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
|
|
throw new Error("Section offsets must be ordered and non-overlapping.");
|
|
}
|
|
lastOffset = offset;
|
|
|
|
const cons = new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL);
|
|
return cons.then(consumer => {
|
|
return {
|
|
generatedOffset: {
|
|
// The offset fields are 0-based, but we use 1-based indices when
|
|
// encoding/decoding from VLQ.
|
|
generatedLine: offsetLine + 1,
|
|
generatedColumn: offsetColumn + 1
|
|
},
|
|
consumer
|
|
};
|
|
});
|
|
})).then(s => {
|
|
that._sections = s;
|
|
return that;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* The list of original sources.
|
|
*/
|
|
get sources() {
|
|
const sources = [];
|
|
for (let i = 0; i < this._sections.length; i++) {
|
|
for (let j = 0; j < this._sections[i].consumer.sources.length; j++) {
|
|
sources.push(this._sections[i].consumer.sources[j]);
|
|
}
|
|
}
|
|
return sources;
|
|
}
|
|
|
|
/**
|
|
* Returns the original source, line, and column information for the generated
|
|
* source's line and column positions provided. The only argument is an object
|
|
* with the following properties:
|
|
*
|
|
* - line: The line number in the generated source. The line number
|
|
* is 1-based.
|
|
* - column: The column number in the generated source. The column
|
|
* number is 0-based.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - source: The original source file, or null.
|
|
* - line: The line number in the original source, or null. The
|
|
* line number is 1-based.
|
|
* - column: The column number in the original source, or null. The
|
|
* column number is 0-based.
|
|
* - name: The original identifier, or null.
|
|
*/
|
|
originalPositionFor(aArgs) {
|
|
const needle = {
|
|
generatedLine: util.getArg(aArgs, "line"),
|
|
generatedColumn: util.getArg(aArgs, "column")
|
|
};
|
|
|
|
// Find the section containing the generated position we're trying to map
|
|
// to an original position.
|
|
const sectionIndex = binarySearch.search(needle, this._sections,
|
|
function(aNeedle, section) {
|
|
const cmp = aNeedle.generatedLine - section.generatedOffset.generatedLine;
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
|
|
return (aNeedle.generatedColumn -
|
|
section.generatedOffset.generatedColumn);
|
|
});
|
|
const section = this._sections[sectionIndex];
|
|
|
|
if (!section) {
|
|
return {
|
|
source: null,
|
|
line: null,
|
|
column: null,
|
|
name: null
|
|
};
|
|
}
|
|
|
|
return section.consumer.originalPositionFor({
|
|
line: needle.generatedLine -
|
|
(section.generatedOffset.generatedLine - 1),
|
|
column: needle.generatedColumn -
|
|
(section.generatedOffset.generatedLine === needle.generatedLine
|
|
? section.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
bias: aArgs.bias
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Return true if we have the source content for every source in the source
|
|
* map, false otherwise.
|
|
*/
|
|
hasContentsOfAllSources() {
|
|
return this._sections.every(function(s) {
|
|
return s.consumer.hasContentsOfAllSources();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Returns the original source content. The only argument is the url of the
|
|
* original source file. Returns null if no original source content is
|
|
* available.
|
|
*/
|
|
sourceContentFor(aSource, nullOnMissing) {
|
|
for (let i = 0; i < this._sections.length; i++) {
|
|
const section = this._sections[i];
|
|
|
|
const content = section.consumer.sourceContentFor(aSource, true);
|
|
if (content) {
|
|
return content;
|
|
}
|
|
}
|
|
if (nullOnMissing) {
|
|
return null;
|
|
}
|
|
throw new Error('"' + aSource + '" is not in the SourceMap.');
|
|
}
|
|
|
|
_findSectionIndex(source) {
|
|
for (let i = 0; i < this._sections.length; i++) {
|
|
const { consumer } = this._sections[i];
|
|
if (consumer._findSourceIndex(source) !== -1) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Returns the generated line and column information for the original source,
|
|
* line, and column positions provided. The only argument is an object with
|
|
* the following properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source. The line number
|
|
* is 1-based.
|
|
* - column: The column number in the original source. The column
|
|
* number is 0-based.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null. The
|
|
* line number is 1-based.
|
|
* - column: The column number in the generated source, or null.
|
|
* The column number is 0-based.
|
|
*/
|
|
generatedPositionFor(aArgs) {
|
|
const index = this._findSectionIndex(util.getArg(aArgs, "source"));
|
|
const section = index >= 0 ? this._sections[index] : null;
|
|
const nextSection =
|
|
index >= 0 && index + 1 < this._sections.length
|
|
? this._sections[index + 1]
|
|
: null;
|
|
|
|
const generatedPosition =
|
|
section && section.consumer.generatedPositionFor(aArgs);
|
|
if (generatedPosition && generatedPosition.line !== null) {
|
|
const lineShift = section.generatedOffset.generatedLine - 1;
|
|
const columnShift = section.generatedOffset.generatedColumn - 1;
|
|
|
|
if (generatedPosition.line === 1) {
|
|
generatedPosition.column += columnShift;
|
|
if (typeof generatedPosition.lastColumn === "number") {
|
|
generatedPosition.lastColumn += columnShift;
|
|
}
|
|
}
|
|
|
|
if (
|
|
generatedPosition.lastColumn === Infinity &&
|
|
nextSection &&
|
|
generatedPosition.line === nextSection.generatedOffset.generatedLine
|
|
) {
|
|
generatedPosition.lastColumn =
|
|
nextSection.generatedOffset.generatedColumn - 2;
|
|
}
|
|
generatedPosition.line += lineShift;
|
|
|
|
return generatedPosition;
|
|
}
|
|
|
|
return {
|
|
line: null,
|
|
column: null,
|
|
lastColumn: null
|
|
};
|
|
}
|
|
|
|
allGeneratedPositionsFor(aArgs) {
|
|
const index = this._findSectionIndex(util.getArg(aArgs, "source"));
|
|
const section = index >= 0 ? this._sections[index] : null;
|
|
const nextSection =
|
|
index >= 0 && index + 1 < this._sections.length
|
|
? this._sections[index + 1]
|
|
: null;
|
|
|
|
if (!section) return [];
|
|
|
|
return section.consumer.allGeneratedPositionsFor(aArgs).map(
|
|
generatedPosition => {
|
|
const lineShift = section.generatedOffset.generatedLine - 1;
|
|
const columnShift = section.generatedOffset.generatedColumn - 1;
|
|
|
|
if (generatedPosition.line === 1) {
|
|
generatedPosition.column += columnShift;
|
|
if (typeof generatedPosition.lastColumn === "number") {
|
|
generatedPosition.lastColumn += columnShift;
|
|
}
|
|
}
|
|
|
|
if (
|
|
generatedPosition.lastColumn === Infinity &&
|
|
nextSection &&
|
|
generatedPosition.line === nextSection.generatedOffset.generatedLine
|
|
) {
|
|
generatedPosition.lastColumn =
|
|
nextSection.generatedOffset.generatedColumn - 2;
|
|
}
|
|
generatedPosition.line += lineShift;
|
|
|
|
return generatedPosition;
|
|
}
|
|
);
|
|
}
|
|
|
|
eachMapping(aCallback, aContext, aOrder) {
|
|
this._sections.forEach((section, index) => {
|
|
const nextSection =
|
|
index + 1 < this._sections.length
|
|
? this._sections[index + 1]
|
|
: null;
|
|
const { generatedOffset } = section;
|
|
|
|
const lineShift = generatedOffset.generatedLine - 1;
|
|
const columnShift = generatedOffset.generatedColumn - 1;
|
|
|
|
section.consumer.eachMapping(function(mapping) {
|
|
if (mapping.generatedLine === 1) {
|
|
mapping.generatedColumn += columnShift;
|
|
|
|
if (typeof mapping.lastGeneratedColumn === "number") {
|
|
mapping.lastGeneratedColumn += columnShift;
|
|
}
|
|
}
|
|
|
|
if (
|
|
mapping.lastGeneratedColumn === Infinity &&
|
|
nextSection &&
|
|
mapping.generatedLine === nextSection.generatedOffset.generatedLine
|
|
) {
|
|
mapping.lastGeneratedColumn =
|
|
nextSection.generatedOffset.generatedColumn - 2;
|
|
}
|
|
mapping.generatedLine += lineShift;
|
|
|
|
aCallback.call(this, mapping);
|
|
}, aContext, aOrder);
|
|
});
|
|
}
|
|
|
|
computeColumnSpans() {
|
|
for (let i = 0; i < this._sections.length; i++) {
|
|
this._sections[i].consumer.computeColumnSpans();
|
|
}
|
|
}
|
|
|
|
destroy() {
|
|
for (let i = 0; i < this._sections.length; i++) {
|
|
this._sections[i].consumer.destroy();
|
|
}
|
|
}
|
|
}
|
|
__webpack_unused_export__ = IndexedSourceMapConsumer;
|
|
|
|
/*
|
|
* Cheat to get around inter-twingled classes. `factory()` can be at the end
|
|
* where it has access to non-hoisted classes, but it gets hoisted itself.
|
|
*/
|
|
function _factory(aSourceMap, aSourceMapURL) {
|
|
let sourceMap = aSourceMap;
|
|
if (typeof aSourceMap === "string") {
|
|
sourceMap = util.parseSourceMapInput(aSourceMap);
|
|
}
|
|
|
|
const consumer = sourceMap.sections != null
|
|
? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
|
|
: new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
|
|
return Promise.resolve(consumer);
|
|
}
|
|
|
|
function _factoryBSM(aSourceMap, aSourceMapURL) {
|
|
return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 87:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
const base64VLQ = __nccwpck_require__(344);
|
|
const util = __nccwpck_require__(354);
|
|
const ArraySet = (__nccwpck_require__(963)/* .ArraySet */ .I);
|
|
const MappingList = (__nccwpck_require__(371)/* .MappingList */ .H);
|
|
|
|
/**
|
|
* An instance of the SourceMapGenerator represents a source map which is
|
|
* being built incrementally. You may pass an object with the following
|
|
* properties:
|
|
*
|
|
* - file: The filename of the generated source.
|
|
* - sourceRoot: A root for all relative URLs in this source map.
|
|
*/
|
|
class SourceMapGenerator {
|
|
constructor(aArgs) {
|
|
if (!aArgs) {
|
|
aArgs = {};
|
|
}
|
|
this._file = util.getArg(aArgs, "file", null);
|
|
this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
|
|
this._skipValidation = util.getArg(aArgs, "skipValidation", false);
|
|
this._sources = new ArraySet();
|
|
this._names = new ArraySet();
|
|
this._mappings = new MappingList();
|
|
this._sourcesContents = null;
|
|
}
|
|
|
|
/**
|
|
* Creates a new SourceMapGenerator based on a SourceMapConsumer
|
|
*
|
|
* @param aSourceMapConsumer The SourceMap.
|
|
*/
|
|
static fromSourceMap(aSourceMapConsumer) {
|
|
const sourceRoot = aSourceMapConsumer.sourceRoot;
|
|
const generator = new SourceMapGenerator({
|
|
file: aSourceMapConsumer.file,
|
|
sourceRoot
|
|
});
|
|
aSourceMapConsumer.eachMapping(function(mapping) {
|
|
const newMapping = {
|
|
generated: {
|
|
line: mapping.generatedLine,
|
|
column: mapping.generatedColumn
|
|
}
|
|
};
|
|
|
|
if (mapping.source != null) {
|
|
newMapping.source = mapping.source;
|
|
if (sourceRoot != null) {
|
|
newMapping.source = util.relative(sourceRoot, newMapping.source);
|
|
}
|
|
|
|
newMapping.original = {
|
|
line: mapping.originalLine,
|
|
column: mapping.originalColumn
|
|
};
|
|
|
|
if (mapping.name != null) {
|
|
newMapping.name = mapping.name;
|
|
}
|
|
}
|
|
|
|
generator.addMapping(newMapping);
|
|
});
|
|
aSourceMapConsumer.sources.forEach(function(sourceFile) {
|
|
let sourceRelative = sourceFile;
|
|
if (sourceRoot !== null) {
|
|
sourceRelative = util.relative(sourceRoot, sourceFile);
|
|
}
|
|
|
|
if (!generator._sources.has(sourceRelative)) {
|
|
generator._sources.add(sourceRelative);
|
|
}
|
|
|
|
const content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
generator.setSourceContent(sourceFile, content);
|
|
}
|
|
});
|
|
return generator;
|
|
}
|
|
|
|
/**
|
|
* Add a single mapping from original source line and column to the generated
|
|
* source's line and column for this source map being created. The mapping
|
|
* object should have the following properties:
|
|
*
|
|
* - generated: An object with the generated line and column positions.
|
|
* - original: An object with the original line and column positions.
|
|
* - source: The original source file (relative to the sourceRoot).
|
|
* - name: An optional original token name for this mapping.
|
|
*/
|
|
addMapping(aArgs) {
|
|
const generated = util.getArg(aArgs, "generated");
|
|
const original = util.getArg(aArgs, "original", null);
|
|
let source = util.getArg(aArgs, "source", null);
|
|
let name = util.getArg(aArgs, "name", null);
|
|
|
|
if (!this._skipValidation) {
|
|
this._validateMapping(generated, original, source, name);
|
|
}
|
|
|
|
if (source != null) {
|
|
source = String(source);
|
|
if (!this._sources.has(source)) {
|
|
this._sources.add(source);
|
|
}
|
|
}
|
|
|
|
if (name != null) {
|
|
name = String(name);
|
|
if (!this._names.has(name)) {
|
|
this._names.add(name);
|
|
}
|
|
}
|
|
|
|
this._mappings.add({
|
|
generatedLine: generated.line,
|
|
generatedColumn: generated.column,
|
|
originalLine: original != null && original.line,
|
|
originalColumn: original != null && original.column,
|
|
source,
|
|
name
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Set the source content for a source file.
|
|
*/
|
|
setSourceContent(aSourceFile, aSourceContent) {
|
|
let source = aSourceFile;
|
|
if (this._sourceRoot != null) {
|
|
source = util.relative(this._sourceRoot, source);
|
|
}
|
|
|
|
if (aSourceContent != null) {
|
|
// Add the source content to the _sourcesContents map.
|
|
// Create a new _sourcesContents map if the property is null.
|
|
if (!this._sourcesContents) {
|
|
this._sourcesContents = Object.create(null);
|
|
}
|
|
this._sourcesContents[util.toSetString(source)] = aSourceContent;
|
|
} else if (this._sourcesContents) {
|
|
// Remove the source file from the _sourcesContents map.
|
|
// If the _sourcesContents map is empty, set the property to null.
|
|
delete this._sourcesContents[util.toSetString(source)];
|
|
if (Object.keys(this._sourcesContents).length === 0) {
|
|
this._sourcesContents = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Applies the mappings of a sub-source-map for a specific source file to the
|
|
* source map being generated. Each mapping to the supplied source file is
|
|
* rewritten using the supplied source map. Note: The resolution for the
|
|
* resulting mappings is the minimium of this map and the supplied map.
|
|
*
|
|
* @param aSourceMapConsumer The source map to be applied.
|
|
* @param aSourceFile Optional. The filename of the source file.
|
|
* If omitted, SourceMapConsumer's file property will be used.
|
|
* @param aSourceMapPath Optional. The dirname of the path to the source map
|
|
* to be applied. If relative, it is relative to the SourceMapConsumer.
|
|
* This parameter is needed when the two source maps aren't in the same
|
|
* directory, and the source map to be applied contains relative source
|
|
* paths. If so, those relative source paths need to be rewritten
|
|
* relative to the SourceMapGenerator.
|
|
*/
|
|
applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
|
|
let sourceFile = aSourceFile;
|
|
// If aSourceFile is omitted, we will use the file property of the SourceMap
|
|
if (aSourceFile == null) {
|
|
if (aSourceMapConsumer.file == null) {
|
|
throw new Error(
|
|
"SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " +
|
|
'or the source map\'s "file" property. Both were omitted.'
|
|
);
|
|
}
|
|
sourceFile = aSourceMapConsumer.file;
|
|
}
|
|
const sourceRoot = this._sourceRoot;
|
|
// Make "sourceFile" relative if an absolute Url is passed.
|
|
if (sourceRoot != null) {
|
|
sourceFile = util.relative(sourceRoot, sourceFile);
|
|
}
|
|
// Applying the SourceMap can add and remove items from the sources and
|
|
// the names array.
|
|
const newSources = this._mappings.toArray().length > 0
|
|
? new ArraySet()
|
|
: this._sources;
|
|
const newNames = new ArraySet();
|
|
|
|
// Find mappings for the "sourceFile"
|
|
this._mappings.unsortedForEach(function(mapping) {
|
|
if (mapping.source === sourceFile && mapping.originalLine != null) {
|
|
// Check if it can be mapped by the source map, then update the mapping.
|
|
const original = aSourceMapConsumer.originalPositionFor({
|
|
line: mapping.originalLine,
|
|
column: mapping.originalColumn
|
|
});
|
|
if (original.source != null) {
|
|
// Copy mapping
|
|
mapping.source = original.source;
|
|
if (aSourceMapPath != null) {
|
|
mapping.source = util.join(aSourceMapPath, mapping.source);
|
|
}
|
|
if (sourceRoot != null) {
|
|
mapping.source = util.relative(sourceRoot, mapping.source);
|
|
}
|
|
mapping.originalLine = original.line;
|
|
mapping.originalColumn = original.column;
|
|
if (original.name != null) {
|
|
mapping.name = original.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
const source = mapping.source;
|
|
if (source != null && !newSources.has(source)) {
|
|
newSources.add(source);
|
|
}
|
|
|
|
const name = mapping.name;
|
|
if (name != null && !newNames.has(name)) {
|
|
newNames.add(name);
|
|
}
|
|
|
|
}, this);
|
|
this._sources = newSources;
|
|
this._names = newNames;
|
|
|
|
// Copy sourcesContents of applied map.
|
|
aSourceMapConsumer.sources.forEach(function(srcFile) {
|
|
const content = aSourceMapConsumer.sourceContentFor(srcFile);
|
|
if (content != null) {
|
|
if (aSourceMapPath != null) {
|
|
srcFile = util.join(aSourceMapPath, srcFile);
|
|
}
|
|
if (sourceRoot != null) {
|
|
srcFile = util.relative(sourceRoot, srcFile);
|
|
}
|
|
this.setSourceContent(srcFile, content);
|
|
}
|
|
}, this);
|
|
}
|
|
|
|
/**
|
|
* A mapping can have one of the three levels of data:
|
|
*
|
|
* 1. Just the generated position.
|
|
* 2. The Generated position, original position, and original source.
|
|
* 3. Generated and original position, original source, as well as a name
|
|
* token.
|
|
*
|
|
* To maintain consistency, we validate that any new mapping being added falls
|
|
* in to one of these categories.
|
|
*/
|
|
_validateMapping(aGenerated, aOriginal, aSource, aName) {
|
|
// When aOriginal is truthy but has empty values for .line and .column,
|
|
// it is most likely a programmer error. In this case we throw a very
|
|
// specific error message to try to guide them the right way.
|
|
// For example: https://github.com/Polymer/polymer-bundler/pull/519
|
|
if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
|
|
throw new Error(
|
|
"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."
|
|
);
|
|
}
|
|
|
|
if (aGenerated && "line" in aGenerated && "column" in aGenerated
|
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
|
&& !aOriginal && !aSource && !aName) {
|
|
// Case 1.
|
|
|
|
} 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) {
|
|
// Cases 2 and 3.
|
|
|
|
} else {
|
|
throw new Error("Invalid mapping: " + JSON.stringify({
|
|
generated: aGenerated,
|
|
source: aSource,
|
|
original: aOriginal,
|
|
name: aName
|
|
}));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Serialize the accumulated mappings in to the stream of base 64 VLQs
|
|
* specified by the source map format.
|
|
*/
|
|
_serializeMappings() {
|
|
let previousGeneratedColumn = 0;
|
|
let previousGeneratedLine = 1;
|
|
let previousOriginalColumn = 0;
|
|
let previousOriginalLine = 0;
|
|
let previousName = 0;
|
|
let previousSource = 0;
|
|
let result = "";
|
|
let next;
|
|
let mapping;
|
|
let nameIdx;
|
|
let sourceIdx;
|
|
|
|
const mappings = this._mappings.toArray();
|
|
for (let i = 0, len = mappings.length; i < len; i++) {
|
|
mapping = mappings[i];
|
|
next = "";
|
|
|
|
if (mapping.generatedLine !== previousGeneratedLine) {
|
|
previousGeneratedColumn = 0;
|
|
while (mapping.generatedLine !== previousGeneratedLine) {
|
|
next += ";";
|
|
previousGeneratedLine++;
|
|
}
|
|
} else if (i > 0) {
|
|
if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
|
|
continue;
|
|
}
|
|
next += ",";
|
|
}
|
|
|
|
next += base64VLQ.encode(mapping.generatedColumn
|
|
- previousGeneratedColumn);
|
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
|
|
if (mapping.source != null) {
|
|
sourceIdx = this._sources.indexOf(mapping.source);
|
|
next += base64VLQ.encode(sourceIdx - previousSource);
|
|
previousSource = sourceIdx;
|
|
|
|
// lines are stored 0-based in SourceMap spec version 3
|
|
next += base64VLQ.encode(mapping.originalLine - 1
|
|
- previousOriginalLine);
|
|
previousOriginalLine = mapping.originalLine - 1;
|
|
|
|
next += base64VLQ.encode(mapping.originalColumn
|
|
- previousOriginalColumn);
|
|
previousOriginalColumn = mapping.originalColumn;
|
|
|
|
if (mapping.name != null) {
|
|
nameIdx = this._names.indexOf(mapping.name);
|
|
next += base64VLQ.encode(nameIdx - previousName);
|
|
previousName = nameIdx;
|
|
}
|
|
}
|
|
|
|
result += next;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
_generateSourcesContent(aSources, aSourceRoot) {
|
|
return aSources.map(function(source) {
|
|
if (!this._sourcesContents) {
|
|
return null;
|
|
}
|
|
if (aSourceRoot != null) {
|
|
source = util.relative(aSourceRoot, source);
|
|
}
|
|
const key = util.toSetString(source);
|
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
|
|
? this._sourcesContents[key]
|
|
: null;
|
|
}, this);
|
|
}
|
|
|
|
/**
|
|
* Externalize the source map.
|
|
*/
|
|
toJSON() {
|
|
const map = {
|
|
version: this._version,
|
|
sources: this._sources.toArray(),
|
|
names: this._names.toArray(),
|
|
mappings: this._serializeMappings()
|
|
};
|
|
if (this._file != null) {
|
|
map.file = this._file;
|
|
}
|
|
if (this._sourceRoot != null) {
|
|
map.sourceRoot = this._sourceRoot;
|
|
}
|
|
if (this._sourcesContents) {
|
|
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Render the source map being generated to a string.
|
|
*/
|
|
toString() {
|
|
return JSON.stringify(this.toJSON());
|
|
}
|
|
}
|
|
|
|
SourceMapGenerator.prototype._version = 3;
|
|
exports.SourceMapGenerator = SourceMapGenerator;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 589:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
const SourceMapGenerator = (__nccwpck_require__(87).SourceMapGenerator);
|
|
const util = __nccwpck_require__(354);
|
|
|
|
// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
|
|
// operating systems these days (capturing the result).
|
|
const REGEX_NEWLINE = /(\r?\n)/;
|
|
|
|
// Newline character code for charCodeAt() comparisons
|
|
const NEWLINE_CODE = 10;
|
|
|
|
// Private symbol for identifying `SourceNode`s when multiple versions of
|
|
// the source-map library are loaded. This MUST NOT CHANGE across
|
|
// versions!
|
|
const isSourceNode = "$$$isSourceNode$$$";
|
|
|
|
/**
|
|
* SourceNodes provide a way to abstract over interpolating/concatenating
|
|
* snippets of generated JavaScript source code while maintaining the line and
|
|
* column information associated with the original source code.
|
|
*
|
|
* @param aLine The original line number.
|
|
* @param aColumn The original column number.
|
|
* @param aSource The original source's filename.
|
|
* @param aChunks Optional. An array of strings which are snippets of
|
|
* generated JS, or other SourceNodes.
|
|
* @param aName The original identifier.
|
|
*/
|
|
class SourceNode {
|
|
constructor(aLine, aColumn, aSource, aChunks, aName) {
|
|
this.children = [];
|
|
this.sourceContents = {};
|
|
this.line = aLine == null ? null : aLine;
|
|
this.column = aColumn == null ? null : aColumn;
|
|
this.source = aSource == null ? null : aSource;
|
|
this.name = aName == null ? null : aName;
|
|
this[isSourceNode] = true;
|
|
if (aChunks != null) this.add(aChunks);
|
|
}
|
|
|
|
/**
|
|
* Creates a SourceNode from generated code and a SourceMapConsumer.
|
|
*
|
|
* @param aGeneratedCode The generated code
|
|
* @param aSourceMapConsumer The SourceMap for the generated code
|
|
* @param aRelativePath Optional. The path that relative sources in the
|
|
* SourceMapConsumer should be relative to.
|
|
*/
|
|
static fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
|
|
// The SourceNode we want to fill with the generated code
|
|
// and the SourceMap
|
|
const node = new SourceNode();
|
|
|
|
// All even indices of this array are one line of the generated code,
|
|
// while all odd indices are the newlines between two adjacent lines
|
|
// (since `REGEX_NEWLINE` captures its match).
|
|
// Processed fragments are accessed by calling `shiftNextLine`.
|
|
const remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
|
|
let remainingLinesIndex = 0;
|
|
const shiftNextLine = function() {
|
|
const lineContents = getNextLine();
|
|
// The last line of a file might not have a newline.
|
|
const newLine = getNextLine() || "";
|
|
return lineContents + newLine;
|
|
|
|
function getNextLine() {
|
|
return remainingLinesIndex < remainingLines.length ?
|
|
remainingLines[remainingLinesIndex++] : undefined;
|
|
}
|
|
};
|
|
|
|
// We need to remember the position of "remainingLines"
|
|
let lastGeneratedLine = 1, lastGeneratedColumn = 0;
|
|
|
|
// The generate SourceNodes we need a code range.
|
|
// To extract it current and last mapping is used.
|
|
// Here we store the last mapping.
|
|
let lastMapping = null;
|
|
let nextLine;
|
|
|
|
aSourceMapConsumer.eachMapping(function(mapping) {
|
|
if (lastMapping !== null) {
|
|
// We add the code from "lastMapping" to "mapping":
|
|
// First check if there is a new line in between.
|
|
if (lastGeneratedLine < mapping.generatedLine) {
|
|
// Associate first line with "lastMapping"
|
|
addMappingWithCode(lastMapping, shiftNextLine());
|
|
lastGeneratedLine++;
|
|
lastGeneratedColumn = 0;
|
|
// The remaining code is added without mapping
|
|
} else {
|
|
// There is no new line in between.
|
|
// Associate the code between "lastGeneratedColumn" and
|
|
// "mapping.generatedColumn" with "lastMapping"
|
|
nextLine = remainingLines[remainingLinesIndex] || "";
|
|
const code = nextLine.substr(0, mapping.generatedColumn -
|
|
lastGeneratedColumn);
|
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
|
|
lastGeneratedColumn);
|
|
lastGeneratedColumn = mapping.generatedColumn;
|
|
addMappingWithCode(lastMapping, code);
|
|
// No more remaining code, continue
|
|
lastMapping = mapping;
|
|
return;
|
|
}
|
|
}
|
|
// We add the generated code until the first mapping
|
|
// to the SourceNode without any mapping.
|
|
// Each line is added as separate string.
|
|
while (lastGeneratedLine < mapping.generatedLine) {
|
|
node.add(shiftNextLine());
|
|
lastGeneratedLine++;
|
|
}
|
|
if (lastGeneratedColumn < mapping.generatedColumn) {
|
|
nextLine = remainingLines[remainingLinesIndex] || "";
|
|
node.add(nextLine.substr(0, mapping.generatedColumn));
|
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
|
|
lastGeneratedColumn = mapping.generatedColumn;
|
|
}
|
|
lastMapping = mapping;
|
|
}, this);
|
|
// We have processed all mappings.
|
|
if (remainingLinesIndex < remainingLines.length) {
|
|
if (lastMapping) {
|
|
// Associate the remaining code in the current line with "lastMapping"
|
|
addMappingWithCode(lastMapping, shiftNextLine());
|
|
}
|
|
// and add the remaining lines without any mapping
|
|
node.add(remainingLines.splice(remainingLinesIndex).join(""));
|
|
}
|
|
|
|
// Copy sourcesContent into SourceNode
|
|
aSourceMapConsumer.sources.forEach(function(sourceFile) {
|
|
const content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
|
if (content != null) {
|
|
if (aRelativePath != null) {
|
|
sourceFile = util.join(aRelativePath, sourceFile);
|
|
}
|
|
node.setSourceContent(sourceFile, content);
|
|
}
|
|
});
|
|
|
|
return node;
|
|
|
|
function addMappingWithCode(mapping, code) {
|
|
if (mapping === null || mapping.source === undefined) {
|
|
node.add(code);
|
|
} else {
|
|
const source = aRelativePath
|
|
? util.join(aRelativePath, mapping.source)
|
|
: mapping.source;
|
|
node.add(new SourceNode(mapping.originalLine,
|
|
mapping.originalColumn,
|
|
source,
|
|
code,
|
|
mapping.name));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a chunk of generated JS to this source node.
|
|
*
|
|
* @param aChunk A string snippet of generated JS code, another instance of
|
|
* SourceNode, or an array where each member is one of those things.
|
|
*/
|
|
add(aChunk) {
|
|
if (Array.isArray(aChunk)) {
|
|
aChunk.forEach(function(chunk) {
|
|
this.add(chunk);
|
|
}, this);
|
|
} else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
|
if (aChunk) {
|
|
this.children.push(aChunk);
|
|
}
|
|
} else {
|
|
throw new TypeError(
|
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
|
);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Add a chunk of generated JS to the beginning of this source node.
|
|
*
|
|
* @param aChunk A string snippet of generated JS code, another instance of
|
|
* SourceNode, or an array where each member is one of those things.
|
|
*/
|
|
prepend(aChunk) {
|
|
if (Array.isArray(aChunk)) {
|
|
for (let i = aChunk.length - 1; i >= 0; i--) {
|
|
this.prepend(aChunk[i]);
|
|
}
|
|
} else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
|
this.children.unshift(aChunk);
|
|
} else {
|
|
throw new TypeError(
|
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
|
);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Walk over the tree of JS snippets in this node and its children. The
|
|
* walking function is called once for each snippet of JS and is passed that
|
|
* snippet and the its original associated source's line/column location.
|
|
*
|
|
* @param aFn The traversal function.
|
|
*/
|
|
walk(aFn) {
|
|
let chunk;
|
|
for (let i = 0, len = this.children.length; i < len; i++) {
|
|
chunk = this.children[i];
|
|
if (chunk[isSourceNode]) {
|
|
chunk.walk(aFn);
|
|
} else if (chunk !== "") {
|
|
aFn(chunk, { source: this.source,
|
|
line: this.line,
|
|
column: this.column,
|
|
name: this.name });
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
|
|
* each of `this.children`.
|
|
*
|
|
* @param aSep The separator.
|
|
*/
|
|
join(aSep) {
|
|
let newChildren;
|
|
let i;
|
|
const len = this.children.length;
|
|
if (len > 0) {
|
|
newChildren = [];
|
|
for (i = 0; i < len - 1; i++) {
|
|
newChildren.push(this.children[i]);
|
|
newChildren.push(aSep);
|
|
}
|
|
newChildren.push(this.children[i]);
|
|
this.children = newChildren;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Call String.prototype.replace on the very right-most source snippet. Useful
|
|
* for trimming whitespace from the end of a source node, etc.
|
|
*
|
|
* @param aPattern The pattern to replace.
|
|
* @param aReplacement The thing to replace the pattern with.
|
|
*/
|
|
replaceRight(aPattern, aReplacement) {
|
|
const lastChild = this.children[this.children.length - 1];
|
|
if (lastChild[isSourceNode]) {
|
|
lastChild.replaceRight(aPattern, aReplacement);
|
|
} else if (typeof lastChild === "string") {
|
|
this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
|
|
} else {
|
|
this.children.push("".replace(aPattern, aReplacement));
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the source content for a source file. This will be added to the SourceMapGenerator
|
|
* in the sourcesContent field.
|
|
*
|
|
* @param aSourceFile The filename of the source file
|
|
* @param aSourceContent The content of the source file
|
|
*/
|
|
setSourceContent(aSourceFile, aSourceContent) {
|
|
this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
|
|
}
|
|
|
|
/**
|
|
* Walk over the tree of SourceNodes. The walking function is called for each
|
|
* source file content and is passed the filename and source content.
|
|
*
|
|
* @param aFn The traversal function.
|
|
*/
|
|
walkSourceContents(aFn) {
|
|
for (let i = 0, len = this.children.length; i < len; i++) {
|
|
if (this.children[i][isSourceNode]) {
|
|
this.children[i].walkSourceContents(aFn);
|
|
}
|
|
}
|
|
|
|
const sources = Object.keys(this.sourceContents);
|
|
for (let i = 0, len = sources.length; i < len; i++) {
|
|
aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the string representation of this source node. Walks over the tree
|
|
* and concatenates all the various snippets together to one string.
|
|
*/
|
|
toString() {
|
|
let str = "";
|
|
this.walk(function(chunk) {
|
|
str += chunk;
|
|
});
|
|
return str;
|
|
}
|
|
|
|
/**
|
|
* Returns the string representation of this source node along with a source
|
|
* map.
|
|
*/
|
|
toStringWithSourceMap(aArgs) {
|
|
const generated = {
|
|
code: "",
|
|
line: 1,
|
|
column: 0
|
|
};
|
|
const map = new SourceMapGenerator(aArgs);
|
|
let sourceMappingActive = false;
|
|
let lastOriginalSource = null;
|
|
let lastOriginalLine = null;
|
|
let lastOriginalColumn = null;
|
|
let lastOriginalName = null;
|
|
this.walk(function(chunk, original) {
|
|
generated.code += chunk;
|
|
if (original.source !== null
|
|
&& original.line !== null
|
|
&& original.column !== null) {
|
|
if (lastOriginalSource !== original.source
|
|
|| lastOriginalLine !== original.line
|
|
|| lastOriginalColumn !== original.column
|
|
|| lastOriginalName !== original.name) {
|
|
map.addMapping({
|
|
source: original.source,
|
|
original: {
|
|
line: original.line,
|
|
column: original.column
|
|
},
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
},
|
|
name: original.name
|
|
});
|
|
}
|
|
lastOriginalSource = original.source;
|
|
lastOriginalLine = original.line;
|
|
lastOriginalColumn = original.column;
|
|
lastOriginalName = original.name;
|
|
sourceMappingActive = true;
|
|
} else if (sourceMappingActive) {
|
|
map.addMapping({
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
}
|
|
});
|
|
lastOriginalSource = null;
|
|
sourceMappingActive = false;
|
|
}
|
|
for (let idx = 0, length = chunk.length; idx < length; idx++) {
|
|
if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
|
|
generated.line++;
|
|
generated.column = 0;
|
|
// Mappings end at eol
|
|
if (idx + 1 === length) {
|
|
lastOriginalSource = null;
|
|
sourceMappingActive = false;
|
|
} else if (sourceMappingActive) {
|
|
map.addMapping({
|
|
source: original.source,
|
|
original: {
|
|
line: original.line,
|
|
column: original.column
|
|
},
|
|
generated: {
|
|
line: generated.line,
|
|
column: generated.column
|
|
},
|
|
name: original.name
|
|
});
|
|
}
|
|
} else {
|
|
generated.column++;
|
|
}
|
|
}
|
|
});
|
|
this.walkSourceContents(function(sourceFile, sourceContent) {
|
|
map.setSourceContent(sourceFile, sourceContent);
|
|
});
|
|
|
|
return { code: generated.code, map };
|
|
}
|
|
}
|
|
|
|
exports.SourceNode = SourceNode;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 869:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
"use strict";
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
|
|
// Note: This file is overridden in the 'package.json#browser' field to
|
|
// substitute lib/url-browser.js instead.
|
|
|
|
// Use the URL global for Node 10, and the 'url' module for Node 8.
|
|
module.exports = typeof URL === "function" ? URL : (__nccwpck_require__(310).URL);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 354:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
const URL = __nccwpck_require__(869);
|
|
|
|
/**
|
|
* This is a helper function for getting values from parameter/options
|
|
* objects.
|
|
*
|
|
* @param args The object we are extracting values from
|
|
* @param name The name of the property we are getting.
|
|
* @param defaultValue An optional value to return if the property is missing
|
|
* from the object. If this is not specified and the property is missing, an
|
|
* error will be thrown.
|
|
*/
|
|
function getArg(aArgs, aName, aDefaultValue) {
|
|
if (aName in aArgs) {
|
|
return aArgs[aName];
|
|
} else if (arguments.length === 3) {
|
|
return aDefaultValue;
|
|
}
|
|
throw new Error('"' + aName + '" is a required argument.');
|
|
|
|
}
|
|
exports.getArg = getArg;
|
|
|
|
const supportsNullProto = (function() {
|
|
const obj = Object.create(null);
|
|
return !("__proto__" in obj);
|
|
}());
|
|
|
|
function identity(s) {
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* Because behavior goes wacky when you set `__proto__` on objects, we
|
|
* have to prefix all the strings in our set with an arbitrary character.
|
|
*
|
|
* See https://github.com/mozilla/source-map/pull/31 and
|
|
* https://github.com/mozilla/source-map/issues/30
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
function toSetString(aStr) {
|
|
if (isProtoString(aStr)) {
|
|
return "$" + aStr;
|
|
}
|
|
|
|
return aStr;
|
|
}
|
|
exports.toSetString = supportsNullProto ? identity : toSetString;
|
|
|
|
function fromSetString(aStr) {
|
|
if (isProtoString(aStr)) {
|
|
return aStr.slice(1);
|
|
}
|
|
|
|
return aStr;
|
|
}
|
|
exports.fromSetString = supportsNullProto ? identity : fromSetString;
|
|
|
|
function isProtoString(s) {
|
|
if (!s) {
|
|
return false;
|
|
}
|
|
|
|
const length = s.length;
|
|
|
|
if (length < 9 /* "__proto__".length */) {
|
|
return false;
|
|
}
|
|
|
|
/* eslint-disable no-multi-spaces */
|
|
if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||
|
|
s.charCodeAt(length - 2) !== 95 /* '_' */ ||
|
|
s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
|
|
s.charCodeAt(length - 4) !== 116 /* 't' */ ||
|
|
s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
|
|
s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
|
|
s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
|
|
s.charCodeAt(length - 8) !== 95 /* '_' */ ||
|
|
s.charCodeAt(length - 9) !== 95 /* '_' */) {
|
|
return false;
|
|
}
|
|
/* eslint-enable no-multi-spaces */
|
|
|
|
for (let i = length - 10; i >= 0; i--) {
|
|
if (s.charCodeAt(i) !== 36 /* '$' */) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function strcmp(aStr1, aStr2) {
|
|
if (aStr1 === aStr2) {
|
|
return 0;
|
|
}
|
|
|
|
if (aStr1 === null) {
|
|
return 1; // aStr2 !== null
|
|
}
|
|
|
|
if (aStr2 === null) {
|
|
return -1; // aStr1 !== null
|
|
}
|
|
|
|
if (aStr1 > aStr2) {
|
|
return 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Comparator between two mappings with inflated source and name strings where
|
|
* the generated positions are compared.
|
|
*/
|
|
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
|
|
let cmp = mappingA.generatedLine - mappingB.generatedLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
|
if (cmp !== 0) {
|
|
return cmp;
|
|
}
|
|
|
|
return strcmp(mappingA.name, mappingB.name);
|
|
}
|
|
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
|
|
|
|
/**
|
|
* Strip any JSON XSSI avoidance prefix from the string (as documented
|
|
* in the source maps specification), and then parse the string as
|
|
* JSON.
|
|
*/
|
|
function parseSourceMapInput(str) {
|
|
return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
|
|
}
|
|
exports.parseSourceMapInput = parseSourceMapInput;
|
|
|
|
// We use 'http' as the base here because we want URLs processed relative
|
|
// to the safe base to be treated as "special" URLs during parsing using
|
|
// the WHATWG URL parsing. This ensures that backslash normalization
|
|
// applies to the path and such.
|
|
const PROTOCOL = "http:";
|
|
const PROTOCOL_AND_HOST = `${PROTOCOL}//host`;
|
|
|
|
/**
|
|
* Make it easy to create small utilities that tweak a URL's path.
|
|
*/
|
|
function createSafeHandler(cb) {
|
|
return input => {
|
|
const type = getURLType(input);
|
|
const base = buildSafeBase(input);
|
|
const url = new URL(input, base);
|
|
|
|
cb(url);
|
|
|
|
const result = url.toString();
|
|
|
|
if (type === "absolute") {
|
|
return result;
|
|
} else if (type === "scheme-relative") {
|
|
return result.slice(PROTOCOL.length);
|
|
} else if (type === "path-absolute") {
|
|
return result.slice(PROTOCOL_AND_HOST.length);
|
|
}
|
|
|
|
// This assumes that the callback will only change
|
|
// the path, search and hash values.
|
|
return computeRelativeURL(base, result);
|
|
};
|
|
}
|
|
|
|
function withBase(url, base) {
|
|
return new URL(url, base).toString();
|
|
}
|
|
|
|
function buildUniqueSegment(prefix, str) {
|
|
let id = 0;
|
|
do {
|
|
const ident = prefix + (id++);
|
|
if (str.indexOf(ident) === -1) return ident;
|
|
} while (true);
|
|
}
|
|
|
|
function buildSafeBase(str) {
|
|
const maxDotParts = str.split("..").length - 1;
|
|
|
|
// If we used a segment that also existed in `str`, then we would be unable
|
|
// to compute relative paths. For example, if `segment` were just "a":
|
|
//
|
|
// const url = "../../a/"
|
|
// const base = buildSafeBase(url); // http://host/a/a/
|
|
// const joined = "http://host/a/";
|
|
// const result = relative(base, joined);
|
|
//
|
|
// Expected: "../../a/";
|
|
// Actual: "a/"
|
|
//
|
|
const segment = buildUniqueSegment("p", str);
|
|
|
|
let base = `${PROTOCOL_AND_HOST}/`;
|
|
for (let i = 0; i < maxDotParts; i++) {
|
|
base += `${segment}/`;
|
|
}
|
|
return base;
|
|
}
|
|
|
|
const ABSOLUTE_SCHEME = /^[A-Za-z0-9\+\-\.]+:/;
|
|
function getURLType(url) {
|
|
if (url[0] === "/") {
|
|
if (url[1] === "/") return "scheme-relative";
|
|
return "path-absolute";
|
|
}
|
|
|
|
return ABSOLUTE_SCHEME.test(url) ? "absolute" : "path-relative";
|
|
}
|
|
|
|
/**
|
|
* Given two URLs that are assumed to be on the same
|
|
* protocol/host/user/password build a relative URL from the
|
|
* path, params, and hash values.
|
|
*
|
|
* @param rootURL The root URL that the target will be relative to.
|
|
* @param targetURL The target that the relative URL points to.
|
|
* @return A rootURL-relative, normalized URL value.
|
|
*/
|
|
function computeRelativeURL(rootURL, targetURL) {
|
|
if (typeof rootURL === "string") rootURL = new URL(rootURL);
|
|
if (typeof targetURL === "string") targetURL = new URL(targetURL);
|
|
|
|
const targetParts = targetURL.pathname.split("/");
|
|
const rootParts = rootURL.pathname.split("/");
|
|
|
|
// If we've got a URL path ending with a "/", we remove it since we'd
|
|
// otherwise be relative to the wrong location.
|
|
if (rootParts.length > 0 && !rootParts[rootParts.length - 1]) {
|
|
rootParts.pop();
|
|
}
|
|
|
|
while (
|
|
targetParts.length > 0 &&
|
|
rootParts.length > 0 &&
|
|
targetParts[0] === rootParts[0]
|
|
) {
|
|
targetParts.shift();
|
|
rootParts.shift();
|
|
}
|
|
|
|
const relativePath = rootParts
|
|
.map(() => "..")
|
|
.concat(targetParts)
|
|
.join("/");
|
|
|
|
return relativePath + targetURL.search + targetURL.hash;
|
|
}
|
|
|
|
/**
|
|
* Given a URL, ensure that it is treated as a directory URL.
|
|
*
|
|
* @param url
|
|
* @return A normalized URL value.
|
|
*/
|
|
const ensureDirectory = createSafeHandler(url => {
|
|
url.pathname = url.pathname.replace(/\/?$/, "/");
|
|
});
|
|
|
|
/**
|
|
* Given a URL, strip off any filename if one is present.
|
|
*
|
|
* @param url
|
|
* @return A normalized URL value.
|
|
*/
|
|
const trimFilename = createSafeHandler(url => {
|
|
url.href = new URL(".", url.toString()).toString();
|
|
});
|
|
|
|
/**
|
|
* Normalize a given URL.
|
|
* * Convert backslashes.
|
|
* * Remove any ".." and "." segments.
|
|
*
|
|
* @param url
|
|
* @return A normalized URL value.
|
|
*/
|
|
const normalize = createSafeHandler(url => {});
|
|
exports.normalize = normalize;
|
|
|
|
/**
|
|
* Joins two paths/URLs.
|
|
*
|
|
* All returned URLs will be normalized.
|
|
*
|
|
* @param aRoot The root path or URL. Assumed to reference a directory.
|
|
* @param aPath The path or URL to be joined with the root.
|
|
* @return A joined and normalized URL value.
|
|
*/
|
|
function join(aRoot, aPath) {
|
|
const pathType = getURLType(aPath);
|
|
const rootType = getURLType(aRoot);
|
|
|
|
aRoot = ensureDirectory(aRoot);
|
|
|
|
if (pathType === "absolute") {
|
|
return withBase(aPath, undefined);
|
|
}
|
|
if (rootType === "absolute") {
|
|
return withBase(aPath, aRoot);
|
|
}
|
|
|
|
if (pathType === "scheme-relative") {
|
|
return normalize(aPath);
|
|
}
|
|
if (rootType === "scheme-relative") {
|
|
return withBase(aPath, withBase(aRoot, PROTOCOL_AND_HOST)).slice(PROTOCOL.length);
|
|
}
|
|
|
|
if (pathType === "path-absolute") {
|
|
return normalize(aPath);
|
|
}
|
|
if (rootType === "path-absolute") {
|
|
return withBase(aPath, withBase(aRoot, PROTOCOL_AND_HOST)).slice(PROTOCOL_AND_HOST.length);
|
|
}
|
|
|
|
const base = buildSafeBase(aPath + aRoot);
|
|
const newPath = withBase(aPath, withBase(aRoot, base));
|
|
return computeRelativeURL(base, newPath);
|
|
}
|
|
exports.join = join;
|
|
|
|
/**
|
|
* Make a path relative to a URL or another path. If returning a
|
|
* relative URL is not possible, the original target will be returned.
|
|
* All returned URLs will be normalized.
|
|
*
|
|
* @param aRoot The root path or URL.
|
|
* @param aPath The path or URL to be made relative to aRoot.
|
|
* @return A rootURL-relative (if possible), normalized URL value.
|
|
*/
|
|
function relative(rootURL, targetURL) {
|
|
const result = relativeIfPossible(rootURL, targetURL);
|
|
|
|
return typeof result === "string" ? result : normalize(targetURL);
|
|
}
|
|
exports.relative = relative;
|
|
|
|
function relativeIfPossible(rootURL, targetURL) {
|
|
const urlType = getURLType(rootURL);
|
|
if (urlType !== getURLType(targetURL)) {
|
|
return null;
|
|
}
|
|
|
|
const base = buildSafeBase(rootURL + targetURL);
|
|
const root = new URL(rootURL, base);
|
|
const target = new URL(targetURL, base);
|
|
|
|
try {
|
|
new URL("", target.toString());
|
|
} catch (err) {
|
|
// Bail if the URL doesn't support things being relative to it,
|
|
// For example, data: and blob: URLs.
|
|
return null;
|
|
}
|
|
|
|
if (
|
|
target.protocol !== root.protocol ||
|
|
target.user !== root.user ||
|
|
target.password !== root.password ||
|
|
target.hostname !== root.hostname ||
|
|
target.port !== root.port
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return computeRelativeURL(root, target);
|
|
}
|
|
|
|
/**
|
|
* Compute the URL of a source given the the source root, the source's
|
|
* URL, and the source map's URL.
|
|
*/
|
|
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
|
|
// The source map spec states that "sourceRoot" and "sources" entries are to be appended. While
|
|
// that is a little vague, implementations have generally interpreted that as joining the
|
|
// URLs with a `/` between then, assuming the "sourceRoot" doesn't already end with one.
|
|
// For example,
|
|
//
|
|
// sourceRoot: "some-dir",
|
|
// sources: ["/some-path.js"]
|
|
//
|
|
// and
|
|
//
|
|
// sourceRoot: "some-dir/",
|
|
// sources: ["/some-path.js"]
|
|
//
|
|
// must behave as "some-dir/some-path.js".
|
|
//
|
|
// With this library's the transition to a more URL-focused implementation, that behavior is
|
|
// preserved here. To acheive that, we trim the "/" from absolute-path when a sourceRoot value
|
|
// is present in order to make the sources entries behave as if they are relative to the
|
|
// "sourceRoot", as they would have if the two strings were simply concated.
|
|
if (sourceRoot && getURLType(sourceURL) === "path-absolute") {
|
|
sourceURL = sourceURL.replace(/^\//, "");
|
|
}
|
|
|
|
let url = normalize(sourceURL || "");
|
|
|
|
// Parsing URLs can be expensive, so we only perform these joins when needed.
|
|
if (sourceRoot) url = join(sourceRoot, url);
|
|
if (sourceMapURL) url = join(trimFilename(sourceMapURL), url);
|
|
return url;
|
|
}
|
|
exports.computeSourceURL = computeSourceURL;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 776:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
const readWasm = __nccwpck_require__(799);
|
|
|
|
/**
|
|
* Provide the JIT with a nice shape / hidden class.
|
|
*/
|
|
function Mapping() {
|
|
this.generatedLine = 0;
|
|
this.generatedColumn = 0;
|
|
this.lastGeneratedColumn = null;
|
|
this.source = null;
|
|
this.originalLine = null;
|
|
this.originalColumn = null;
|
|
this.name = null;
|
|
}
|
|
|
|
let cachedWasm = null;
|
|
|
|
module.exports = function wasm() {
|
|
if (cachedWasm) {
|
|
return cachedWasm;
|
|
}
|
|
|
|
const callbackStack = [];
|
|
|
|
cachedWasm = readWasm().then(buffer => {
|
|
return WebAssembly.instantiate(buffer, {
|
|
env: {
|
|
mapping_callback(
|
|
generatedLine,
|
|
generatedColumn,
|
|
|
|
hasLastGeneratedColumn,
|
|
lastGeneratedColumn,
|
|
|
|
hasOriginal,
|
|
source,
|
|
originalLine,
|
|
originalColumn,
|
|
|
|
hasName,
|
|
name
|
|
) {
|
|
const mapping = new Mapping();
|
|
// JS uses 1-based line numbers, wasm uses 0-based.
|
|
mapping.generatedLine = generatedLine + 1;
|
|
mapping.generatedColumn = generatedColumn;
|
|
|
|
if (hasLastGeneratedColumn) {
|
|
// JS uses inclusive last generated column, wasm uses exclusive.
|
|
mapping.lastGeneratedColumn = lastGeneratedColumn - 1;
|
|
}
|
|
|
|
if (hasOriginal) {
|
|
mapping.source = source;
|
|
// JS uses 1-based line numbers, wasm uses 0-based.
|
|
mapping.originalLine = originalLine + 1;
|
|
mapping.originalColumn = originalColumn;
|
|
|
|
if (hasName) {
|
|
mapping.name = name;
|
|
}
|
|
}
|
|
|
|
callbackStack[callbackStack.length - 1](mapping);
|
|
},
|
|
|
|
start_all_generated_locations_for() { console.time("all_generated_locations_for"); },
|
|
end_all_generated_locations_for() { console.timeEnd("all_generated_locations_for"); },
|
|
|
|
start_compute_column_spans() { console.time("compute_column_spans"); },
|
|
end_compute_column_spans() { console.timeEnd("compute_column_spans"); },
|
|
|
|
start_generated_location_for() { console.time("generated_location_for"); },
|
|
end_generated_location_for() { console.timeEnd("generated_location_for"); },
|
|
|
|
start_original_location_for() { console.time("original_location_for"); },
|
|
end_original_location_for() { console.timeEnd("original_location_for"); },
|
|
|
|
start_parse_mappings() { console.time("parse_mappings"); },
|
|
end_parse_mappings() { console.timeEnd("parse_mappings"); },
|
|
|
|
start_sort_by_generated_location() { console.time("sort_by_generated_location"); },
|
|
end_sort_by_generated_location() { console.timeEnd("sort_by_generated_location"); },
|
|
|
|
start_sort_by_original_location() { console.time("sort_by_original_location"); },
|
|
end_sort_by_original_location() { console.timeEnd("sort_by_original_location"); },
|
|
}
|
|
});
|
|
}).then(Wasm => {
|
|
return {
|
|
exports: Wasm.instance.exports,
|
|
withMappingCallback: (mappingCallback, f) => {
|
|
callbackStack.push(mappingCallback);
|
|
try {
|
|
f();
|
|
} finally {
|
|
callbackStack.pop();
|
|
}
|
|
}
|
|
};
|
|
}).then(null, e => {
|
|
cachedWasm = null;
|
|
throw e;
|
|
});
|
|
|
|
return cachedWasm;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 147:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
module.exports = require("fs");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 17:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
module.exports = require("path");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 310:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
module.exports = require("url");
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
/************************************************************************/
|
|
/******/ // The module cache
|
|
/******/ var __webpack_module_cache__ = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __nccwpck_require__(moduleId) {
|
|
/******/ // Check if module is in cache
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
/******/ if (cachedModule !== undefined) {
|
|
/******/ return cachedModule.exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
/******/ // no module.id needed
|
|
/******/ // no module.loaded needed
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ var threw = true;
|
|
/******/ try {
|
|
/******/ __webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
|
|
/******/ threw = false;
|
|
/******/ } finally {
|
|
/******/ if(threw) delete __webpack_module_cache__[moduleId];
|
|
/******/ }
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/************************************************************************/
|
|
/******/ /* webpack/runtime/compat */
|
|
/******/
|
|
/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
|
|
/******/
|
|
/************************************************************************/
|
|
var __webpack_exports__ = {};
|
|
// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
|
|
(() => {
|
|
var exports = __webpack_exports__;
|
|
/*
|
|
* Copyright 2009-2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE.txt or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
exports.SourceMapGenerator = __nccwpck_require__(87).SourceMapGenerator;
|
|
exports.SourceMapConsumer = __nccwpck_require__(886).SourceMapConsumer;
|
|
exports.SourceNode = __nccwpck_require__(589).SourceNode;
|
|
|
|
})();
|
|
|
|
module.exports = __webpack_exports__;
|
|
/******/ })()
|
|
; |