@pastweb/vue 2.0.0

package/dist/node_modules/source-map-js/lib/source-map-consumer.cjs

@@ -0,0 +1,790 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_base64_vlq$1 = require("./base64-vlq.cjs");
+const require_util$1 = require("./util.cjs");
+const require_array_set$1 = require("./array-set.cjs");
+const require_binary_search$1 = require("./binary-search.cjs");
+const require_quick_sort$1 = require("./quick-sort.cjs");
+//#region node_modules/source-map-js/lib/source-map-consumer.js
+var require_source_map_consumer = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	var util = require_util$1.default;
+	var binarySearch = require_binary_search$1.default;
+	var ArraySet = require_array_set$1.default.ArraySet;
+	var base64VLQ = require_base64_vlq$1.default;
+	var quickSort = require_quick_sort$1.default.quickSort;
+	function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+		var sourceMap = aSourceMap;
+		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
+		return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+	}
+	SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
+		return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+	};
+	/**
+	* The version of the source mapping spec that we are consuming.
+	*/
+	SourceMapConsumer.prototype._version = 3;
+	SourceMapConsumer.prototype.__generatedMappings = null;
+	Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
+		configurable: true,
+		enumerable: true,
+		get: function() {
+			if (!this.__generatedMappings) this._parseMappings(this._mappings, this.sourceRoot);
+			return this.__generatedMappings;
+		}
+	});
+	SourceMapConsumer.prototype.__originalMappings = null;
+	Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
+		configurable: true,
+		enumerable: true,
+		get: function() {
+			if (!this.__originalMappings) this._parseMappings(this._mappings, this.sourceRoot);
+			return this.__originalMappings;
+		}
+	});
+	SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+		var c = aStr.charAt(index);
+		return c === ";" || c === ",";
+	};
+	/**
+	* 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).
+	*/
+	SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+		throw new Error("Subclasses must implement _parseMappings");
+	};
+	SourceMapConsumer.GENERATED_ORDER = 1;
+	SourceMapConsumer.ORIGINAL_ORDER = 2;
+	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+	/**
+	* 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`.
+	*/
+	SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+		var context = aContext || null;
+		var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+		var mappings;
+		switch (order) {
+			case SourceMapConsumer.GENERATED_ORDER:
+				mappings = this._generatedMappings;
+				break;
+			case SourceMapConsumer.ORIGINAL_ORDER:
+				mappings = this._originalMappings;
+				break;
+			default: throw new Error("Unknown order of iteration.");
+		}
+		var sourceRoot = this.sourceRoot;
+		var boundCallback = aCallback.bind(context);
+		var names = this._names;
+		var sources = this._sources;
+		var sourceMapURL = this._sourceMapURL;
+		for (var i = 0, n = mappings.length; i < n; i++) {
+			var mapping = mappings[i];
+			var source = mapping.source === null ? null : sources.at(mapping.source);
+			if (source !== null) source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
+			boundCallback({
+				source,
+				generatedLine: mapping.generatedLine,
+				generatedColumn: mapping.generatedColumn,
+				originalLine: mapping.originalLine,
+				originalColumn: mapping.originalColumn,
+				name: mapping.name === null ? null : names.at(mapping.name)
+			});
+		}
+	};
+	/**
+	* 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.
+	*/
+	SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+		var line = util.getArg(aArgs, "line");
+		var needle = {
+			source: util.getArg(aArgs, "source"),
+			originalLine: line,
+			originalColumn: util.getArg(aArgs, "column", 0)
+		};
+		needle.source = this._findSourceIndex(needle.source);
+		if (needle.source < 0) return [];
+		var mappings = [];
+		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
+		if (index >= 0) {
+			var mapping = this._originalMappings[index];
+			if (aArgs.column === void 0) {
+				var originalLine = mapping.originalLine;
+				while (mapping && mapping.originalLine === originalLine) {
+					mappings.push({
+						line: util.getArg(mapping, "generatedLine", null),
+						column: util.getArg(mapping, "generatedColumn", null),
+						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+					});
+					mapping = this._originalMappings[++index];
+				}
+			} else {
+				var originalColumn = mapping.originalColumn;
+				while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
+					mappings.push({
+						line: util.getArg(mapping, "generatedLine", null),
+						column: util.getArg(mapping, "generatedColumn", null),
+						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+					});
+					mapping = this._originalMappings[++index];
+				}
+			}
+		}
+		return mappings;
+	};
+	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 referrenced 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#
+	*/
+	function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+		var sourceMap = aSourceMap;
+		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
+		var version = util.getArg(sourceMap, "version");
+		var sources = util.getArg(sourceMap, "sources");
+		var names = util.getArg(sourceMap, "names", []);
+		var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
+		var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
+		var mappings = util.getArg(sourceMap, "mappings");
+		var file = util.getArg(sourceMap, "file", null);
+		if (version != this._version) throw new Error("Unsupported version: " + version);
+		if (sourceRoot) sourceRoot = util.normalize(sourceRoot);
+		sources = sources.map(String).map(util.normalize).map(function(source) {
+			return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
+		});
+		this._names = ArraySet.fromArray(names.map(String), true);
+		this._sources = ArraySet.fromArray(sources, true);
+		this._absoluteSources = this._sources.toArray().map(function(s) {
+			return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+		});
+		this.sourceRoot = sourceRoot;
+		this.sourcesContent = sourcesContent;
+		this._mappings = mappings;
+		this._sourceMapURL = aSourceMapURL;
+		this.file = file;
+	}
+	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+	/**
+	* Utility function to find the index of a source.  Returns -1 if not
+	* found.
+	*/
+	BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
+		var relativeSource = aSource;
+		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
+		if (this._sources.has(relativeSource)) return this._sources.indexOf(relativeSource);
+		var i;
+		for (i = 0; i < this._absoluteSources.length; ++i) if (this._absoluteSources[i] == aSource) return i;
+		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
+	*/
+	BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
+		var smc = Object.create(BasicSourceMapConsumer.prototype);
+		var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+		var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+		smc.sourceRoot = aSourceMap._sourceRoot;
+		smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
+		smc.file = aSourceMap._file;
+		smc._sourceMapURL = aSourceMapURL;
+		smc._absoluteSources = smc._sources.toArray().map(function(s) {
+			return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+		});
+		var generatedMappings = aSourceMap._mappings.toArray().slice();
+		var destGeneratedMappings = smc.__generatedMappings = [];
+		var destOriginalMappings = smc.__originalMappings = [];
+		for (var i = 0, length = generatedMappings.length; i < length; i++) {
+			var srcMapping = generatedMappings[i];
+			var destMapping = new Mapping();
+			destMapping.generatedLine = srcMapping.generatedLine;
+			destMapping.generatedColumn = srcMapping.generatedColumn;
+			if (srcMapping.source) {
+				destMapping.source = sources.indexOf(srcMapping.source);
+				destMapping.originalLine = srcMapping.originalLine;
+				destMapping.originalColumn = srcMapping.originalColumn;
+				if (srcMapping.name) destMapping.name = names.indexOf(srcMapping.name);
+				destOriginalMappings.push(destMapping);
+			}
+			destGeneratedMappings.push(destMapping);
+		}
+		quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+		return smc;
+	};
+	/**
+	* The version of the source mapping spec that we are consuming.
+	*/
+	BasicSourceMapConsumer.prototype._version = 3;
+	/**
+	* The list of original sources.
+	*/
+	Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { get: function() {
+		return this._absoluteSources.slice();
+	} });
+	/**
+	* Provide the JIT with a nice shape / hidden class.
+	*/
+	function Mapping() {
+		this.generatedLine = 0;
+		this.generatedColumn = 0;
+		this.source = null;
+		this.originalLine = null;
+		this.originalColumn = null;
+		this.name = null;
+	}
+	/**
+	* 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).
+	*/
+	const compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
+	function sortGenerated(array, start) {
+		let l = array.length;
+		let n = array.length - start;
+		if (n <= 1) return;
+		else if (n == 2) {
+			let a = array[start];
+			let b = array[start + 1];
+			if (compareGenerated(a, b) > 0) {
+				array[start] = b;
+				array[start + 1] = a;
+			}
+		} else if (n < 20) for (let i = start; i < l; i++) for (let j = i; j > start; j--) {
+			let a = array[j - 1];
+			let b = array[j];
+			if (compareGenerated(a, b) <= 0) break;
+			array[j - 1] = b;
+			array[j] = a;
+		}
+		else quickSort(array, compareGenerated, start);
+	}
+	BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+		var generatedLine = 1;
+		var previousGeneratedColumn = 0;
+		var previousOriginalLine = 0;
+		var previousOriginalColumn = 0;
+		var previousSource = 0;
+		var previousName = 0;
+		var length = aStr.length;
+		var index = 0;
+		var temp = {};
+		var originalMappings = [];
+		var generatedMappings = [], mapping, segment, end, value;
+		let subarrayStart = 0;
+		while (index < length) if (aStr.charAt(index) === ";") {
+			generatedLine++;
+			index++;
+			previousGeneratedColumn = 0;
+			sortGenerated(generatedMappings, subarrayStart);
+			subarrayStart = generatedMappings.length;
+		} else if (aStr.charAt(index) === ",") index++;
+		else {
+			mapping = new Mapping();
+			mapping.generatedLine = generatedLine;
+			for (end = index; end < length; end++) if (this._charIsMappingSeparator(aStr, end)) break;
+			aStr.slice(index, end);
+			segment = [];
+			while (index < end) {
+				base64VLQ.decode(aStr, index, temp);
+				value = temp.value;
+				index = temp.rest;
+				segment.push(value);
+			}
+			if (segment.length === 2) throw new Error("Found a source, but no line and column");
+			if (segment.length === 3) throw new Error("Found a source and line, but no column");
+			mapping.generatedColumn = previousGeneratedColumn + segment[0];
+			previousGeneratedColumn = mapping.generatedColumn;
+			if (segment.length > 1) {
+				mapping.source = previousSource + segment[1];
+				previousSource += segment[1];
+				mapping.originalLine = previousOriginalLine + segment[2];
+				previousOriginalLine = mapping.originalLine;
+				mapping.originalLine += 1;
+				mapping.originalColumn = previousOriginalColumn + segment[3];
+				previousOriginalColumn = mapping.originalColumn;
+				if (segment.length > 4) {
+					mapping.name = previousName + segment[4];
+					previousName += segment[4];
+				}
+			}
+			generatedMappings.push(mapping);
+			if (typeof mapping.originalLine === "number") {
+				let currentSource = mapping.source;
+				while (originalMappings.length <= currentSource) originalMappings.push(null);
+				if (originalMappings[currentSource] === null) originalMappings[currentSource] = [];
+				originalMappings[currentSource].push(mapping);
+			}
+		}
+		sortGenerated(generatedMappings, subarrayStart);
+		this.__generatedMappings = generatedMappings;
+		for (var i = 0; i < originalMappings.length; i++) if (originalMappings[i] != null) quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
+		this.__originalMappings = [].concat(...originalMappings);
+	};
+	/**
+	* Find the mapping that best matches the hypothetical "needle" mapping that
+	* we are searching for in the given "haystack" of mappings.
+	*/
+	BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
+		if (aNeedle[aLineName] <= 0) throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
+		if (aNeedle[aColumnName] < 0) throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
+		return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+	};
+	/**
+	* Compute the last column for each generated mapping. The last column is
+	* inclusive.
+	*/
+	BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
+		for (var index = 0; index < this._generatedMappings.length; ++index) {
+			var mapping = this._generatedMappings[index];
+			if (index + 1 < this._generatedMappings.length) {
+				var nextMapping = this._generatedMappings[index + 1];
+				if (mapping.generatedLine === nextMapping.generatedLine) {
+					mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+					continue;
+				}
+			}
+			mapping.lastGeneratedColumn = Infinity;
+		}
+	};
+	/**
+	* 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.
+	*/
+	BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
+		var needle = {
+			generatedLine: util.getArg(aArgs, "line"),
+			generatedColumn: util.getArg(aArgs, "column")
+		};
+		var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
+		if (index >= 0) {
+			var mapping = this._generatedMappings[index];
+			if (mapping.generatedLine === needle.generatedLine) {
+				var source = util.getArg(mapping, "source", null);
+				if (source !== null) {
+					source = this._sources.at(source);
+					source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+				}
+				var 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.
+	*/
+	BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_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.
+	*/
+	BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+		if (!this.sourcesContent) return null;
+		var index = this._findSourceIndex(aSource);
+		if (index >= 0) return this.sourcesContent[index];
+		var relativeSource = aSource;
+		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
+		var url;
+		if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
+			var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
+			if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
+			if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+		}
+		if (nullOnMissing) return null;
+		else throw new Error("\"" + relativeSource + "\" 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.
+	*/
+	BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
+		var source = util.getArg(aArgs, "source");
+		source = this._findSourceIndex(source);
+		if (source < 0) return {
+			line: null,
+			column: null,
+			lastColumn: null
+		};
+		var needle = {
+			source,
+			originalLine: util.getArg(aArgs, "line"),
+			originalColumn: util.getArg(aArgs, "column")
+		};
+		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
+		if (index >= 0) {
+			var mapping = this._originalMappings[index];
+			if (mapping.source === needle.source) return {
+				line: util.getArg(mapping, "generatedLine", null),
+				column: util.getArg(mapping, "generatedColumn", null),
+				lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+			};
+		}
+		return {
+			line: null,
+			column: null,
+			lastColumn: null
+		};
+	};
+	exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+	/**
+	* An IndexedSourceMapConsumer instance represents a parsed source map which
+	* we can query for information. It differs from BasicSourceMapConsumer in
+	* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
+	* input.
+	*
+	* The first parameter is a raw source map (either as a JSON string, or already
+	* parsed to an object). According to the spec for indexed source maps, they
+	* have the following attributes:
+	*
+	*   - version: Which version of the source map spec this map is following.
+	*   - file: Optional. The generated file this source map is associated with.
+	*   - sections: A list of section definitions.
+	*
+	* Each value under the "sections" field has two fields:
+	*   - offset: The offset into the original specified at which this section
+	*       begins to apply, defined as an object with a "line" and "column"
+	*       field.
+	*   - map: A source map definition. This source map could also be indexed,
+	*       but doesn't have to be.
+	*
+	* Instead of the "map" field, it's also possible to have a "url" field
+	* specifying a URL to retrieve a source map from, but that's currently
+	* unsupported.
+	*
+	* Here's an example source map, taken from the source map spec[0], but
+	* modified to omit a section which uses the "url" field.
+	*
+	*  {
+	*    version : 3,
+	*    file: "app.js",
+	*    sections: [{
+	*      offset: {line:100, column:10},
+	*      map: {
+	*        version : 3,
+	*        file: "section.js",
+	*        sources: ["foo.js", "bar.js"],
+	*        names: ["src", "maps", "are", "fun"],
+	*        mappings: "AAAA,E;;ABCDE;"
+	*      }
+	*    }],
+	*  }
+	*
+	* The second parameter, if given, is a string whose value is the URL
+	* at which the source map was found.  This URL is used to compute the
+	* sources array.
+	*
+	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
+	*/
+	function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+		var sourceMap = aSourceMap;
+		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
+		var version = util.getArg(sourceMap, "version");
+		var sections = util.getArg(sourceMap, "sections");
+		if (version != this._version) throw new Error("Unsupported version: " + version);
+		this._sources = new ArraySet();
+		this._names = new ArraySet();
+		var lastOffset = {
+			line: -1,
+			column: 0
+		};
+		this._sections = sections.map(function(s) {
+			if (s.url) throw new Error("Support for url field in sections not implemented.");
+			var offset = util.getArg(s, "offset");
+			var offsetLine = util.getArg(offset, "line");
+			var 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;
+			return {
+				generatedOffset: {
+					generatedLine: offsetLine + 1,
+					generatedColumn: offsetColumn + 1
+				},
+				consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
+			};
+		});
+	}
+	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+	/**
+	* The version of the source mapping spec that we are consuming.
+	*/
+	IndexedSourceMapConsumer.prototype._version = 3;
+	/**
+	* The list of original sources.
+	*/
+	Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { get: function() {
+		var sources = [];
+		for (var i = 0; i < this._sections.length; i++) for (var 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.
+	*/
+	IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+		var needle = {
+			generatedLine: util.getArg(aArgs, "line"),
+			generatedColumn: util.getArg(aArgs, "column")
+		};
+		var sectionIndex = binarySearch.search(needle, this._sections, function(needle, section) {
+			var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
+			if (cmp) return cmp;
+			return needle.generatedColumn - section.generatedOffset.generatedColumn;
+		});
+		var 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.
+	*/
+	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_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.
+	*/
+	IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+		for (var i = 0; i < this._sections.length; i++) {
+			var content = this._sections[i].consumer.sourceContentFor(aSource, true);
+			if (content || content === "") return content;
+		}
+		if (nullOnMissing) return null;
+		else 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.
+	*
+	* 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.
+	*/
+	IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+		for (var i = 0; i < this._sections.length; i++) {
+			var section = this._sections[i];
+			if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) continue;
+			var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+			if (generatedPosition) return {
+				line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
+				column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
+			};
+		}
+		return {
+			line: null,
+			column: null
+		};
+	};
+	/**
+	* 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).
+	*/
+	IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+		this.__generatedMappings = [];
+		this.__originalMappings = [];
+		for (var i = 0; i < this._sections.length; i++) {
+			var section = this._sections[i];
+			var sectionMappings = section.consumer._generatedMappings;
+			for (var j = 0; j < sectionMappings.length; j++) {
+				var mapping = sectionMappings[j];
+				var source = section.consumer._sources.at(mapping.source);
+				if (source !== null) source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
+				this._sources.add(source);
+				source = this._sources.indexOf(source);
+				var name = null;
+				if (mapping.name) {
+					name = section.consumer._names.at(mapping.name);
+					this._names.add(name);
+					name = this._names.indexOf(name);
+				}
+				var adjustedMapping = {
+					source,
+					generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
+					generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+					originalLine: mapping.originalLine,
+					originalColumn: mapping.originalColumn,
+					name
+				};
+				this.__generatedMappings.push(adjustedMapping);
+				if (typeof adjustedMapping.originalLine === "number") this.__originalMappings.push(adjustedMapping);
+			}
+		}
+		quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+		quickSort(this.__originalMappings, util.compareByOriginalPositions);
+	};
+	exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_source_map_consumer();
+	}
+});
+
+//# sourceMappingURL=source-map-consumer.cjs.map