265 lines
12 KiB
JavaScript
265 lines
12 KiB
JavaScript
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@jridgewell/trace-mapping'), require('sourcemap-codec')) :
|
|
typeof define === 'function' && define.amd ? define(['@jridgewell/trace-mapping', 'sourcemap-codec'], factory) :
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.remapping = factory(global.traceMapping, global.sourcemapCodec));
|
|
})(this, (function (TraceMap, sourcemapCodec) { 'use strict';
|
|
|
|
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
|
|
|
|
var TraceMap__default = /*#__PURE__*/_interopDefaultLegacy(TraceMap);
|
|
|
|
/**
|
|
* A "leaf" node in the sourcemap tree, representing an original, unmodified
|
|
* source file. Recursive segment tracing ends at the `OriginalSource`.
|
|
*/
|
|
class OriginalSource {
|
|
constructor(filename, content) {
|
|
this.filename = filename;
|
|
this.content = content;
|
|
}
|
|
/**
|
|
* Tracing a `SourceMapSegment` ends when we get to an `OriginalSource`,
|
|
* meaning this line/column location originated from this source file.
|
|
*/
|
|
originalPositionFor(line, column, name) {
|
|
return { column, line, name, source: this };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* FastStringArray acts like a `Set` (allowing only one occurrence of a string
|
|
* `key`), but provides the index of the `key` in the backing array.
|
|
*
|
|
* This is designed to allow synchronizing a second array with the contents of
|
|
* the backing array, like how `sourcesContent[i]` is the source content
|
|
* associated with `source[i]`, and there are never duplicates.
|
|
*/
|
|
class FastStringArray {
|
|
constructor() {
|
|
this.indexes = Object.create(null);
|
|
this.array = [];
|
|
}
|
|
/**
|
|
* Puts `key` into the backing array, if it is not already present. Returns
|
|
* the index of the `key` in the backing array.
|
|
*/
|
|
put(key) {
|
|
const { array, indexes } = this;
|
|
// The key may or may not be present. If it is present, it's a number.
|
|
let index = indexes[key];
|
|
// If it's not yet present, we need to insert it and track the index in the
|
|
// indexes.
|
|
if (index === undefined) {
|
|
index = indexes[key] = array.length;
|
|
array.push(key);
|
|
}
|
|
return index;
|
|
}
|
|
}
|
|
|
|
const INVALID_MAPPING = undefined;
|
|
const SOURCELESS_MAPPING = null;
|
|
/**
|
|
* SourceMapTree represents a single sourcemap, with the ability to trace
|
|
* mappings into its child nodes (which may themselves be SourceMapTrees).
|
|
*/
|
|
class SourceMapTree {
|
|
constructor(map, sources) {
|
|
this.map = map;
|
|
this.sources = sources;
|
|
}
|
|
/**
|
|
* traceMappings is only called on the root level SourceMapTree, and begins the process of
|
|
* resolving each mapping in terms of the original source files.
|
|
*/
|
|
traceMappings() {
|
|
const names = new FastStringArray();
|
|
const sources = new FastStringArray();
|
|
const sourcesContent = [];
|
|
const { sources: rootSources, map } = this;
|
|
const rootNames = map.names;
|
|
let lastGenLine = -1;
|
|
let lastSourcesIndex = -1;
|
|
let lastSourceLine = -1;
|
|
let lastSourceColumn = -1;
|
|
const mappings = map.map(trace);
|
|
if (mappings.length > lastGenLine + 1) {
|
|
mappings.length = lastGenLine + 1;
|
|
}
|
|
// TODO: Make all sources relative to the sourceRoot.
|
|
return Object.assign({}, this.map, {
|
|
mappings,
|
|
names: names.array,
|
|
sources: sources.array,
|
|
sourcesContent,
|
|
});
|
|
function trace(genLine, genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
|
|
let traced = SOURCELESS_MAPPING;
|
|
// 1-length segments only move the current generated column, there's no source information
|
|
// to gather from it.
|
|
if (sourcesIndex !== -1) {
|
|
const source = rootSources[sourcesIndex];
|
|
traced = source.originalPositionFor(sourceLine, sourceColumn, namesIndex === -1 ? '' : rootNames[namesIndex]);
|
|
// If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
|
|
// respective segment into an original source.
|
|
if (traced === INVALID_MAPPING)
|
|
return null;
|
|
}
|
|
if (traced === SOURCELESS_MAPPING) {
|
|
if (lastSourcesIndex === -1) {
|
|
// This is a consecutive source-less segment, which doesn't carry any new information.
|
|
return null;
|
|
}
|
|
lastSourcesIndex = lastSourceLine = lastSourceColumn = -1;
|
|
return [genColumn];
|
|
}
|
|
// So we traced a segment down into its original source file. Now push a
|
|
// new segment pointing to this location.
|
|
const { column, line, name } = traced;
|
|
const { content, filename } = traced.source;
|
|
// Store the source location, and ensure we keep sourcesContent up to
|
|
// date with the sources array.
|
|
const sIndex = sources.put(filename);
|
|
sourcesContent[sIndex] = content;
|
|
if (lastGenLine === genLine &&
|
|
lastSourcesIndex === sIndex &&
|
|
lastSourceLine === line &&
|
|
lastSourceColumn === column) {
|
|
// This is a duplicate mapping pointing at the exact same starting point in the source
|
|
// file. It doesn't carry any new information, and only bloats the sourcemap.
|
|
return null;
|
|
}
|
|
lastGenLine = genLine;
|
|
lastSourcesIndex = sIndex;
|
|
lastSourceLine = line;
|
|
lastSourceColumn = column;
|
|
// This looks like unnecessary duplication, but it noticeably increases performance. If we
|
|
// were to push the nameIndex onto length-4 array, v8 would internally allocate 22 slots!
|
|
// That's 68 wasted bytes! Array literals have the same capacity as their length, saving
|
|
// memory.
|
|
if (name)
|
|
return [genColumn, sIndex, line, column, names.put(name)];
|
|
return [genColumn, sIndex, line, column];
|
|
}
|
|
}
|
|
/**
|
|
* traceSegment is only called on children SourceMapTrees. It recurses down
|
|
* into its own child SourceMapTrees, until we find the original source map.
|
|
*/
|
|
originalPositionFor(line, column, name) {
|
|
const segment = this.map.traceSegment(line, column);
|
|
// If we couldn't find a segment, then this doesn't exist in the sourcemap.
|
|
if (segment == null)
|
|
return INVALID_MAPPING;
|
|
// 1-length segments only move the current generated column, there's no source information
|
|
// to gather from it.
|
|
if (segment.length === 1)
|
|
return SOURCELESS_MAPPING;
|
|
const source = this.sources[segment[1]];
|
|
return source.originalPositionFor(segment[2], segment[3], segment.length === 5 ? this.map.names[segment[4]] : name);
|
|
}
|
|
}
|
|
|
|
function asArray(value) {
|
|
if (Array.isArray(value))
|
|
return value;
|
|
return [value];
|
|
}
|
|
/**
|
|
* Recursively builds a tree structure out of sourcemap files, with each node
|
|
* being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
|
|
* `OriginalSource`s and `SourceMapTree`s.
|
|
*
|
|
* Every sourcemap is composed of a collection of source files and mappings
|
|
* into locations of those source files. When we generate a `SourceMapTree` for
|
|
* the sourcemap, we attempt to load each source file's own sourcemap. If it
|
|
* does not have an associated sourcemap, it is considered an original,
|
|
* unmodified source file.
|
|
*/
|
|
function buildSourceMapTree(input, loader) {
|
|
const maps = asArray(input).map((m) => new TraceMap__default["default"](m));
|
|
const map = maps.pop();
|
|
for (let i = 0; i < maps.length; i++) {
|
|
if (maps[i].sources.length > 1) {
|
|
throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
|
|
'Did you specify these with the most recent transformation maps first?');
|
|
}
|
|
}
|
|
let tree = build(map, loader);
|
|
for (let i = maps.length - 1; i >= 0; i--) {
|
|
tree = new SourceMapTree(maps[i], [tree]);
|
|
}
|
|
return tree;
|
|
}
|
|
function build(map, loader) {
|
|
const { resolvedSources, sourcesContent } = map;
|
|
const children = resolvedSources.map((sourceFile, i) => {
|
|
const source = sourceFile || '';
|
|
// Use the provided loader callback to retrieve the file's sourcemap.
|
|
// TODO: We should eventually support async loading of sourcemap files.
|
|
const sourceMap = loader(source);
|
|
// If there is no sourcemap, then it is an unmodified source file.
|
|
if (!sourceMap) {
|
|
// The source file's actual contents must be included in the sourcemap
|
|
// (done when generating the sourcemap) for it to be included as a
|
|
// sourceContent in the output sourcemap.
|
|
const sourceContent = sourcesContent ? sourcesContent[i] : null;
|
|
return new OriginalSource(source, sourceContent);
|
|
}
|
|
// Else, it's a real sourcemap, and we need to recurse into it to load its
|
|
// source files.
|
|
return build(new TraceMap__default["default"](sourceMap, source), loader);
|
|
});
|
|
return new SourceMapTree(map, children);
|
|
}
|
|
|
|
/**
|
|
* A SourceMap v3 compatible sourcemap, which only includes fields that were
|
|
* provided to it.
|
|
*/
|
|
class SourceMap {
|
|
constructor(map, options) {
|
|
this.version = 3; // SourceMap spec says this should be first.
|
|
if ('file' in map)
|
|
this.file = map.file;
|
|
this.mappings = options.decodedMappings ? map.mappings : sourcemapCodec.encode(map.mappings);
|
|
this.names = map.names;
|
|
// TODO: We first need to make all source URIs relative to the sourceRoot
|
|
// before we can support a sourceRoot.
|
|
// if ('sourceRoot' in map) this.sourceRoot = map.sourceRoot;
|
|
this.sources = map.sources;
|
|
if (!options.excludeContent && 'sourcesContent' in map) {
|
|
this.sourcesContent = map.sourcesContent;
|
|
}
|
|
}
|
|
toString() {
|
|
return JSON.stringify(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Traces through all the mappings in the root sourcemap, through the sources
|
|
* (and their sourcemaps), all the way back to the original source location.
|
|
*
|
|
* `loader` will be called every time we encounter a source file. If it returns
|
|
* a sourcemap, we will recurse into that sourcemap to continue the trace. If
|
|
* it returns a falsey value, that source file is treated as an original,
|
|
* unmodified source file.
|
|
*
|
|
* Pass `excludeContent` to exclude any self-containing source file content
|
|
* from the output sourcemap.
|
|
*
|
|
* Pass `decodedMappings` to receive a SourceMap with decoded (instead of
|
|
* VLQ encoded) mappings.
|
|
*/
|
|
function remapping(input, loader, options) {
|
|
const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
|
|
const graph = buildSourceMapTree(input, loader);
|
|
return new SourceMap(graph.traceMappings(), opts);
|
|
}
|
|
|
|
return remapping;
|
|
|
|
}));
|
|
//# sourceMappingURL=remapping.umd.js.map
|