559 lines
18 KiB
JavaScript
559 lines
18 KiB
JavaScript
(function (global, factory, m) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(module, require('@jridgewell/resolve-uri'), require('@jridgewell/sourcemap-codec')) :
|
|
typeof define === 'function' && define.amd ? define(['module', '@jridgewell/resolve-uri', '@jridgewell/sourcemap-codec'], factory) :
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(m = { exports: {} }, global.resolveURI, global.sourcemapCodec), global.traceMapping = 'default' in m.exports ? m.exports.default : m.exports);
|
|
})(this, (function (module, require_resolveURI, require_sourcemapCodec) {
|
|
"use strict";
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// umd:@jridgewell/sourcemap-codec
|
|
var require_sourcemap_codec = __commonJS({
|
|
"umd:@jridgewell/sourcemap-codec"(exports, module2) {
|
|
module2.exports = require_sourcemapCodec;
|
|
}
|
|
});
|
|
|
|
// umd:@jridgewell/resolve-uri
|
|
var require_resolve_uri = __commonJS({
|
|
"umd:@jridgewell/resolve-uri"(exports, module2) {
|
|
module2.exports = require_resolveURI;
|
|
}
|
|
});
|
|
|
|
// src/trace-mapping.ts
|
|
var trace_mapping_exports = {};
|
|
__export(trace_mapping_exports, {
|
|
AnyMap: () => FlattenMap,
|
|
FlattenMap: () => FlattenMap,
|
|
GREATEST_LOWER_BOUND: () => GREATEST_LOWER_BOUND,
|
|
LEAST_UPPER_BOUND: () => LEAST_UPPER_BOUND,
|
|
TraceMap: () => TraceMap,
|
|
allGeneratedPositionsFor: () => allGeneratedPositionsFor,
|
|
decodedMap: () => decodedMap,
|
|
decodedMappings: () => decodedMappings,
|
|
eachMapping: () => eachMapping,
|
|
encodedMap: () => encodedMap,
|
|
encodedMappings: () => encodedMappings,
|
|
generatedPositionFor: () => generatedPositionFor,
|
|
isIgnored: () => isIgnored,
|
|
originalPositionFor: () => originalPositionFor,
|
|
presortedDecodedMap: () => presortedDecodedMap,
|
|
sourceContentFor: () => sourceContentFor,
|
|
traceSegment: () => traceSegment
|
|
});
|
|
module.exports = __toCommonJS(trace_mapping_exports);
|
|
var import_sourcemap_codec = __toESM(require_sourcemap_codec());
|
|
|
|
// src/resolve.ts
|
|
var import_resolve_uri = __toESM(require_resolve_uri());
|
|
|
|
// src/strip-filename.ts
|
|
function stripFilename(path) {
|
|
if (!path) return "";
|
|
const index = path.lastIndexOf("/");
|
|
return path.slice(0, index + 1);
|
|
}
|
|
|
|
// src/resolve.ts
|
|
function resolver(mapUrl, sourceRoot) {
|
|
const from = stripFilename(mapUrl);
|
|
const prefix = sourceRoot ? sourceRoot + "/" : "";
|
|
return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from);
|
|
}
|
|
|
|
// src/sourcemap-segment.ts
|
|
var COLUMN = 0;
|
|
var SOURCES_INDEX = 1;
|
|
var SOURCE_LINE = 2;
|
|
var SOURCE_COLUMN = 3;
|
|
var NAMES_INDEX = 4;
|
|
var REV_GENERATED_LINE = 1;
|
|
var REV_GENERATED_COLUMN = 2;
|
|
|
|
// src/sort.ts
|
|
function maybeSort(mappings, owned) {
|
|
const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
|
|
if (unsortedIndex === mappings.length) return mappings;
|
|
if (!owned) mappings = mappings.slice();
|
|
for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
|
|
mappings[i] = sortSegments(mappings[i], owned);
|
|
}
|
|
return mappings;
|
|
}
|
|
function nextUnsortedSegmentLine(mappings, start) {
|
|
for (let i = start; i < mappings.length; i++) {
|
|
if (!isSorted(mappings[i])) return i;
|
|
}
|
|
return mappings.length;
|
|
}
|
|
function isSorted(line) {
|
|
for (let j = 1; j < line.length; j++) {
|
|
if (line[j][COLUMN] < line[j - 1][COLUMN]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function sortSegments(line, owned) {
|
|
if (!owned) line = line.slice();
|
|
return line.sort(sortComparator);
|
|
}
|
|
function sortComparator(a, b) {
|
|
return a[COLUMN] - b[COLUMN];
|
|
}
|
|
|
|
// src/binary-search.ts
|
|
var found = false;
|
|
function binarySearch(haystack, needle, low, high) {
|
|
while (low <= high) {
|
|
const mid = low + (high - low >> 1);
|
|
const cmp = haystack[mid][COLUMN] - needle;
|
|
if (cmp === 0) {
|
|
found = true;
|
|
return mid;
|
|
}
|
|
if (cmp < 0) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid - 1;
|
|
}
|
|
}
|
|
found = false;
|
|
return low - 1;
|
|
}
|
|
function upperBound(haystack, needle, index) {
|
|
for (let i = index + 1; i < haystack.length; index = i++) {
|
|
if (haystack[i][COLUMN] !== needle) break;
|
|
}
|
|
return index;
|
|
}
|
|
function lowerBound(haystack, needle, index) {
|
|
for (let i = index - 1; i >= 0; index = i--) {
|
|
if (haystack[i][COLUMN] !== needle) break;
|
|
}
|
|
return index;
|
|
}
|
|
function memoizedState() {
|
|
return {
|
|
lastKey: -1,
|
|
lastNeedle: -1,
|
|
lastIndex: -1
|
|
};
|
|
}
|
|
function memoizedBinarySearch(haystack, needle, state, key) {
|
|
const { lastKey, lastNeedle, lastIndex } = state;
|
|
let low = 0;
|
|
let high = haystack.length - 1;
|
|
if (key === lastKey) {
|
|
if (needle === lastNeedle) {
|
|
found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
|
|
return lastIndex;
|
|
}
|
|
if (needle >= lastNeedle) {
|
|
low = lastIndex === -1 ? 0 : lastIndex;
|
|
} else {
|
|
high = lastIndex;
|
|
}
|
|
}
|
|
state.lastKey = key;
|
|
state.lastNeedle = needle;
|
|
return state.lastIndex = binarySearch(haystack, needle, low, high);
|
|
}
|
|
|
|
// src/by-source.ts
|
|
function buildBySources(decoded, memos) {
|
|
const sources = memos.map(buildNullArray);
|
|
for (let i = 0; i < decoded.length; i++) {
|
|
const line = decoded[i];
|
|
for (let j = 0; j < line.length; j++) {
|
|
const seg = line[j];
|
|
if (seg.length === 1) continue;
|
|
const sourceIndex2 = seg[SOURCES_INDEX];
|
|
const sourceLine = seg[SOURCE_LINE];
|
|
const sourceColumn = seg[SOURCE_COLUMN];
|
|
const originalSource = sources[sourceIndex2];
|
|
const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
|
|
const memo = memos[sourceIndex2];
|
|
let index = upperBound(
|
|
originalLine,
|
|
sourceColumn,
|
|
memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine)
|
|
);
|
|
memo.lastIndex = ++index;
|
|
insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
|
|
}
|
|
}
|
|
return sources;
|
|
}
|
|
function insert(array, index, value) {
|
|
for (let i = array.length; i > index; i--) {
|
|
array[i] = array[i - 1];
|
|
}
|
|
array[index] = value;
|
|
}
|
|
function buildNullArray() {
|
|
return { __proto__: null };
|
|
}
|
|
|
|
// src/types.ts
|
|
function parse(map) {
|
|
return typeof map === "string" ? JSON.parse(map) : map;
|
|
}
|
|
|
|
// src/flatten-map.ts
|
|
var FlattenMap = function(map, mapUrl) {
|
|
const parsed = parse(map);
|
|
if (!("sections" in parsed)) {
|
|
return new TraceMap(parsed, mapUrl);
|
|
}
|
|
const mappings = [];
|
|
const sources = [];
|
|
const sourcesContent = [];
|
|
const names = [];
|
|
const ignoreList = [];
|
|
recurse(
|
|
parsed,
|
|
mapUrl,
|
|
mappings,
|
|
sources,
|
|
sourcesContent,
|
|
names,
|
|
ignoreList,
|
|
0,
|
|
0,
|
|
Infinity,
|
|
Infinity
|
|
);
|
|
const joined = {
|
|
version: 3,
|
|
file: parsed.file,
|
|
names,
|
|
sources,
|
|
sourcesContent,
|
|
mappings,
|
|
ignoreList
|
|
};
|
|
return presortedDecodedMap(joined);
|
|
};
|
|
function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
|
|
const { sections } = input;
|
|
for (let i = 0; i < sections.length; i++) {
|
|
const { map, offset } = sections[i];
|
|
let sl = stopLine;
|
|
let sc = stopColumn;
|
|
if (i + 1 < sections.length) {
|
|
const nextOffset = sections[i + 1].offset;
|
|
sl = Math.min(stopLine, lineOffset + nextOffset.line);
|
|
if (sl === stopLine) {
|
|
sc = Math.min(stopColumn, columnOffset + nextOffset.column);
|
|
} else if (sl < stopLine) {
|
|
sc = columnOffset + nextOffset.column;
|
|
}
|
|
}
|
|
addSection(
|
|
map,
|
|
mapUrl,
|
|
mappings,
|
|
sources,
|
|
sourcesContent,
|
|
names,
|
|
ignoreList,
|
|
lineOffset + offset.line,
|
|
columnOffset + offset.column,
|
|
sl,
|
|
sc
|
|
);
|
|
}
|
|
}
|
|
function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
|
|
const parsed = parse(input);
|
|
if ("sections" in parsed) return recurse(...arguments);
|
|
const map = new TraceMap(parsed, mapUrl);
|
|
const sourcesOffset = sources.length;
|
|
const namesOffset = names.length;
|
|
const decoded = decodedMappings(map);
|
|
const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
|
|
append(sources, resolvedSources);
|
|
append(names, map.names);
|
|
if (contents) append(sourcesContent, contents);
|
|
else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
|
|
if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset);
|
|
for (let i = 0; i < decoded.length; i++) {
|
|
const lineI = lineOffset + i;
|
|
if (lineI > stopLine) return;
|
|
const out = getLine(mappings, lineI);
|
|
const cOffset = i === 0 ? columnOffset : 0;
|
|
const line = decoded[i];
|
|
for (let j = 0; j < line.length; j++) {
|
|
const seg = line[j];
|
|
const column = cOffset + seg[COLUMN];
|
|
if (lineI === stopLine && column >= stopColumn) return;
|
|
if (seg.length === 1) {
|
|
out.push([column]);
|
|
continue;
|
|
}
|
|
const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
|
|
const sourceLine = seg[SOURCE_LINE];
|
|
const sourceColumn = seg[SOURCE_COLUMN];
|
|
out.push(
|
|
seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function append(arr, other) {
|
|
for (let i = 0; i < other.length; i++) arr.push(other[i]);
|
|
}
|
|
function getLine(arr, index) {
|
|
for (let i = arr.length; i <= index; i++) arr[i] = [];
|
|
return arr[index];
|
|
}
|
|
|
|
// src/trace-mapping.ts
|
|
var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
|
|
var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
|
|
var LEAST_UPPER_BOUND = -1;
|
|
var GREATEST_LOWER_BOUND = 1;
|
|
var TraceMap = class {
|
|
constructor(map, mapUrl) {
|
|
const isString = typeof map === "string";
|
|
if (!isString && map._decodedMemo) return map;
|
|
const parsed = parse(map);
|
|
const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
|
|
this.version = version;
|
|
this.file = file;
|
|
this.names = names || [];
|
|
this.sourceRoot = sourceRoot;
|
|
this.sources = sources;
|
|
this.sourcesContent = sourcesContent;
|
|
this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
|
|
const resolve = resolver(mapUrl, sourceRoot);
|
|
this.resolvedSources = sources.map(resolve);
|
|
const { mappings } = parsed;
|
|
if (typeof mappings === "string") {
|
|
this._encoded = mappings;
|
|
this._decoded = void 0;
|
|
} else if (Array.isArray(mappings)) {
|
|
this._encoded = void 0;
|
|
this._decoded = maybeSort(mappings, isString);
|
|
} else if (parsed.sections) {
|
|
throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
|
|
} else {
|
|
throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
|
|
}
|
|
this._decodedMemo = memoizedState();
|
|
this._bySources = void 0;
|
|
this._bySourceMemos = void 0;
|
|
}
|
|
};
|
|
function cast(map) {
|
|
return map;
|
|
}
|
|
function encodedMappings(map) {
|
|
var _a, _b;
|
|
return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = (0, import_sourcemap_codec.encode)(cast(map)._decoded);
|
|
}
|
|
function decodedMappings(map) {
|
|
var _a;
|
|
return (_a = cast(map))._decoded || (_a._decoded = (0, import_sourcemap_codec.decode)(cast(map)._encoded));
|
|
}
|
|
function traceSegment(map, line, column) {
|
|
const decoded = decodedMappings(map);
|
|
if (line >= decoded.length) return null;
|
|
const segments = decoded[line];
|
|
const index = traceSegmentInternal(
|
|
segments,
|
|
cast(map)._decodedMemo,
|
|
line,
|
|
column,
|
|
GREATEST_LOWER_BOUND
|
|
);
|
|
return index === -1 ? null : segments[index];
|
|
}
|
|
function originalPositionFor(map, needle) {
|
|
let { line, column, bias } = needle;
|
|
line--;
|
|
if (line < 0) throw new Error(LINE_GTR_ZERO);
|
|
if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
|
|
const decoded = decodedMappings(map);
|
|
if (line >= decoded.length) return OMapping(null, null, null, null);
|
|
const segments = decoded[line];
|
|
const index = traceSegmentInternal(
|
|
segments,
|
|
cast(map)._decodedMemo,
|
|
line,
|
|
column,
|
|
bias || GREATEST_LOWER_BOUND
|
|
);
|
|
if (index === -1) return OMapping(null, null, null, null);
|
|
const segment = segments[index];
|
|
if (segment.length === 1) return OMapping(null, null, null, null);
|
|
const { names, resolvedSources } = map;
|
|
return OMapping(
|
|
resolvedSources[segment[SOURCES_INDEX]],
|
|
segment[SOURCE_LINE] + 1,
|
|
segment[SOURCE_COLUMN],
|
|
segment.length === 5 ? names[segment[NAMES_INDEX]] : null
|
|
);
|
|
}
|
|
function generatedPositionFor(map, needle) {
|
|
const { source, line, column, bias } = needle;
|
|
return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
|
|
}
|
|
function allGeneratedPositionsFor(map, needle) {
|
|
const { source, line, column, bias } = needle;
|
|
return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
|
|
}
|
|
function eachMapping(map, cb) {
|
|
const decoded = decodedMappings(map);
|
|
const { names, resolvedSources } = map;
|
|
for (let i = 0; i < decoded.length; i++) {
|
|
const line = decoded[i];
|
|
for (let j = 0; j < line.length; j++) {
|
|
const seg = line[j];
|
|
const generatedLine = i + 1;
|
|
const generatedColumn = seg[0];
|
|
let source = null;
|
|
let originalLine = null;
|
|
let originalColumn = null;
|
|
let name = null;
|
|
if (seg.length !== 1) {
|
|
source = resolvedSources[seg[1]];
|
|
originalLine = seg[2] + 1;
|
|
originalColumn = seg[3];
|
|
}
|
|
if (seg.length === 5) name = names[seg[4]];
|
|
cb({
|
|
generatedLine,
|
|
generatedColumn,
|
|
source,
|
|
originalLine,
|
|
originalColumn,
|
|
name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function sourceIndex(map, source) {
|
|
const { sources, resolvedSources } = map;
|
|
let index = sources.indexOf(source);
|
|
if (index === -1) index = resolvedSources.indexOf(source);
|
|
return index;
|
|
}
|
|
function sourceContentFor(map, source) {
|
|
const { sourcesContent } = map;
|
|
if (sourcesContent == null) return null;
|
|
const index = sourceIndex(map, source);
|
|
return index === -1 ? null : sourcesContent[index];
|
|
}
|
|
function isIgnored(map, source) {
|
|
const { ignoreList } = map;
|
|
if (ignoreList == null) return false;
|
|
const index = sourceIndex(map, source);
|
|
return index === -1 ? false : ignoreList.includes(index);
|
|
}
|
|
function presortedDecodedMap(map, mapUrl) {
|
|
const tracer = new TraceMap(clone(map, []), mapUrl);
|
|
cast(tracer)._decoded = map.mappings;
|
|
return tracer;
|
|
}
|
|
function decodedMap(map) {
|
|
return clone(map, decodedMappings(map));
|
|
}
|
|
function encodedMap(map) {
|
|
return clone(map, encodedMappings(map));
|
|
}
|
|
function clone(map, mappings) {
|
|
return {
|
|
version: map.version,
|
|
file: map.file,
|
|
names: map.names,
|
|
sourceRoot: map.sourceRoot,
|
|
sources: map.sources,
|
|
sourcesContent: map.sourcesContent,
|
|
mappings,
|
|
ignoreList: map.ignoreList || map.x_google_ignoreList
|
|
};
|
|
}
|
|
function OMapping(source, line, column, name) {
|
|
return { source, line, column, name };
|
|
}
|
|
function GMapping(line, column) {
|
|
return { line, column };
|
|
}
|
|
function traceSegmentInternal(segments, memo, line, column, bias) {
|
|
let index = memoizedBinarySearch(segments, column, memo, line);
|
|
if (found) {
|
|
index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
|
|
} else if (bias === LEAST_UPPER_BOUND) index++;
|
|
if (index === -1 || index === segments.length) return -1;
|
|
return index;
|
|
}
|
|
function sliceGeneratedPositions(segments, memo, line, column, bias) {
|
|
let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
|
|
if (!found && bias === LEAST_UPPER_BOUND) min++;
|
|
if (min === -1 || min === segments.length) return [];
|
|
const matchedColumn = found ? column : segments[min][COLUMN];
|
|
if (!found) min = lowerBound(segments, matchedColumn, min);
|
|
const max = upperBound(segments, matchedColumn, min);
|
|
const result = [];
|
|
for (; min <= max; min++) {
|
|
const segment = segments[min];
|
|
result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
|
|
}
|
|
return result;
|
|
}
|
|
function generatedPosition(map, source, line, column, bias, all) {
|
|
var _a;
|
|
line--;
|
|
if (line < 0) throw new Error(LINE_GTR_ZERO);
|
|
if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
|
|
const { sources, resolvedSources } = map;
|
|
let sourceIndex2 = sources.indexOf(source);
|
|
if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source);
|
|
if (sourceIndex2 === -1) return all ? [] : GMapping(null, null);
|
|
const generated = (_a = cast(map))._bySources || (_a._bySources = buildBySources(
|
|
decodedMappings(map),
|
|
cast(map)._bySourceMemos = sources.map(memoizedState)
|
|
));
|
|
const segments = generated[sourceIndex2][line];
|
|
if (segments == null) return all ? [] : GMapping(null, null);
|
|
const memo = cast(map)._bySourceMemos[sourceIndex2];
|
|
if (all) return sliceGeneratedPositions(segments, memo, line, column, bias);
|
|
const index = traceSegmentInternal(segments, memo, line, column, bias);
|
|
if (index === -1) return GMapping(null, null);
|
|
const segment = segments[index];
|
|
return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
|
|
}
|
|
}));
|
|
//# sourceMappingURL=trace-mapping.umd.js.map
|