"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.default = mergeSourceMap;
|
|
function _sourceMap() {
|
const data = require("source-map");
|
|
_sourceMap = function () {
|
return data;
|
};
|
|
return data;
|
}
|
|
function mergeSourceMap(inputMap, map) {
|
const input = buildMappingData(inputMap);
|
const output = buildMappingData(map);
|
const mergedGenerator = new (_sourceMap().SourceMapGenerator)();
|
|
for (const {
|
source
|
} of input.sources) {
|
if (typeof source.content === "string") {
|
mergedGenerator.setSourceContent(source.path, source.content);
|
}
|
}
|
|
if (output.sources.length === 1) {
|
const defaultSource = output.sources[0];
|
const insertedMappings = new Map();
|
eachInputGeneratedRange(input, (generated, original, source) => {
|
eachOverlappingGeneratedOutputRange(defaultSource, generated, item => {
|
const key = makeMappingKey(item);
|
if (insertedMappings.has(key)) return;
|
insertedMappings.set(key, item);
|
mergedGenerator.addMapping({
|
source: source.path,
|
original: {
|
line: original.line,
|
column: original.columnStart
|
},
|
generated: {
|
line: item.line,
|
column: item.columnStart
|
},
|
name: original.name
|
});
|
});
|
});
|
|
for (const item of insertedMappings.values()) {
|
if (item.columnEnd === Infinity) {
|
continue;
|
}
|
|
const clearItem = {
|
line: item.line,
|
columnStart: item.columnEnd
|
};
|
const key = makeMappingKey(clearItem);
|
|
if (insertedMappings.has(key)) {
|
continue;
|
}
|
|
mergedGenerator.addMapping({
|
generated: {
|
line: clearItem.line,
|
column: clearItem.columnStart
|
}
|
});
|
}
|
}
|
|
const result = mergedGenerator.toJSON();
|
|
if (typeof input.sourceRoot === "string") {
|
result.sourceRoot = input.sourceRoot;
|
}
|
|
return result;
|
}
|
|
function makeMappingKey(item) {
|
return `${item.line}/${item.columnStart}`;
|
}
|
|
function eachOverlappingGeneratedOutputRange(outputFile, inputGeneratedRange, callback) {
|
const overlappingOriginal = filterApplicableOriginalRanges(outputFile, inputGeneratedRange);
|
|
for (const {
|
generated
|
} of overlappingOriginal) {
|
for (const item of generated) {
|
callback(item);
|
}
|
}
|
}
|
|
function filterApplicableOriginalRanges({
|
mappings
|
}, {
|
line,
|
columnStart,
|
columnEnd
|
}) {
|
return filterSortedArray(mappings, ({
|
original: outOriginal
|
}) => {
|
if (line > outOriginal.line) return -1;
|
if (line < outOriginal.line) return 1;
|
if (columnStart >= outOriginal.columnEnd) return -1;
|
if (columnEnd <= outOriginal.columnStart) return 1;
|
return 0;
|
});
|
}
|
|
function eachInputGeneratedRange(map, callback) {
|
for (const {
|
source,
|
mappings
|
} of map.sources) {
|
for (const {
|
original,
|
generated
|
} of mappings) {
|
for (const item of generated) {
|
callback(item, original, source);
|
}
|
}
|
}
|
}
|
|
function buildMappingData(map) {
|
const consumer = new (_sourceMap().SourceMapConsumer)(Object.assign({}, map, {
|
sourceRoot: null
|
}));
|
const sources = new Map();
|
const mappings = new Map();
|
let last = null;
|
consumer.computeColumnSpans();
|
consumer.eachMapping(m => {
|
if (m.originalLine === null) return;
|
let source = sources.get(m.source);
|
|
if (!source) {
|
source = {
|
path: m.source,
|
content: consumer.sourceContentFor(m.source, true)
|
};
|
sources.set(m.source, source);
|
}
|
|
let sourceData = mappings.get(source);
|
|
if (!sourceData) {
|
sourceData = {
|
source,
|
mappings: []
|
};
|
mappings.set(source, sourceData);
|
}
|
|
const obj = {
|
line: m.originalLine,
|
columnStart: m.originalColumn,
|
columnEnd: Infinity,
|
name: m.name
|
};
|
|
if (last && last.source === source && last.mapping.line === m.originalLine) {
|
last.mapping.columnEnd = m.originalColumn;
|
}
|
|
last = {
|
source,
|
mapping: obj
|
};
|
sourceData.mappings.push({
|
original: obj,
|
generated: consumer.allGeneratedPositionsFor({
|
source: m.source,
|
line: m.originalLine,
|
column: m.originalColumn
|
}).map(item => ({
|
line: item.line,
|
columnStart: item.column,
|
columnEnd: item.lastColumn + 1
|
}))
|
});
|
}, null, _sourceMap().SourceMapConsumer.ORIGINAL_ORDER);
|
return {
|
file: map.file,
|
sourceRoot: map.sourceRoot,
|
sources: Array.from(mappings.values())
|
};
|
}
|
|
function findInsertionLocation(array, callback) {
|
let left = 0;
|
let right = array.length;
|
|
while (left < right) {
|
const mid = Math.floor((left + right) / 2);
|
const item = array[mid];
|
const result = callback(item);
|
|
if (result === 0) {
|
left = mid;
|
break;
|
}
|
|
if (result >= 0) {
|
right = mid;
|
} else {
|
left = mid + 1;
|
}
|
}
|
|
let i = left;
|
|
if (i < array.length) {
|
while (i >= 0 && callback(array[i]) >= 0) {
|
i--;
|
}
|
|
return i + 1;
|
}
|
|
return i;
|
}
|
|
function filterSortedArray(array, callback) {
|
const start = findInsertionLocation(array, callback);
|
const results = [];
|
|
for (let i = start; i < array.length && callback(array[i]) === 0; i++) {
|
results.push(array[i]);
|
}
|
|
return results;
|
}
|
