source: trip-planner-front/node_modules/source-map-js/lib/source-map-consumer.js

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 40.4 KB
Line 
1/* -*- Mode: js; js-indent-level: 2; -*- */
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
6 */
7
8var util = require('./util');
9var binarySearch = require('./binary-search');
10var ArraySet = require('./array-set').ArraySet;
11var base64VLQ = require('./base64-vlq');
12var quickSort = require('./quick-sort').quickSort;
13
14function SourceMapConsumer(aSourceMap, aSourceMapURL) {
15 var sourceMap = aSourceMap;
16 if (typeof aSourceMap === 'string') {
17 sourceMap = util.parseSourceMapInput(aSourceMap);
18 }
19
20 return sourceMap.sections != null
21 ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
22 : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
23}
24
25SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
26 return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
27}
28
29/**
30 * The version of the source mapping spec that we are consuming.
31 */
32SourceMapConsumer.prototype._version = 3;
33
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.
41//
42// Each object in the arrays is of the form:
43//
44// {
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
48// chunk of code,
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
54// code.
55// }
56//
57// All properties except for `generatedLine` and `generatedColumn` can be
58// `null`.
59//
60// `_generatedMappings` is ordered by the generated positions.
61//
62// `_originalMappings` is ordered by the original positions.
63
64SourceMapConsumer.prototype.__generatedMappings = null;
65Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
66 configurable: true,
67 enumerable: true,
68 get: function () {
69 if (!this.__generatedMappings) {
70 this._parseMappings(this._mappings, this.sourceRoot);
71 }
72
73 return this.__generatedMappings;
74 }
75});
76
77SourceMapConsumer.prototype.__originalMappings = null;
78Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
79 configurable: true,
80 enumerable: true,
81 get: function () {
82 if (!this.__originalMappings) {
83 this._parseMappings(this._mappings, this.sourceRoot);
84 }
85
86 return this.__originalMappings;
87 }
88});
89
90SourceMapConsumer.prototype._charIsMappingSeparator =
91 function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
92 var c = aStr.charAt(index);
93 return c === ";" || c === ",";
94 };
95
96/**
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).
100 */
101SourceMapConsumer.prototype._parseMappings =
102 function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
103 throw new Error("Subclasses must implement _parseMappings");
104 };
105
106SourceMapConsumer.GENERATED_ORDER = 1;
107SourceMapConsumer.ORIGINAL_ORDER = 2;
108
109SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
110SourceMapConsumer.LEAST_UPPER_BOUND = 2;
111
112/**
113 * Iterate over each mapping between an original source/line/column and a
114 * generated line/column in this source map.
115 *
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.
121 * @param aOrder
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`.
127 */
128SourceMapConsumer.prototype.eachMapping =
129 function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
130 var context = aContext || null;
131 var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
132
133 var mappings;
134 switch (order) {
135 case SourceMapConsumer.GENERATED_ORDER:
136 mappings = this._generatedMappings;
137 break;
138 case SourceMapConsumer.ORIGINAL_ORDER:
139 mappings = this._originalMappings;
140 break;
141 default:
142 throw new Error("Unknown order of iteration.");
143 }
144
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);
149 return {
150 source: source,
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)
156 };
157 }, this).forEach(aCallback, context);
158 };
159
160/**
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.
167 *
168 * The only argument is an object with the following properties:
169 *
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.
174 *
175 * and an array of objects is returned, each with the following properties:
176 *
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.
181 */
182SourceMapConsumer.prototype.allGeneratedPositionsFor =
183 function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
184 var line = util.getArg(aArgs, 'line');
185
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.
190 var needle = {
191 source: util.getArg(aArgs, 'source'),
192 originalLine: line,
193 originalColumn: util.getArg(aArgs, 'column', 0)
194 };
195
196 needle.source = this._findSourceIndex(needle.source);
197 if (needle.source < 0) {
198 return [];
199 }
200
201 var mappings = [];
202
203 var index = this._findMapping(needle,
204 this._originalMappings,
205 "originalLine",
206 "originalColumn",
207 util.compareByOriginalPositions,
208 binarySearch.LEAST_UPPER_BOUND);
209 if (index >= 0) {
210 var mapping = this._originalMappings[index];
211
212 if (aArgs.column === undefined) {
213 var originalLine = mapping.originalLine;
214
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) {
220 mappings.push({
221 line: util.getArg(mapping, 'generatedLine', null),
222 column: util.getArg(mapping, 'generatedColumn', null),
223 lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
224 });
225
226 mapping = this._originalMappings[++index];
227 }
228 } else {
229 var originalColumn = mapping.originalColumn;
230
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.
235 while (mapping &&
236 mapping.originalLine === line &&
237 mapping.originalColumn == originalColumn) {
238 mappings.push({
239 line: util.getArg(mapping, 'generatedLine', null),
240 column: util.getArg(mapping, 'generatedColumn', null),
241 lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
242 });
243
244 mapping = this._originalMappings[++index];
245 }
246 }
247 }
248
249 return mappings;
250 };
251
252exports.SourceMapConsumer = SourceMapConsumer;
253
254/**
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.
258 *
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:
262 *
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.
270 *
271 * Here is an example source map, taken from the source map spec[0]:
272 *
273 * {
274 * version : 3,
275 * file: "out.js",
276 * sourceRoot : "",
277 * sources: ["foo.js", "bar.js"],
278 * names: ["src", "maps", "are", "fun"],
279 * mappings: "AA,AB;;ABCDE;"
280 * }
281 *
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
284 * sources array.
285 *
286 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
287 */
288function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
289 var sourceMap = aSourceMap;
290 if (typeof aSourceMap === 'string') {
291 sourceMap = util.parseSourceMapInput(aSourceMap);
292 }
293
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);
303
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);
308 }
309
310 if (sourceRoot) {
311 sourceRoot = util.normalize(sourceRoot);
312 }
313
314 sources = sources
315 .map(String)
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.
319 .map(util.normalize)
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)
327 : source;
328 });
329
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);
336
337 this._absoluteSources = this._sources.toArray().map(function (s) {
338 return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
339 });
340
341 this.sourceRoot = sourceRoot;
342 this.sourcesContent = sourcesContent;
343 this._mappings = mappings;
344 this._sourceMapURL = aSourceMapURL;
345 this.file = file;
346}
347
348BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
349BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
350
351/**
352 * Utility function to find the index of a source. Returns -1 if not
353 * found.
354 */
355BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
356 var relativeSource = aSource;
357 if (this.sourceRoot != null) {
358 relativeSource = util.relative(this.sourceRoot, relativeSource);
359 }
360
361 if (this._sources.has(relativeSource)) {
362 return this._sources.indexOf(relativeSource);
363 }
364
365 // Maybe aSource is an absolute URL as returned by |sources|. In
366 // this case we can't simply undo the transform.
367 var i;
368 for (i = 0; i < this._absoluteSources.length; ++i) {
369 if (this._absoluteSources[i] == aSource) {
370 return i;
371 }
372 }
373
374 return -1;
375};
376
377/**
378 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
379 *
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
385 */
386BasicSourceMapConsumer.fromSourceMap =
387 function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
388 var smc = Object.create(BasicSourceMapConsumer.prototype);
389
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(),
394 smc.sourceRoot);
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);
399 });
400
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.
405
406 var generatedMappings = aSourceMap._mappings.toArray().slice();
407 var destGeneratedMappings = smc.__generatedMappings = [];
408 var destOriginalMappings = smc.__originalMappings = [];
409
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;
415
416 if (srcMapping.source) {
417 destMapping.source = sources.indexOf(srcMapping.source);
418 destMapping.originalLine = srcMapping.originalLine;
419 destMapping.originalColumn = srcMapping.originalColumn;
420
421 if (srcMapping.name) {
422 destMapping.name = names.indexOf(srcMapping.name);
423 }
424
425 destOriginalMappings.push(destMapping);
426 }
427
428 destGeneratedMappings.push(destMapping);
429 }
430
431 quickSort(smc.__originalMappings, util.compareByOriginalPositions);
432
433 return smc;
434 };
435
436/**
437 * The version of the source mapping spec that we are consuming.
438 */
439BasicSourceMapConsumer.prototype._version = 3;
440
441/**
442 * The list of original sources.
443 */
444Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
445 get: function () {
446 return this._absoluteSources.slice();
447 }
448});
449
450/**
451 * Provide the JIT with a nice shape / hidden class.
452 */
453function Mapping() {
454 this.generatedLine = 0;
455 this.generatedColumn = 0;
456 this.source = null;
457 this.originalLine = null;
458 this.originalColumn = null;
459 this.name = null;
460}
461
462/**
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).
466 */
467
468const compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
469function sortGenerated(array, start) {
470 let l = array.length;
471 let n = array.length - start;
472 if (n <= 1) {
473 return;
474 } else if (n == 2) {
475 let a = array[start];
476 let b = array[start + 1];
477 if (compareGenerated(a, b) > 0) {
478 array[start] = b;
479 array[start + 1] = a;
480 }
481 } else if (n < 20) {
482 for (let i = start; i < l; i++) {
483 for (let j = i; j > start; j--) {
484 let a = array[j - 1];
485 let b = array[j];
486 if (compareGenerated(a, b) <= 0) {
487 break;
488 }
489 array[j - 1] = b;
490 array[j] = a;
491 }
492 }
493 } else {
494 quickSort(array, compareGenerated, start);
495 }
496}
497BasicSourceMapConsumer.prototype._parseMappings =
498 function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
499 var generatedLine = 1;
500 var previousGeneratedColumn = 0;
501 var previousOriginalLine = 0;
502 var previousOriginalColumn = 0;
503 var previousSource = 0;
504 var previousName = 0;
505 var length = aStr.length;
506 var index = 0;
507 var cachedSegments = {};
508 var temp = {};
509 var originalMappings = [];
510 var generatedMappings = [];
511 var mapping, str, segment, end, value;
512
513 let subarrayStart = 0;
514 while (index < length) {
515 if (aStr.charAt(index) === ';') {
516 generatedLine++;
517 index++;
518 previousGeneratedColumn = 0;
519
520 sortGenerated(generatedMappings, subarrayStart);
521 subarrayStart = generatedMappings.length;
522 }
523 else if (aStr.charAt(index) === ',') {
524 index++;
525 }
526 else {
527 mapping = new Mapping();
528 mapping.generatedLine = generatedLine;
529
530 for (end = index; end < length; end++) {
531 if (this._charIsMappingSeparator(aStr, end)) {
532 break;
533 }
534 }
535 str = aStr.slice(index, end);
536
537 segment = [];
538 while (index < end) {
539 base64VLQ.decode(aStr, index, temp);
540 value = temp.value;
541 index = temp.rest;
542 segment.push(value);
543 }
544
545 if (segment.length === 2) {
546 throw new Error('Found a source, but no line and column');
547 }
548
549 if (segment.length === 3) {
550 throw new Error('Found a source and line, but no column');
551 }
552
553 // Generated column.
554 mapping.generatedColumn = previousGeneratedColumn + segment[0];
555 previousGeneratedColumn = mapping.generatedColumn;
556
557 if (segment.length > 1) {
558 // Original source.
559 mapping.source = previousSource + segment[1];
560 previousSource += segment[1];
561
562 // Original line.
563 mapping.originalLine = previousOriginalLine + segment[2];
564 previousOriginalLine = mapping.originalLine;
565 // Lines are stored 0-based
566 mapping.originalLine += 1;
567
568 // Original column.
569 mapping.originalColumn = previousOriginalColumn + segment[3];
570 previousOriginalColumn = mapping.originalColumn;
571
572 if (segment.length > 4) {
573 // Original name.
574 mapping.name = previousName + segment[4];
575 previousName += segment[4];
576 }
577 }
578
579 generatedMappings.push(mapping);
580 if (typeof mapping.originalLine === 'number') {
581 let currentSource = mapping.source;
582 while (originalMappings.length <= currentSource) {
583 originalMappings.push(null);
584 }
585 if (originalMappings[currentSource] === null) {
586 originalMappings[currentSource] = [];
587 }
588 originalMappings[currentSource].push(mapping);
589 }
590 }
591 }
592
593 sortGenerated(generatedMappings, subarrayStart);
594 this.__generatedMappings = generatedMappings;
595
596 for (var i = 0; i < originalMappings.length; i++) {
597 if (originalMappings[i] != null) {
598 quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
599 }
600 }
601 this.__originalMappings = [].concat(...originalMappings);
602 };
603
604/**
605 * Find the mapping that best matches the hypothetical "needle" mapping that
606 * we are searching for in the given "haystack" of mappings.
607 */
608BasicSourceMapConsumer.prototype._findMapping =
609 function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
610 aColumnName, aComparator, aBias) {
611 // To return the position we are searching for, we must first find the
612 // mapping for the given position and then return the opposite position it
613 // points to. Because the mappings are sorted, we can use binary search to
614 // find the best mapping.
615
616 if (aNeedle[aLineName] <= 0) {
617 throw new TypeError('Line must be greater than or equal to 1, got '
618 + aNeedle[aLineName]);
619 }
620 if (aNeedle[aColumnName] < 0) {
621 throw new TypeError('Column must be greater than or equal to 0, got '
622 + aNeedle[aColumnName]);
623 }
624
625 return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
626 };
627
628/**
629 * Compute the last column for each generated mapping. The last column is
630 * inclusive.
631 */
632BasicSourceMapConsumer.prototype.computeColumnSpans =
633 function SourceMapConsumer_computeColumnSpans() {
634 for (var index = 0; index < this._generatedMappings.length; ++index) {
635 var mapping = this._generatedMappings[index];
636
637 // Mappings do not contain a field for the last generated columnt. We
638 // can come up with an optimistic estimate, however, by assuming that
639 // mappings are contiguous (i.e. given two consecutive mappings, the
640 // first mapping ends where the second one starts).
641 if (index + 1 < this._generatedMappings.length) {
642 var nextMapping = this._generatedMappings[index + 1];
643
644 if (mapping.generatedLine === nextMapping.generatedLine) {
645 mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
646 continue;
647 }
648 }
649
650 // The last mapping for each line spans the entire line.
651 mapping.lastGeneratedColumn = Infinity;
652 }
653 };
654
655/**
656 * Returns the original source, line, and column information for the generated
657 * source's line and column positions provided. The only argument is an object
658 * with the following properties:
659 *
660 * - line: The line number in the generated source. The line number
661 * is 1-based.
662 * - column: The column number in the generated source. The column
663 * number is 0-based.
664 * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
665 * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
666 * closest element that is smaller than or greater than the one we are
667 * searching for, respectively, if the exact element cannot be found.
668 * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
669 *
670 * and an object is returned with the following properties:
671 *
672 * - source: The original source file, or null.
673 * - line: The line number in the original source, or null. The
674 * line number is 1-based.
675 * - column: The column number in the original source, or null. The
676 * column number is 0-based.
677 * - name: The original identifier, or null.
678 */
679BasicSourceMapConsumer.prototype.originalPositionFor =
680 function SourceMapConsumer_originalPositionFor(aArgs) {
681 var needle = {
682 generatedLine: util.getArg(aArgs, 'line'),
683 generatedColumn: util.getArg(aArgs, 'column')
684 };
685
686 var index = this._findMapping(
687 needle,
688 this._generatedMappings,
689 "generatedLine",
690 "generatedColumn",
691 util.compareByGeneratedPositionsDeflated,
692 util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
693 );
694
695 if (index >= 0) {
696 var mapping = this._generatedMappings[index];
697
698 if (mapping.generatedLine === needle.generatedLine) {
699 var source = util.getArg(mapping, 'source', null);
700 if (source !== null) {
701 source = this._sources.at(source);
702 source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
703 }
704 var name = util.getArg(mapping, 'name', null);
705 if (name !== null) {
706 name = this._names.at(name);
707 }
708 return {
709 source: source,
710 line: util.getArg(mapping, 'originalLine', null),
711 column: util.getArg(mapping, 'originalColumn', null),
712 name: name
713 };
714 }
715 }
716
717 return {
718 source: null,
719 line: null,
720 column: null,
721 name: null
722 };
723 };
724
725/**
726 * Return true if we have the source content for every source in the source
727 * map, false otherwise.
728 */
729BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
730 function BasicSourceMapConsumer_hasContentsOfAllSources() {
731 if (!this.sourcesContent) {
732 return false;
733 }
734 return this.sourcesContent.length >= this._sources.size() &&
735 !this.sourcesContent.some(function (sc) { return sc == null; });
736 };
737
738/**
739 * Returns the original source content. The only argument is the url of the
740 * original source file. Returns null if no original source content is
741 * available.
742 */
743BasicSourceMapConsumer.prototype.sourceContentFor =
744 function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
745 if (!this.sourcesContent) {
746 return null;
747 }
748
749 var index = this._findSourceIndex(aSource);
750 if (index >= 0) {
751 return this.sourcesContent[index];
752 }
753
754 var relativeSource = aSource;
755 if (this.sourceRoot != null) {
756 relativeSource = util.relative(this.sourceRoot, relativeSource);
757 }
758
759 var url;
760 if (this.sourceRoot != null
761 && (url = util.urlParse(this.sourceRoot))) {
762 // XXX: file:// URIs and absolute paths lead to unexpected behavior for
763 // many users. We can help them out when they expect file:// URIs to
764 // behave like it would if they were running a local HTTP server. See
765 // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
766 var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
767 if (url.scheme == "file"
768 && this._sources.has(fileUriAbsPath)) {
769 return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
770 }
771
772 if ((!url.path || url.path == "/")
773 && this._sources.has("/" + relativeSource)) {
774 return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
775 }
776 }
777
778 // This function is used recursively from
779 // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
780 // don't want to throw if we can't find the source - we just want to
781 // return null, so we provide a flag to exit gracefully.
782 if (nullOnMissing) {
783 return null;
784 }
785 else {
786 throw new Error('"' + relativeSource + '" is not in the SourceMap.');
787 }
788 };
789
790/**
791 * Returns the generated line and column information for the original source,
792 * line, and column positions provided. The only argument is an object with
793 * the following properties:
794 *
795 * - source: The filename of the original source.
796 * - line: The line number in the original source. The line number
797 * is 1-based.
798 * - column: The column number in the original source. The column
799 * number is 0-based.
800 * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
801 * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
802 * closest element that is smaller than or greater than the one we are
803 * searching for, respectively, if the exact element cannot be found.
804 * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
805 *
806 * and an object is returned with the following properties:
807 *
808 * - line: The line number in the generated source, or null. The
809 * line number is 1-based.
810 * - column: The column number in the generated source, or null.
811 * The column number is 0-based.
812 */
813BasicSourceMapConsumer.prototype.generatedPositionFor =
814 function SourceMapConsumer_generatedPositionFor(aArgs) {
815 var source = util.getArg(aArgs, 'source');
816 source = this._findSourceIndex(source);
817 if (source < 0) {
818 return {
819 line: null,
820 column: null,
821 lastColumn: null
822 };
823 }
824
825 var needle = {
826 source: source,
827 originalLine: util.getArg(aArgs, 'line'),
828 originalColumn: util.getArg(aArgs, 'column')
829 };
830
831 var index = this._findMapping(
832 needle,
833 this._originalMappings,
834 "originalLine",
835 "originalColumn",
836 util.compareByOriginalPositions,
837 util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
838 );
839
840 if (index >= 0) {
841 var mapping = this._originalMappings[index];
842
843 if (mapping.source === needle.source) {
844 return {
845 line: util.getArg(mapping, 'generatedLine', null),
846 column: util.getArg(mapping, 'generatedColumn', null),
847 lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
848 };
849 }
850 }
851
852 return {
853 line: null,
854 column: null,
855 lastColumn: null
856 };
857 };
858
859exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
860
861/**
862 * An IndexedSourceMapConsumer instance represents a parsed source map which
863 * we can query for information. It differs from BasicSourceMapConsumer in
864 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
865 * input.
866 *
867 * The first parameter is a raw source map (either as a JSON string, or already
868 * parsed to an object). According to the spec for indexed source maps, they
869 * have the following attributes:
870 *
871 * - version: Which version of the source map spec this map is following.
872 * - file: Optional. The generated file this source map is associated with.
873 * - sections: A list of section definitions.
874 *
875 * Each value under the "sections" field has two fields:
876 * - offset: The offset into the original specified at which this section
877 * begins to apply, defined as an object with a "line" and "column"
878 * field.
879 * - map: A source map definition. This source map could also be indexed,
880 * but doesn't have to be.
881 *
882 * Instead of the "map" field, it's also possible to have a "url" field
883 * specifying a URL to retrieve a source map from, but that's currently
884 * unsupported.
885 *
886 * Here's an example source map, taken from the source map spec[0], but
887 * modified to omit a section which uses the "url" field.
888 *
889 * {
890 * version : 3,
891 * file: "app.js",
892 * sections: [{
893 * offset: {line:100, column:10},
894 * map: {
895 * version : 3,
896 * file: "section.js",
897 * sources: ["foo.js", "bar.js"],
898 * names: ["src", "maps", "are", "fun"],
899 * mappings: "AAAA,E;;ABCDE;"
900 * }
901 * }],
902 * }
903 *
904 * The second parameter, if given, is a string whose value is the URL
905 * at which the source map was found. This URL is used to compute the
906 * sources array.
907 *
908 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
909 */
910function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
911 var sourceMap = aSourceMap;
912 if (typeof aSourceMap === 'string') {
913 sourceMap = util.parseSourceMapInput(aSourceMap);
914 }
915
916 var version = util.getArg(sourceMap, 'version');
917 var sections = util.getArg(sourceMap, 'sections');
918
919 if (version != this._version) {
920 throw new Error('Unsupported version: ' + version);
921 }
922
923 this._sources = new ArraySet();
924 this._names = new ArraySet();
925
926 var lastOffset = {
927 line: -1,
928 column: 0
929 };
930 this._sections = sections.map(function (s) {
931 if (s.url) {
932 // The url field will require support for asynchronicity.
933 // See https://github.com/mozilla/source-map/issues/16
934 throw new Error('Support for url field in sections not implemented.');
935 }
936 var offset = util.getArg(s, 'offset');
937 var offsetLine = util.getArg(offset, 'line');
938 var offsetColumn = util.getArg(offset, 'column');
939
940 if (offsetLine < lastOffset.line ||
941 (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
942 throw new Error('Section offsets must be ordered and non-overlapping.');
943 }
944 lastOffset = offset;
945
946 return {
947 generatedOffset: {
948 // The offset fields are 0-based, but we use 1-based indices when
949 // encoding/decoding from VLQ.
950 generatedLine: offsetLine + 1,
951 generatedColumn: offsetColumn + 1
952 },
953 consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
954 }
955 });
956}
957
958IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
959IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
960
961/**
962 * The version of the source mapping spec that we are consuming.
963 */
964IndexedSourceMapConsumer.prototype._version = 3;
965
966/**
967 * The list of original sources.
968 */
969Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
970 get: function () {
971 var sources = [];
972 for (var i = 0; i < this._sections.length; i++) {
973 for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
974 sources.push(this._sections[i].consumer.sources[j]);
975 }
976 }
977 return sources;
978 }
979});
980
981/**
982 * Returns the original source, line, and column information for the generated
983 * source's line and column positions provided. The only argument is an object
984 * with the following properties:
985 *
986 * - line: The line number in the generated source. The line number
987 * is 1-based.
988 * - column: The column number in the generated source. The column
989 * number is 0-based.
990 *
991 * and an object is returned with the following properties:
992 *
993 * - source: The original source file, or null.
994 * - line: The line number in the original source, or null. The
995 * line number is 1-based.
996 * - column: The column number in the original source, or null. The
997 * column number is 0-based.
998 * - name: The original identifier, or null.
999 */
1000IndexedSourceMapConsumer.prototype.originalPositionFor =
1001 function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
1002 var needle = {
1003 generatedLine: util.getArg(aArgs, 'line'),
1004 generatedColumn: util.getArg(aArgs, 'column')
1005 };
1006
1007 // Find the section containing the generated position we're trying to map
1008 // to an original position.
1009 var sectionIndex = binarySearch.search(needle, this._sections,
1010 function(needle, section) {
1011 var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
1012 if (cmp) {
1013 return cmp;
1014 }
1015
1016 return (needle.generatedColumn -
1017 section.generatedOffset.generatedColumn);
1018 });
1019 var section = this._sections[sectionIndex];
1020
1021 if (!section) {
1022 return {
1023 source: null,
1024 line: null,
1025 column: null,
1026 name: null
1027 };
1028 }
1029
1030 return section.consumer.originalPositionFor({
1031 line: needle.generatedLine -
1032 (section.generatedOffset.generatedLine - 1),
1033 column: needle.generatedColumn -
1034 (section.generatedOffset.generatedLine === needle.generatedLine
1035 ? section.generatedOffset.generatedColumn - 1
1036 : 0),
1037 bias: aArgs.bias
1038 });
1039 };
1040
1041/**
1042 * Return true if we have the source content for every source in the source
1043 * map, false otherwise.
1044 */
1045IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
1046 function IndexedSourceMapConsumer_hasContentsOfAllSources() {
1047 return this._sections.every(function (s) {
1048 return s.consumer.hasContentsOfAllSources();
1049 });
1050 };
1051
1052/**
1053 * Returns the original source content. The only argument is the url of the
1054 * original source file. Returns null if no original source content is
1055 * available.
1056 */
1057IndexedSourceMapConsumer.prototype.sourceContentFor =
1058 function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
1059 for (var i = 0; i < this._sections.length; i++) {
1060 var section = this._sections[i];
1061
1062 var content = section.consumer.sourceContentFor(aSource, true);
1063 if (content) {
1064 return content;
1065 }
1066 }
1067 if (nullOnMissing) {
1068 return null;
1069 }
1070 else {
1071 throw new Error('"' + aSource + '" is not in the SourceMap.');
1072 }
1073 };
1074
1075/**
1076 * Returns the generated line and column information for the original source,
1077 * line, and column positions provided. The only argument is an object with
1078 * the following properties:
1079 *
1080 * - source: The filename of the original source.
1081 * - line: The line number in the original source. The line number
1082 * is 1-based.
1083 * - column: The column number in the original source. The column
1084 * number is 0-based.
1085 *
1086 * and an object is returned with the following properties:
1087 *
1088 * - line: The line number in the generated source, or null. The
1089 * line number is 1-based.
1090 * - column: The column number in the generated source, or null.
1091 * The column number is 0-based.
1092 */
1093IndexedSourceMapConsumer.prototype.generatedPositionFor =
1094 function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
1095 for (var i = 0; i < this._sections.length; i++) {
1096 var section = this._sections[i];
1097
1098 // Only consider this section if the requested source is in the list of
1099 // sources of the consumer.
1100 if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
1101 continue;
1102 }
1103 var generatedPosition = section.consumer.generatedPositionFor(aArgs);
1104 if (generatedPosition) {
1105 var ret = {
1106 line: generatedPosition.line +
1107 (section.generatedOffset.generatedLine - 1),
1108 column: generatedPosition.column +
1109 (section.generatedOffset.generatedLine === generatedPosition.line
1110 ? section.generatedOffset.generatedColumn - 1
1111 : 0)
1112 };
1113 return ret;
1114 }
1115 }
1116
1117 return {
1118 line: null,
1119 column: null
1120 };
1121 };
1122
1123/**
1124 * Parse the mappings in a string in to a data structure which we can easily
1125 * query (the ordered arrays in the `this.__generatedMappings` and
1126 * `this.__originalMappings` properties).
1127 */
1128IndexedSourceMapConsumer.prototype._parseMappings =
1129 function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
1130 this.__generatedMappings = [];
1131 this.__originalMappings = [];
1132 for (var i = 0; i < this._sections.length; i++) {
1133 var section = this._sections[i];
1134 var sectionMappings = section.consumer._generatedMappings;
1135 for (var j = 0; j < sectionMappings.length; j++) {
1136 var mapping = sectionMappings[j];
1137
1138 var source = section.consumer._sources.at(mapping.source);
1139 source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
1140 this._sources.add(source);
1141 source = this._sources.indexOf(source);
1142
1143 var name = null;
1144 if (mapping.name) {
1145 name = section.consumer._names.at(mapping.name);
1146 this._names.add(name);
1147 name = this._names.indexOf(name);
1148 }
1149
1150 // The mappings coming from the consumer for the section have
1151 // generated positions relative to the start of the section, so we
1152 // need to offset them to be relative to the start of the concatenated
1153 // generated file.
1154 var adjustedMapping = {
1155 source: source,
1156 generatedLine: mapping.generatedLine +
1157 (section.generatedOffset.generatedLine - 1),
1158 generatedColumn: mapping.generatedColumn +
1159 (section.generatedOffset.generatedLine === mapping.generatedLine
1160 ? section.generatedOffset.generatedColumn - 1
1161 : 0),
1162 originalLine: mapping.originalLine,
1163 originalColumn: mapping.originalColumn,
1164 name: name
1165 };
1166
1167 this.__generatedMappings.push(adjustedMapping);
1168 if (typeof adjustedMapping.originalLine === 'number') {
1169 this.__originalMappings.push(adjustedMapping);
1170 }
1171 }
1172 }
1173
1174 quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
1175 quickSort(this.__originalMappings, util.compareByOriginalPositions);
1176 };
1177
1178exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
Note: See TracBrowser for help on using the repository browser.