| /* -*- Mode: js; js-indent-level: 2; -*- */ |
| /* |
| * Copyright 2011 Mozilla Foundation and contributors |
| * Licensed under the New BSD license. See LICENSE or: |
| * http://opensource.org/licenses/BSD-3-Clause |
| */ |
| |
| const base64VLQ = require("./base64-vlq"); |
| const util = require("./util"); |
| const ArraySet = require("./array-set").ArraySet; |
| const MappingList = require("./mapping-list").MappingList; |
| |
| /** |
| * An instance of the SourceMapGenerator represents a source map which is |
| * being built incrementally. You may pass an object with the following |
| * properties: |
| * |
| * - file: The filename of the generated source. |
| * - sourceRoot: A root for all relative URLs in this source map. |
| */ |
| class SourceMapGenerator { |
| constructor(aArgs) { |
| if (!aArgs) { |
| aArgs = {}; |
| } |
| this._file = util.getArg(aArgs, "file", null); |
| this._sourceRoot = util.getArg(aArgs, "sourceRoot", null); |
| this._skipValidation = util.getArg(aArgs, "skipValidation", false); |
| this._sources = new ArraySet(); |
| this._names = new ArraySet(); |
| this._mappings = new MappingList(); |
| this._sourcesContents = null; |
| } |
| |
| /** |
| * Creates a new SourceMapGenerator based on a SourceMapConsumer |
| * |
| * @param aSourceMapConsumer The SourceMap. |
| */ |
| static fromSourceMap(aSourceMapConsumer) { |
| const sourceRoot = aSourceMapConsumer.sourceRoot; |
| const generator = new SourceMapGenerator({ |
| file: aSourceMapConsumer.file, |
| sourceRoot |
| }); |
| aSourceMapConsumer.eachMapping(function(mapping) { |
| const newMapping = { |
| generated: { |
| line: mapping.generatedLine, |
| column: mapping.generatedColumn |
| } |
| }; |
| |
| if (mapping.source != null) { |
| newMapping.source = mapping.source; |
| if (sourceRoot != null) { |
| newMapping.source = util.relative(sourceRoot, newMapping.source); |
| } |
| |
| newMapping.original = { |
| line: mapping.originalLine, |
| column: mapping.originalColumn |
| }; |
| |
| if (mapping.name != null) { |
| newMapping.name = mapping.name; |
| } |
| } |
| |
| generator.addMapping(newMapping); |
| }); |
| aSourceMapConsumer.sources.forEach(function(sourceFile) { |
| let sourceRelative = sourceFile; |
| if (sourceRoot !== null) { |
| sourceRelative = util.relative(sourceRoot, sourceFile); |
| } |
| |
| if (!generator._sources.has(sourceRelative)) { |
| generator._sources.add(sourceRelative); |
| } |
| |
| const content = aSourceMapConsumer.sourceContentFor(sourceFile); |
| if (content != null) { |
| generator.setSourceContent(sourceFile, content); |
| } |
| }); |
| return generator; |
| } |
| |
| /** |
| * Add a single mapping from original source line and column to the generated |
| * source's line and column for this source map being created. The mapping |
| * object should have the following properties: |
| * |
| * - generated: An object with the generated line and column positions. |
| * - original: An object with the original line and column positions. |
| * - source: The original source file (relative to the sourceRoot). |
| * - name: An optional original token name for this mapping. |
| */ |
| addMapping(aArgs) { |
| const generated = util.getArg(aArgs, "generated"); |
| const original = util.getArg(aArgs, "original", null); |
| let source = util.getArg(aArgs, "source", null); |
| let name = util.getArg(aArgs, "name", null); |
| |
| if (!this._skipValidation) { |
| this._validateMapping(generated, original, source, name); |
| } |
| |
| if (source != null) { |
| source = String(source); |
| if (!this._sources.has(source)) { |
| this._sources.add(source); |
| } |
| } |
| |
| if (name != null) { |
| name = String(name); |
| if (!this._names.has(name)) { |
| this._names.add(name); |
| } |
| } |
| |
| this._mappings.add({ |
| generatedLine: generated.line, |
| generatedColumn: generated.column, |
| originalLine: original != null && original.line, |
| originalColumn: original != null && original.column, |
| source, |
| name |
| }); |
| } |
| |
| /** |
| * Set the source content for a source file. |
| */ |
| setSourceContent(aSourceFile, aSourceContent) { |
| let source = aSourceFile; |
| if (this._sourceRoot != null) { |
| source = util.relative(this._sourceRoot, source); |
| } |
| |
| if (aSourceContent != null) { |
| // Add the source content to the _sourcesContents map. |
| // Create a new _sourcesContents map if the property is null. |
| if (!this._sourcesContents) { |
| this._sourcesContents = Object.create(null); |
| } |
| this._sourcesContents[util.toSetString(source)] = aSourceContent; |
| } else if (this._sourcesContents) { |
| // Remove the source file from the _sourcesContents map. |
| // If the _sourcesContents map is empty, set the property to null. |
| delete this._sourcesContents[util.toSetString(source)]; |
| if (Object.keys(this._sourcesContents).length === 0) { |
| this._sourcesContents = null; |
| } |
| } |
| } |
| |
| /** |
| * Applies the mappings of a sub-source-map for a specific source file to the |
| * source map being generated. Each mapping to the supplied source file is |
| * rewritten using the supplied source map. Note: The resolution for the |
| * resulting mappings is the minimium of this map and the supplied map. |
| * |
| * @param aSourceMapConsumer The source map to be applied. |
| * @param aSourceFile Optional. The filename of the source file. |
| * If omitted, SourceMapConsumer's file property will be used. |
| * @param aSourceMapPath Optional. The dirname of the path to the source map |
| * to be applied. If relative, it is relative to the SourceMapConsumer. |
| * This parameter is needed when the two source maps aren't in the same |
| * directory, and the source map to be applied contains relative source |
| * paths. If so, those relative source paths need to be rewritten |
| * relative to the SourceMapGenerator. |
| */ |
| applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) { |
| let sourceFile = aSourceFile; |
| // If aSourceFile is omitted, we will use the file property of the SourceMap |
| if (aSourceFile == null) { |
| if (aSourceMapConsumer.file == null) { |
| throw new Error( |
| "SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " + |
| 'or the source map\'s "file" property. Both were omitted.' |
| ); |
| } |
| sourceFile = aSourceMapConsumer.file; |
| } |
| const sourceRoot = this._sourceRoot; |
| // Make "sourceFile" relative if an absolute Url is passed. |
| if (sourceRoot != null) { |
| sourceFile = util.relative(sourceRoot, sourceFile); |
| } |
| // Applying the SourceMap can add and remove items from the sources and |
| // the names array. |
| const newSources = this._mappings.toArray().length > 0 |
| ? new ArraySet() |
| : this._sources; |
| const newNames = new ArraySet(); |
| |
| // Find mappings for the "sourceFile" |
| this._mappings.unsortedForEach(function(mapping) { |
| if (mapping.source === sourceFile && mapping.originalLine != null) { |
| // Check if it can be mapped by the source map, then update the mapping. |
| const original = aSourceMapConsumer.originalPositionFor({ |
| line: mapping.originalLine, |
| column: mapping.originalColumn |
| }); |
| if (original.source != null) { |
| // Copy mapping |
| mapping.source = original.source; |
| if (aSourceMapPath != null) { |
| mapping.source = util.join(aSourceMapPath, mapping.source); |
| } |
| if (sourceRoot != null) { |
| mapping.source = util.relative(sourceRoot, mapping.source); |
| } |
| mapping.originalLine = original.line; |
| mapping.originalColumn = original.column; |
| if (original.name != null) { |
| mapping.name = original.name; |
| } |
| } |
| } |
| |
| const source = mapping.source; |
| if (source != null && !newSources.has(source)) { |
| newSources.add(source); |
| } |
| |
| const name = mapping.name; |
| if (name != null && !newNames.has(name)) { |
| newNames.add(name); |
| } |
| |
| }, this); |
| this._sources = newSources; |
| this._names = newNames; |
| |
| // Copy sourcesContents of applied map. |
| aSourceMapConsumer.sources.forEach(function(srcFile) { |
| const content = aSourceMapConsumer.sourceContentFor(srcFile); |
| if (content != null) { |
| if (aSourceMapPath != null) { |
| srcFile = util.join(aSourceMapPath, srcFile); |
| } |
| if (sourceRoot != null) { |
| srcFile = util.relative(sourceRoot, srcFile); |
| } |
| this.setSourceContent(srcFile, content); |
| } |
| }, this); |
| } |
| |
| /** |
| * A mapping can have one of the three levels of data: |
| * |
| * 1. Just the generated position. |
| * 2. The Generated position, original position, and original source. |
| * 3. Generated and original position, original source, as well as a name |
| * token. |
| * |
| * To maintain consistency, we validate that any new mapping being added falls |
| * in to one of these categories. |
| */ |
| _validateMapping(aGenerated, aOriginal, aSource, aName) { |
| // When aOriginal is truthy but has empty values for .line and .column, |
| // it is most likely a programmer error. In this case we throw a very |
| // specific error message to try to guide them the right way. |
| // For example: https://github.com/Polymer/polymer-bundler/pull/519 |
| if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") { |
| throw new Error( |
| "original.line and original.column are not numbers -- you probably meant to omit " + |
| "the original mapping entirely and only map the generated position. If so, pass " + |
| "null for the original mapping instead of an object with empty or null values." |
| ); |
| } |
| |
| if (aGenerated && "line" in aGenerated && "column" in aGenerated |
| && aGenerated.line > 0 && aGenerated.column >= 0 |
| && !aOriginal && !aSource && !aName) { |
| // Case 1. |
| |
| } else if (aGenerated && "line" in aGenerated && "column" in aGenerated |
| && aOriginal && "line" in aOriginal && "column" in aOriginal |
| && aGenerated.line > 0 && aGenerated.column >= 0 |
| && aOriginal.line > 0 && aOriginal.column >= 0 |
| && aSource) { |
| // Cases 2 and 3. |
| |
| } else { |
| throw new Error("Invalid mapping: " + JSON.stringify({ |
| generated: aGenerated, |
| source: aSource, |
| original: aOriginal, |
| name: aName |
| })); |
| } |
| } |
| |
| /** |
| * Serialize the accumulated mappings in to the stream of base 64 VLQs |
| * specified by the source map format. |
| */ |
| _serializeMappings() { |
| let previousGeneratedColumn = 0; |
| let previousGeneratedLine = 1; |
| let previousOriginalColumn = 0; |
| let previousOriginalLine = 0; |
| let previousName = 0; |
| let previousSource = 0; |
| let result = ""; |
| let next; |
| let mapping; |
| let nameIdx; |
| let sourceIdx; |
| |
| const mappings = this._mappings.toArray(); |
| for (let i = 0, len = mappings.length; i < len; i++) { |
| mapping = mappings[i]; |
| next = ""; |
| |
| if (mapping.generatedLine !== previousGeneratedLine) { |
| previousGeneratedColumn = 0; |
| while (mapping.generatedLine !== previousGeneratedLine) { |
| next += ";"; |
| previousGeneratedLine++; |
| } |
| } else if (i > 0) { |
| if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) { |
| continue; |
| } |
| next += ","; |
| } |
| |
| next += base64VLQ.encode(mapping.generatedColumn |
| - previousGeneratedColumn); |
| previousGeneratedColumn = mapping.generatedColumn; |
| |
| if (mapping.source != null) { |
| sourceIdx = this._sources.indexOf(mapping.source); |
| next += base64VLQ.encode(sourceIdx - previousSource); |
| previousSource = sourceIdx; |
| |
| // lines are stored 0-based in SourceMap spec version 3 |
| next += base64VLQ.encode(mapping.originalLine - 1 |
| - previousOriginalLine); |
| previousOriginalLine = mapping.originalLine - 1; |
| |
| next += base64VLQ.encode(mapping.originalColumn |
| - previousOriginalColumn); |
| previousOriginalColumn = mapping.originalColumn; |
| |
| if (mapping.name != null) { |
| nameIdx = this._names.indexOf(mapping.name); |
| next += base64VLQ.encode(nameIdx - previousName); |
| previousName = nameIdx; |
| } |
| } |
| |
| result += next; |
| } |
| |
| return result; |
| } |
| |
| _generateSourcesContent(aSources, aSourceRoot) { |
| return aSources.map(function(source) { |
| if (!this._sourcesContents) { |
| return null; |
| } |
| if (aSourceRoot != null) { |
| source = util.relative(aSourceRoot, source); |
| } |
| const key = util.toSetString(source); |
| return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) |
| ? this._sourcesContents[key] |
| : null; |
| }, this); |
| } |
| |
| /** |
| * Externalize the source map. |
| */ |
| toJSON() { |
| const map = { |
| version: this._version, |
| sources: this._sources.toArray(), |
| names: this._names.toArray(), |
| mappings: this._serializeMappings() |
| }; |
| if (this._file != null) { |
| map.file = this._file; |
| } |
| if (this._sourceRoot != null) { |
| map.sourceRoot = this._sourceRoot; |
| } |
| if (this._sourcesContents) { |
| map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot); |
| } |
| |
| return map; |
| } |
| |
| /** |
| * Render the source map being generated to a string. |
| */ |
| toString() { |
| return JSON.stringify(this.toJSON()); |
| } |
| } |
| |
| SourceMapGenerator.prototype._version = 3; |
| exports.SourceMapGenerator = SourceMapGenerator; |
