| (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 |