forked from Fediversity/Fediversity
176 lines
6.2 KiB
JavaScript
176 lines
6.2 KiB
JavaScript
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourcemapCodec = {}));
|
|
})(this, (function (exports) { 'use strict';
|
|
|
|
const comma = ','.charCodeAt(0);
|
|
const semicolon = ';'.charCodeAt(0);
|
|
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
const intToChar = new Uint8Array(64); // 64 possible chars.
|
|
const charToInt = new Uint8Array(128); // z is 122 in ASCII
|
|
for (let i = 0; i < chars.length; i++) {
|
|
const c = chars.charCodeAt(i);
|
|
intToChar[i] = c;
|
|
charToInt[c] = i;
|
|
}
|
|
// Provide a fallback for older environments.
|
|
const td = typeof TextDecoder !== 'undefined'
|
|
? /* #__PURE__ */ new TextDecoder()
|
|
: typeof Buffer !== 'undefined'
|
|
? {
|
|
decode(buf) {
|
|
const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
|
|
return out.toString();
|
|
},
|
|
}
|
|
: {
|
|
decode(buf) {
|
|
let out = '';
|
|
for (let i = 0; i < buf.length; i++) {
|
|
out += String.fromCharCode(buf[i]);
|
|
}
|
|
return out;
|
|
},
|
|
};
|
|
function decode(mappings) {
|
|
const state = new Int32Array(5);
|
|
const decoded = [];
|
|
let index = 0;
|
|
do {
|
|
const semi = indexOf(mappings, index);
|
|
const line = [];
|
|
let sorted = true;
|
|
let lastCol = 0;
|
|
state[0] = 0;
|
|
for (let i = index; i < semi; i++) {
|
|
let seg;
|
|
i = decodeInteger(mappings, i, state, 0); // genColumn
|
|
const col = state[0];
|
|
if (col < lastCol)
|
|
sorted = false;
|
|
lastCol = col;
|
|
if (hasMoreVlq(mappings, i, semi)) {
|
|
i = decodeInteger(mappings, i, state, 1); // sourcesIndex
|
|
i = decodeInteger(mappings, i, state, 2); // sourceLine
|
|
i = decodeInteger(mappings, i, state, 3); // sourceColumn
|
|
if (hasMoreVlq(mappings, i, semi)) {
|
|
i = decodeInteger(mappings, i, state, 4); // namesIndex
|
|
seg = [col, state[1], state[2], state[3], state[4]];
|
|
}
|
|
else {
|
|
seg = [col, state[1], state[2], state[3]];
|
|
}
|
|
}
|
|
else {
|
|
seg = [col];
|
|
}
|
|
line.push(seg);
|
|
}
|
|
if (!sorted)
|
|
sort(line);
|
|
decoded.push(line);
|
|
index = semi + 1;
|
|
} while (index <= mappings.length);
|
|
return decoded;
|
|
}
|
|
function indexOf(mappings, index) {
|
|
const idx = mappings.indexOf(';', index);
|
|
return idx === -1 ? mappings.length : idx;
|
|
}
|
|
function decodeInteger(mappings, pos, state, j) {
|
|
let value = 0;
|
|
let shift = 0;
|
|
let integer = 0;
|
|
do {
|
|
const c = mappings.charCodeAt(pos++);
|
|
integer = charToInt[c];
|
|
value |= (integer & 31) << shift;
|
|
shift += 5;
|
|
} while (integer & 32);
|
|
const shouldNegate = value & 1;
|
|
value >>>= 1;
|
|
if (shouldNegate) {
|
|
value = -0x80000000 | -value;
|
|
}
|
|
state[j] += value;
|
|
return pos;
|
|
}
|
|
function hasMoreVlq(mappings, i, length) {
|
|
if (i >= length)
|
|
return false;
|
|
return mappings.charCodeAt(i) !== comma;
|
|
}
|
|
function sort(line) {
|
|
line.sort(sortComparator);
|
|
}
|
|
function sortComparator(a, b) {
|
|
return a[0] - b[0];
|
|
}
|
|
function encode(decoded) {
|
|
const state = new Int32Array(5);
|
|
const bufLength = 1024 * 16;
|
|
const subLength = bufLength - 36;
|
|
const buf = new Uint8Array(bufLength);
|
|
const sub = buf.subarray(0, subLength);
|
|
let pos = 0;
|
|
let out = '';
|
|
for (let i = 0; i < decoded.length; i++) {
|
|
const line = decoded[i];
|
|
if (i > 0) {
|
|
if (pos === bufLength) {
|
|
out += td.decode(buf);
|
|
pos = 0;
|
|
}
|
|
buf[pos++] = semicolon;
|
|
}
|
|
if (line.length === 0)
|
|
continue;
|
|
state[0] = 0;
|
|
for (let j = 0; j < line.length; j++) {
|
|
const segment = line[j];
|
|
// We can push up to 5 ints, each int can take at most 7 chars, and we
|
|
// may push a comma.
|
|
if (pos > subLength) {
|
|
out += td.decode(sub);
|
|
buf.copyWithin(0, subLength, pos);
|
|
pos -= subLength;
|
|
}
|
|
if (j > 0)
|
|
buf[pos++] = comma;
|
|
pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
|
|
if (segment.length === 1)
|
|
continue;
|
|
pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
|
|
pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
|
|
pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
|
|
if (segment.length === 4)
|
|
continue;
|
|
pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
|
|
}
|
|
}
|
|
return out + td.decode(buf.subarray(0, pos));
|
|
}
|
|
function encodeInteger(buf, pos, state, segment, j) {
|
|
const next = segment[j];
|
|
let num = next - state[j];
|
|
state[j] = next;
|
|
num = num < 0 ? (-num << 1) | 1 : num << 1;
|
|
do {
|
|
let clamped = num & 0b011111;
|
|
num >>>= 5;
|
|
if (num > 0)
|
|
clamped |= 0b100000;
|
|
buf[pos++] = intToChar[clamped];
|
|
} while (num > 0);
|
|
return pos;
|
|
}
|
|
|
|
exports.decode = decode;
|
|
exports.encode = encode;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
}));
|
|
//# sourceMappingURL=sourcemap-codec.umd.js.map
|