@bildit-platform/engine 0.1.5 → 0.1.6

package/dist/esm/node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/compiled/source-map08/source-map.js

@@ -0,0 +1,3001 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __module as sourceMap } from '../../../../../../../../_virtual/source-map2.js';
+import require$$0 from 'fs';
+import require$$1 from 'path';
+import require$$2 from 'url';
+
+/******/
+
+var hasRequiredSourceMap;
+
+function requireSourceMap () {
+	if (hasRequiredSourceMap) return sourceMap.exports;
+	hasRequiredSourceMap = 1;
+	(() => { // 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;
+	}
+
+	/**
+	 * 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__) => {
+
+
+	// 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);
+	__nccwpck_require__(17);
+
+	module.exports = function readWasm() {
+	  return new Promise((resolve, reject) => {
+	    __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__) => {
+	/* -*- 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);
+	__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;
+
+	/**
+	 * 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();
+	    }
+	  }
+	}
+
+	/*
+	 * 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) ; 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) ; 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__) => {
+	/* -*- 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) => {
+	module.exports = require$$0;
+
+	/***/ }),
+
+	/***/ 17:
+	/***/ ((module) => {
+	module.exports = require$$1;
+
+	/***/ }),
+
+	/***/ 310:
+	/***/ ((module) => {
+	module.exports = require$$2;
+
+	/***/ })
+
+	/******/ 	});
+	/************************************************************************/
+	/******/ 	// 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;
+
+	})();
+
+	sourceMap.exports = __webpack_exports__;
+	/******/ })()
+	;
+	return sourceMap.exports;
+}
+
+export { requireSourceMap as __require };