1 /* -*- Mode: js; js-indent-level: 2; -*- */
3 * Copyright 2011 Mozilla Foundation and contributors
4 * Licensed under the New BSD license. See LICENSE or:
5 * http://opensource.org/licenses/BSD-3-Clause
8 var util = require('./util');
9 var binarySearch = require('./binary-search');
10 var ArraySet = require('./array-set').ArraySet;
11 var base64VLQ = require('./base64-vlq');
12 var quickSort = require('./quick-sort').quickSort;
14 function SourceMapConsumer(aSourceMap, aSourceMapURL) {
15 var sourceMap = aSourceMap;
16 if (typeof aSourceMap === 'string') {
17 sourceMap = util.parseSourceMapInput(aSourceMap);
20 return sourceMap.sections != null
21 ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
22 : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
25 SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
26 return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
30 * The version of the source mapping spec that we are consuming.
32 SourceMapConsumer.prototype._version = 3;
34 // `__generatedMappings` and `__originalMappings` are arrays that hold the
35 // parsed mapping coordinates from the source map's "mappings" attribute. They
36 // are lazily instantiated, accessed via the `_generatedMappings` and
37 // `_originalMappings` getters respectively, and we only parse the mappings
38 // and create these arrays once queried for a source location. We jump through
39 // these hoops because there can be many thousands of mappings, and parsing
40 // them is expensive, so we only want to do it if we must.
42 // Each object in the arrays is of the form:
45 // generatedLine: The line number in the generated code,
46 // generatedColumn: The column number in the generated code,
47 // source: The path to the original source file that generated this
49 // originalLine: The line number in the original source that
50 // corresponds to this chunk of generated code,
51 // originalColumn: The column number in the original source that
52 // corresponds to this chunk of generated code,
53 // name: The name of the original symbol which generated this chunk of
57 // All properties except for `generatedLine` and `generatedColumn` can be
60 // `_generatedMappings` is ordered by the generated positions.
62 // `_originalMappings` is ordered by the original positions.
64 SourceMapConsumer.prototype.__generatedMappings = null;
65 Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
69 if (!this.__generatedMappings) {
70 this._parseMappings(this._mappings, this.sourceRoot);
73 return this.__generatedMappings;
77 SourceMapConsumer.prototype.__originalMappings = null;
78 Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
82 if (!this.__originalMappings) {
83 this._parseMappings(this._mappings, this.sourceRoot);
86 return this.__originalMappings;
90 SourceMapConsumer.prototype._charIsMappingSeparator =
91 function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
92 var c = aStr.charAt(index);
93 return c === ";" || c === ",";
97 * Parse the mappings in a string in to a data structure which we can easily
98 * query (the ordered arrays in the `this.__generatedMappings` and
99 * `this.__originalMappings` properties).
101 SourceMapConsumer.prototype._parseMappings =
102 function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
103 throw new Error("Subclasses must implement _parseMappings");
106 SourceMapConsumer.GENERATED_ORDER = 1;
107 SourceMapConsumer.ORIGINAL_ORDER = 2;
109 SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
110 SourceMapConsumer.LEAST_UPPER_BOUND = 2;
113 * Iterate over each mapping between an original source/line/column and a
114 * generated line/column in this source map.
116 * @param Function aCallback
117 * The function that is called with each mapping.
118 * @param Object aContext
119 * Optional. If specified, this object will be the value of `this` every
120 * time that `aCallback` is called.
122 * Either `SourceMapConsumer.GENERATED_ORDER` or
123 * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
124 * iterate over the mappings sorted by the generated file's line/column
125 * order or the original's source/line/column order, respectively. Defaults to
126 * `SourceMapConsumer.GENERATED_ORDER`.
128 SourceMapConsumer.prototype.eachMapping =
129 function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
130 var context = aContext || null;
131 var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
135 case SourceMapConsumer.GENERATED_ORDER:
136 mappings = this._generatedMappings;
138 case SourceMapConsumer.ORIGINAL_ORDER:
139 mappings = this._originalMappings;
142 throw new Error("Unknown order of iteration.");
145 var sourceRoot = this.sourceRoot;
146 mappings.map(function (mapping) {
147 var source = mapping.source === null ? null : this._sources.at(mapping.source);
148 source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
151 generatedLine: mapping.generatedLine,
152 generatedColumn: mapping.generatedColumn,
153 originalLine: mapping.originalLine,
154 originalColumn: mapping.originalColumn,
155 name: mapping.name === null ? null : this._names.at(mapping.name)
157 }, this).forEach(aCallback, context);
161 * Returns all generated line and column information for the original source,
162 * line, and column provided. If no column is provided, returns all mappings
163 * corresponding to a either the line we are searching for or the next
164 * closest line that has any mappings. Otherwise, returns all mappings
165 * corresponding to the given line and either the column we are searching for
166 * or the next closest column that has any offsets.
168 * The only argument is an object with the following properties:
170 * - source: The filename of the original source.
171 * - line: The line number in the original source. The line number is 1-based.
172 * - column: Optional. the column number in the original source.
173 * The column number is 0-based.
175 * and an array of objects is returned, each with the following properties:
177 * - line: The line number in the generated source, or null. The
178 * line number is 1-based.
179 * - column: The column number in the generated source, or null.
180 * The column number is 0-based.
182 SourceMapConsumer.prototype.allGeneratedPositionsFor =
183 function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
184 var line = util.getArg(aArgs, 'line');
186 // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
187 // returns the index of the closest mapping less than the needle. By
188 // setting needle.originalColumn to 0, we thus find the last mapping for
189 // the given line, provided such a mapping exists.
191 source: util.getArg(aArgs, 'source'),
193 originalColumn: util.getArg(aArgs, 'column', 0)
196 needle.source = this._findSourceIndex(needle.source);
197 if (needle.source < 0) {
203 var index = this._findMapping(needle,
204 this._originalMappings,
207 util.compareByOriginalPositions,
208 binarySearch.LEAST_UPPER_BOUND);
210 var mapping = this._originalMappings[index];
212 if (aArgs.column === undefined) {
213 var originalLine = mapping.originalLine;
215 // Iterate until either we run out of mappings, or we run into
216 // a mapping for a different line than the one we found. Since
217 // mappings are sorted, this is guaranteed to find all mappings for
218 // the line we found.
219 while (mapping && mapping.originalLine === originalLine) {
221 line: util.getArg(mapping, 'generatedLine', null),
222 column: util.getArg(mapping, 'generatedColumn', null),
223 lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
226 mapping = this._originalMappings[++index];
229 var originalColumn = mapping.originalColumn;
231 // Iterate until either we run out of mappings, or we run into
232 // a mapping for a different line than the one we were searching for.
233 // Since mappings are sorted, this is guaranteed to find all mappings for
234 // the line we are searching for.
236 mapping.originalLine === line &&
237 mapping.originalColumn == originalColumn) {
239 line: util.getArg(mapping, 'generatedLine', null),
240 column: util.getArg(mapping, 'generatedColumn', null),
241 lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
244 mapping = this._originalMappings[++index];
252 exports.SourceMapConsumer = SourceMapConsumer;
255 * A BasicSourceMapConsumer instance represents a parsed source map which we can
256 * query for information about the original file positions by giving it a file
257 * position in the generated source.
259 * The first parameter is the raw source map (either as a JSON string, or
260 * already parsed to an object). According to the spec, source maps have the
261 * following attributes:
263 * - version: Which version of the source map spec this map is following.
264 * - sources: An array of URLs to the original source files.
265 * - names: An array of identifiers which can be referrenced by individual mappings.
266 * - sourceRoot: Optional. The URL root from which all sources are relative.
267 * - sourcesContent: Optional. An array of contents of the original source files.
268 * - mappings: A string of base64 VLQs which contain the actual mappings.
269 * - file: Optional. The generated file this source map is associated with.
271 * Here is an example source map, taken from the source map spec[0]:
277 * sources: ["foo.js", "bar.js"],
278 * names: ["src", "maps", "are", "fun"],
279 * mappings: "AA,AB;;ABCDE;"
282 * The second parameter, if given, is a string whose value is the URL
283 * at which the source map was found. This URL is used to compute the
286 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
288 function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
289 var sourceMap = aSourceMap;
290 if (typeof aSourceMap === 'string') {
291 sourceMap = util.parseSourceMapInput(aSourceMap);
294 var version = util.getArg(sourceMap, 'version');
295 var sources = util.getArg(sourceMap, 'sources');
296 // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
297 // requires the array) to play nice here.
298 var names = util.getArg(sourceMap, 'names', []);
299 var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
300 var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
301 var mappings = util.getArg(sourceMap, 'mappings');
302 var file = util.getArg(sourceMap, 'file', null);
304 // Once again, Sass deviates from the spec and supplies the version as a
305 // string rather than a number, so we use loose equality checking here.
306 if (version != this._version) {
307 throw new Error('Unsupported version: ' + version);
311 sourceRoot = util.normalize(sourceRoot);
316 // Some source maps produce relative source paths like "./foo.js" instead of
317 // "foo.js". Normalize these first so that future comparisons will succeed.
318 // See bugzil.la/1090768.
320 // Always ensure that absolute sources are internally stored relative to
321 // the source root, if the source root is absolute. Not doing this would
322 // be particularly problematic when the source root is a prefix of the
323 // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
324 .map(function (source) {
325 return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
326 ? util.relative(sourceRoot, source)
330 // Pass `true` below to allow duplicate names and sources. While source maps
331 // are intended to be compressed and deduplicated, the TypeScript compiler
332 // sometimes generates source maps with duplicates in them. See Github issue
333 // #72 and bugzil.la/889492.
334 this._names = ArraySet.fromArray(names.map(String), true);
335 this._sources = ArraySet.fromArray(sources, true);
337 this._absoluteSources = this._sources.toArray().map(function (s) {
338 return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
341 this.sourceRoot = sourceRoot;
342 this.sourcesContent = sourcesContent;
343 this._mappings = mappings;
344 this._sourceMapURL = aSourceMapURL;
348 BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
349 BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
352 * Utility function to find the index of a source. Returns -1 if not
355 BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
356 var relativeSource = aSource;
357 if (this.sourceRoot != null) {
358 relativeSource = util.relative(this.sourceRoot, relativeSource);
361 if (this._sources.has(relativeSource)) {
362 return this._sources.indexOf(relativeSource);
365 // Maybe aSource is an absolute URL as returned by |sources|. In
366 // this case we can't simply undo the transform.
368 for (i = 0; i < this._absoluteSources.length; ++i) {
369 if (this._absoluteSources[i] == aSource) {
378 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
380 * @param SourceMapGenerator aSourceMap
381 * The source map that will be consumed.
382 * @param String aSourceMapURL
383 * The URL at which the source map can be found (optional)
384 * @returns BasicSourceMapConsumer
386 BasicSourceMapConsumer.fromSourceMap =
387 function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
388 var smc = Object.create(BasicSourceMapConsumer.prototype);
390 var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
391 var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
392 smc.sourceRoot = aSourceMap._sourceRoot;
393 smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
395 smc.file = aSourceMap._file;
396 smc._sourceMapURL = aSourceMapURL;
397 smc._absoluteSources = smc._sources.toArray().map(function (s) {
398 return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
401 // Because we are modifying the entries (by converting string sources and
402 // names to indices into the sources and names ArraySets), we have to make
403 // a copy of the entry or else bad things happen. Shared mutable state
404 // strikes again! See github issue #191.
406 var generatedMappings = aSourceMap._mappings.toArray().slice();
407 var destGeneratedMappings = smc.__generatedMappings = [];
408 var destOriginalMappings = smc.__originalMappings = [];
410 for (var i = 0, length = generatedMappings.length; i < length; i++) {
411 var srcMapping = generatedMappings[i];
412 var destMapping = new Mapping;
413 destMapping.generatedLine = srcMapping.generatedLine;
414 destMapping.generatedColumn = srcMapping.generatedColumn;
416 if (srcMapping.source) {
417 destMapping.source = sources.indexOf(srcMapping.source);
418 destMapping.originalLine = srcMapping.originalLine;
419 destMapping.originalColumn = srcMapping.originalColumn;
421 if (srcMapping.name) {
422 destMapping.name = names.indexOf(srcMapping.name);
425 destOriginalMappings.push(destMapping);
428 destGeneratedMappings.push(destMapping);
431 quickSort(smc.__originalMappings, util.compareByOriginalPositions);
437 * The version of the source mapping spec that we are consuming.
439 BasicSourceMapConsumer.prototype._version = 3;
442 * The list of original sources.
444 Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
446 return this._absoluteSources.slice();
451 * Provide the JIT with a nice shape / hidden class.
454 this.generatedLine = 0;
455 this.generatedColumn = 0;
457 this.originalLine = null;
458 this.originalColumn = null;
463 * Parse the mappings in a string in to a data structure which we can easily
464 * query (the ordered arrays in the `this.__generatedMappings` and
465 * `this.__originalMappings` properties).
467 BasicSourceMapConsumer.prototype._parseMappings =
468 function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
469 var generatedLine = 1;
470 var previousGeneratedColumn = 0;
471 var previousOriginalLine = 0;
472 var previousOriginalColumn = 0;
473 var previousSource = 0;
474 var previousName = 0;
475 var length = aStr.length;
477 var cachedSegments = {};
479 var originalMappings = [];
480 var generatedMappings = [];
481 var mapping, str, segment, end, value;
483 while (index < length) {
484 if (aStr.charAt(index) === ';') {
487 previousGeneratedColumn = 0;
489 else if (aStr.charAt(index) === ',') {
493 mapping = new Mapping();
494 mapping.generatedLine = generatedLine;
496 // Because each offset is encoded relative to the previous one,
497 // many segments often have the same encoding. We can exploit this
498 // fact by caching the parsed variable length fields of each segment,
499 // allowing us to avoid a second parse if we encounter the same
501 for (end = index; end < length; end++) {
502 if (this._charIsMappingSeparator(aStr, end)) {
506 str = aStr.slice(index, end);
508 segment = cachedSegments[str];
513 while (index < end) {
514 base64VLQ.decode(aStr, index, temp);
520 if (segment.length === 2) {
521 throw new Error('Found a source, but no line and column');
524 if (segment.length === 3) {
525 throw new Error('Found a source and line, but no column');
528 cachedSegments[str] = segment;
532 mapping.generatedColumn = previousGeneratedColumn + segment[0];
533 previousGeneratedColumn = mapping.generatedColumn;
535 if (segment.length > 1) {
537 mapping.source = previousSource + segment[1];
538 previousSource += segment[1];
541 mapping.originalLine = previousOriginalLine + segment[2];
542 previousOriginalLine = mapping.originalLine;
543 // Lines are stored 0-based
544 mapping.originalLine += 1;
547 mapping.originalColumn = previousOriginalColumn + segment[3];
548 previousOriginalColumn = mapping.originalColumn;
550 if (segment.length > 4) {
552 mapping.name = previousName + segment[4];
553 previousName += segment[4];
557 generatedMappings.push(mapping);
558 if (typeof mapping.originalLine === 'number') {
559 originalMappings.push(mapping);
564 quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
565 this.__generatedMappings = generatedMappings;
567 quickSort(originalMappings, util.compareByOriginalPositions);
568 this.__originalMappings = originalMappings;
572 * Find the mapping that best matches the hypothetical "needle" mapping that
573 * we are searching for in the given "haystack" of mappings.
575 BasicSourceMapConsumer.prototype._findMapping =
576 function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
577 aColumnName, aComparator, aBias) {
578 // To return the position we are searching for, we must first find the
579 // mapping for the given position and then return the opposite position it
580 // points to. Because the mappings are sorted, we can use binary search to
581 // find the best mapping.
583 if (aNeedle[aLineName] <= 0) {
584 throw new TypeError('Line must be greater than or equal to 1, got '
585 + aNeedle[aLineName]);
587 if (aNeedle[aColumnName] < 0) {
588 throw new TypeError('Column must be greater than or equal to 0, got '
589 + aNeedle[aColumnName]);
592 return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
596 * Compute the last column for each generated mapping. The last column is
599 BasicSourceMapConsumer.prototype.computeColumnSpans =
600 function SourceMapConsumer_computeColumnSpans() {
601 for (var index = 0; index < this._generatedMappings.length; ++index) {
602 var mapping = this._generatedMappings[index];
604 // Mappings do not contain a field for the last generated columnt. We
605 // can come up with an optimistic estimate, however, by assuming that
606 // mappings are contiguous (i.e. given two consecutive mappings, the
607 // first mapping ends where the second one starts).
608 if (index + 1 < this._generatedMappings.length) {
609 var nextMapping = this._generatedMappings[index + 1];
611 if (mapping.generatedLine === nextMapping.generatedLine) {
612 mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
617 // The last mapping for each line spans the entire line.
618 mapping.lastGeneratedColumn = Infinity;
623 * Returns the original source, line, and column information for the generated
624 * source's line and column positions provided. The only argument is an object
625 * with the following properties:
627 * - line: The line number in the generated source. The line number
629 * - column: The column number in the generated source. The column
631 * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
632 * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
633 * closest element that is smaller than or greater than the one we are
634 * searching for, respectively, if the exact element cannot be found.
635 * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
637 * and an object is returned with the following properties:
639 * - source: The original source file, or null.
640 * - line: The line number in the original source, or null. The
641 * line number is 1-based.
642 * - column: The column number in the original source, or null. The
643 * column number is 0-based.
644 * - name: The original identifier, or null.
646 BasicSourceMapConsumer.prototype.originalPositionFor =
647 function SourceMapConsumer_originalPositionFor(aArgs) {
649 generatedLine: util.getArg(aArgs, 'line'),
650 generatedColumn: util.getArg(aArgs, 'column')
653 var index = this._findMapping(
655 this._generatedMappings,
658 util.compareByGeneratedPositionsDeflated,
659 util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
663 var mapping = this._generatedMappings[index];
665 if (mapping.generatedLine === needle.generatedLine) {
666 var source = util.getArg(mapping, 'source', null);
667 if (source !== null) {
668 source = this._sources.at(source);
669 source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
671 var name = util.getArg(mapping, 'name', null);
673 name = this._names.at(name);
677 line: util.getArg(mapping, 'originalLine', null),
678 column: util.getArg(mapping, 'originalColumn', null),
693 * Return true if we have the source content for every source in the source
694 * map, false otherwise.
696 BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
697 function BasicSourceMapConsumer_hasContentsOfAllSources() {
698 if (!this.sourcesContent) {
701 return this.sourcesContent.length >= this._sources.size() &&
702 !this.sourcesContent.some(function (sc) { return sc == null; });
706 * Returns the original source content. The only argument is the url of the
707 * original source file. Returns null if no original source content is
710 BasicSourceMapConsumer.prototype.sourceContentFor =
711 function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
712 if (!this.sourcesContent) {
716 var index = this._findSourceIndex(aSource);
718 return this.sourcesContent[index];
721 var relativeSource = aSource;
722 if (this.sourceRoot != null) {
723 relativeSource = util.relative(this.sourceRoot, relativeSource);
727 if (this.sourceRoot != null
728 && (url = util.urlParse(this.sourceRoot))) {
729 // XXX: file:// URIs and absolute paths lead to unexpected behavior for
730 // many users. We can help them out when they expect file:// URIs to
731 // behave like it would if they were running a local HTTP server. See
732 // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
733 var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
734 if (url.scheme == "file"
735 && this._sources.has(fileUriAbsPath)) {
736 return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
739 if ((!url.path || url.path == "/")
740 && this._sources.has("/" + relativeSource)) {
741 return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
745 // This function is used recursively from
746 // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
747 // don't want to throw if we can't find the source - we just want to
748 // return null, so we provide a flag to exit gracefully.
753 throw new Error('"' + relativeSource + '" is not in the SourceMap.');
758 * Returns the generated line and column information for the original source,
759 * line, and column positions provided. The only argument is an object with
760 * the following properties:
762 * - source: The filename of the original source.
763 * - line: The line number in the original source. The line number
765 * - column: The column number in the original source. The column
767 * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
768 * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
769 * closest element that is smaller than or greater than the one we are
770 * searching for, respectively, if the exact element cannot be found.
771 * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
773 * and an object is returned with the following properties:
775 * - line: The line number in the generated source, or null. The
776 * line number is 1-based.
777 * - column: The column number in the generated source, or null.
778 * The column number is 0-based.
780 BasicSourceMapConsumer.prototype.generatedPositionFor =
781 function SourceMapConsumer_generatedPositionFor(aArgs) {
782 var source = util.getArg(aArgs, 'source');
783 source = this._findSourceIndex(source);
794 originalLine: util.getArg(aArgs, 'line'),
795 originalColumn: util.getArg(aArgs, 'column')
798 var index = this._findMapping(
800 this._originalMappings,
803 util.compareByOriginalPositions,
804 util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
808 var mapping = this._originalMappings[index];
810 if (mapping.source === needle.source) {
812 line: util.getArg(mapping, 'generatedLine', null),
813 column: util.getArg(mapping, 'generatedColumn', null),
814 lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
826 exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
829 * An IndexedSourceMapConsumer instance represents a parsed source map which
830 * we can query for information. It differs from BasicSourceMapConsumer in
831 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
834 * The first parameter is a raw source map (either as a JSON string, or already
835 * parsed to an object). According to the spec for indexed source maps, they
836 * have the following attributes:
838 * - version: Which version of the source map spec this map is following.
839 * - file: Optional. The generated file this source map is associated with.
840 * - sections: A list of section definitions.
842 * Each value under the "sections" field has two fields:
843 * - offset: The offset into the original specified at which this section
844 * begins to apply, defined as an object with a "line" and "column"
846 * - map: A source map definition. This source map could also be indexed,
847 * but doesn't have to be.
849 * Instead of the "map" field, it's also possible to have a "url" field
850 * specifying a URL to retrieve a source map from, but that's currently
853 * Here's an example source map, taken from the source map spec[0], but
854 * modified to omit a section which uses the "url" field.
860 * offset: {line:100, column:10},
863 * file: "section.js",
864 * sources: ["foo.js", "bar.js"],
865 * names: ["src", "maps", "are", "fun"],
866 * mappings: "AAAA,E;;ABCDE;"
871 * The second parameter, if given, is a string whose value is the URL
872 * at which the source map was found. This URL is used to compute the
875 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
877 function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
878 var sourceMap = aSourceMap;
879 if (typeof aSourceMap === 'string') {
880 sourceMap = util.parseSourceMapInput(aSourceMap);
883 var version = util.getArg(sourceMap, 'version');
884 var sections = util.getArg(sourceMap, 'sections');
886 if (version != this._version) {
887 throw new Error('Unsupported version: ' + version);
890 this._sources = new ArraySet();
891 this._names = new ArraySet();
897 this._sections = sections.map(function (s) {
899 // The url field will require support for asynchronicity.
900 // See https://github.com/mozilla/source-map/issues/16
901 throw new Error('Support for url field in sections not implemented.');
903 var offset = util.getArg(s, 'offset');
904 var offsetLine = util.getArg(offset, 'line');
905 var offsetColumn = util.getArg(offset, 'column');
907 if (offsetLine < lastOffset.line ||
908 (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
909 throw new Error('Section offsets must be ordered and non-overlapping.');
915 // The offset fields are 0-based, but we use 1-based indices when
916 // encoding/decoding from VLQ.
917 generatedLine: offsetLine + 1,
918 generatedColumn: offsetColumn + 1
920 consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
925 IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
926 IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
929 * The version of the source mapping spec that we are consuming.
931 IndexedSourceMapConsumer.prototype._version = 3;
934 * The list of original sources.
936 Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
939 for (var i = 0; i < this._sections.length; i++) {
940 for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
941 sources.push(this._sections[i].consumer.sources[j]);
949 * Returns the original source, line, and column information for the generated
950 * source's line and column positions provided. The only argument is an object
951 * with the following properties:
953 * - line: The line number in the generated source. The line number
955 * - column: The column number in the generated source. The column
958 * and an object is returned with the following properties:
960 * - source: The original source file, or null.
961 * - line: The line number in the original source, or null. The
962 * line number is 1-based.
963 * - column: The column number in the original source, or null. The
964 * column number is 0-based.
965 * - name: The original identifier, or null.
967 IndexedSourceMapConsumer.prototype.originalPositionFor =
968 function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
970 generatedLine: util.getArg(aArgs, 'line'),
971 generatedColumn: util.getArg(aArgs, 'column')
974 // Find the section containing the generated position we're trying to map
975 // to an original position.
976 var sectionIndex = binarySearch.search(needle, this._sections,
977 function(needle, section) {
978 var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
983 return (needle.generatedColumn -
984 section.generatedOffset.generatedColumn);
986 var section = this._sections[sectionIndex];
997 return section.consumer.originalPositionFor({
998 line: needle.generatedLine -
999 (section.generatedOffset.generatedLine - 1),
1000 column: needle.generatedColumn -
1001 (section.generatedOffset.generatedLine === needle.generatedLine
1002 ? section.generatedOffset.generatedColumn - 1
1009 * Return true if we have the source content for every source in the source
1010 * map, false otherwise.
1012 IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
1013 function IndexedSourceMapConsumer_hasContentsOfAllSources() {
1014 return this._sections.every(function (s) {
1015 return s.consumer.hasContentsOfAllSources();
1020 * Returns the original source content. The only argument is the url of the
1021 * original source file. Returns null if no original source content is
1024 IndexedSourceMapConsumer.prototype.sourceContentFor =
1025 function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
1026 for (var i = 0; i < this._sections.length; i++) {
1027 var section = this._sections[i];
1029 var content = section.consumer.sourceContentFor(aSource, true);
1034 if (nullOnMissing) {
1038 throw new Error('"' + aSource + '" is not in the SourceMap.');
1043 * Returns the generated line and column information for the original source,
1044 * line, and column positions provided. The only argument is an object with
1045 * the following properties:
1047 * - source: The filename of the original source.
1048 * - line: The line number in the original source. The line number
1050 * - column: The column number in the original source. The column
1051 * number is 0-based.
1053 * and an object is returned with the following properties:
1055 * - line: The line number in the generated source, or null. The
1056 * line number is 1-based.
1057 * - column: The column number in the generated source, or null.
1058 * The column number is 0-based.
1060 IndexedSourceMapConsumer.prototype.generatedPositionFor =
1061 function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
1062 for (var i = 0; i < this._sections.length; i++) {
1063 var section = this._sections[i];
1065 // Only consider this section if the requested source is in the list of
1066 // sources of the consumer.
1067 if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
1070 var generatedPosition = section.consumer.generatedPositionFor(aArgs);
1071 if (generatedPosition) {
1073 line: generatedPosition.line +
1074 (section.generatedOffset.generatedLine - 1),
1075 column: generatedPosition.column +
1076 (section.generatedOffset.generatedLine === generatedPosition.line
1077 ? section.generatedOffset.generatedColumn - 1
1091 * Parse the mappings in a string in to a data structure which we can easily
1092 * query (the ordered arrays in the `this.__generatedMappings` and
1093 * `this.__originalMappings` properties).
1095 IndexedSourceMapConsumer.prototype._parseMappings =
1096 function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
1097 this.__generatedMappings = [];
1098 this.__originalMappings = [];
1099 for (var i = 0; i < this._sections.length; i++) {
1100 var section = this._sections[i];
1101 var sectionMappings = section.consumer._generatedMappings;
1102 for (var j = 0; j < sectionMappings.length; j++) {
1103 var mapping = sectionMappings[j];
1105 var source = section.consumer._sources.at(mapping.source);
1106 source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
1107 this._sources.add(source);
1108 source = this._sources.indexOf(source);
1112 name = section.consumer._names.at(mapping.name);
1113 this._names.add(name);
1114 name = this._names.indexOf(name);
1117 // The mappings coming from the consumer for the section have
1118 // generated positions relative to the start of the section, so we
1119 // need to offset them to be relative to the start of the concatenated
1121 var adjustedMapping = {
1123 generatedLine: mapping.generatedLine +
1124 (section.generatedOffset.generatedLine - 1),
1125 generatedColumn: mapping.generatedColumn +
1126 (section.generatedOffset.generatedLine === mapping.generatedLine
1127 ? section.generatedOffset.generatedColumn - 1
1129 originalLine: mapping.originalLine,
1130 originalColumn: mapping.originalColumn,
1134 this.__generatedMappings.push(adjustedMapping);
1135 if (typeof adjustedMapping.originalLine === 'number') {
1136 this.__originalMappings.push(adjustedMapping);
1141 quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
1142 quickSort(this.__originalMappings, util.compareByOriginalPositions);
1145 exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;