From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001 From: Piotr Russ Date: Mon, 16 Nov 2020 00:10:28 +0100 Subject: api, login, auth --- node_modules/source-list-map/lib/CodeNode.js | 66 ++++++++ .../source-list-map/lib/MappingsContext.js | 45 ++++++ node_modules/source-list-map/lib/SingleLineNode.js | 93 ++++++++++++ node_modules/source-list-map/lib/SourceListMap.js | 117 ++++++++++++++ node_modules/source-list-map/lib/SourceNode.js | 129 ++++++++++++++++ node_modules/source-list-map/lib/base64-vlq.js | 169 +++++++++++++++++++++ .../source-list-map/lib/fromStringWithSourceMap.js | 102 +++++++++++++ node_modules/source-list-map/lib/helpers.js | 23 +++ node_modules/source-list-map/lib/index.js | 6 + 9 files changed, 750 insertions(+) create mode 100644 node_modules/source-list-map/lib/CodeNode.js create mode 100644 node_modules/source-list-map/lib/MappingsContext.js create mode 100644 node_modules/source-list-map/lib/SingleLineNode.js create mode 100644 node_modules/source-list-map/lib/SourceListMap.js create mode 100644 node_modules/source-list-map/lib/SourceNode.js create mode 100644 node_modules/source-list-map/lib/base64-vlq.js create mode 100644 node_modules/source-list-map/lib/fromStringWithSourceMap.js create mode 100644 node_modules/source-list-map/lib/helpers.js create mode 100644 node_modules/source-list-map/lib/index.js (limited to 'node_modules/source-list-map/lib') diff --git a/node_modules/source-list-map/lib/CodeNode.js b/node_modules/source-list-map/lib/CodeNode.js new file mode 100644 index 0000000..2013363 --- /dev/null +++ b/node_modules/source-list-map/lib/CodeNode.js @@ -0,0 +1,66 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const getNumberOfLines = require("./helpers").getNumberOfLines; +const getUnfinishedLine = require("./helpers").getUnfinishedLine; + +class CodeNode { + constructor(generatedCode) { + this.generatedCode = generatedCode; + } + + clone() { + return new CodeNode(this.generatedCode); + } + + getGeneratedCode() { + return this.generatedCode; + } + + getMappings(mappingsContext) { + const lines = getNumberOfLines(this.generatedCode); + const mapping = Array(lines+1).join(";"); + if(lines > 0) { + mappingsContext.unfinishedGeneratedLine = getUnfinishedLine(this.generatedCode); + if(mappingsContext.unfinishedGeneratedLine > 0) { + return mapping + "A"; + } else { + return mapping; + } + } else { + const prevUnfinished = mappingsContext.unfinishedGeneratedLine; + mappingsContext.unfinishedGeneratedLine += getUnfinishedLine(this.generatedCode); + if(prevUnfinished === 0 && mappingsContext.unfinishedGeneratedLine > 0) { + return "A"; + } else { + return ""; + } + } + } + + addGeneratedCode(generatedCode) { + this.generatedCode += generatedCode; + } + + mapGeneratedCode(fn) { + const generatedCode = fn(this.generatedCode); + return new CodeNode(generatedCode); + } + + getNormalizedNodes() { + return [this]; + } + + merge(otherNode) { + if(otherNode instanceof CodeNode) { + this.generatedCode += otherNode.generatedCode; + return this; + } + return false; + } +} + +module.exports = CodeNode; diff --git a/node_modules/source-list-map/lib/MappingsContext.js b/node_modules/source-list-map/lib/MappingsContext.js new file mode 100644 index 0000000..9a0c905 --- /dev/null +++ b/node_modules/source-list-map/lib/MappingsContext.js @@ -0,0 +1,45 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +class MappingsContext { + constructor() { + this.sourcesIndices = new Map(); + this.sourcesContent = new Map(); + this.hasSourceContent = false; + this.currentOriginalLine = 1; + this.currentSource = 0; + this.unfinishedGeneratedLine = false; + } + + ensureSource(source, originalSource) { + let idx = this.sourcesIndices.get(source); + if(typeof idx === "number") { + return idx; + } + idx = this.sourcesIndices.size; + this.sourcesIndices.set(source, idx); + this.sourcesContent.set(source, originalSource) + if(typeof originalSource === "string") + this.hasSourceContent = true; + return idx; + } + + getArrays() { + const sources = []; + const sourcesContent = []; + + for(const pair of this.sourcesContent) { + sources.push(pair[0]); + sourcesContent.push(pair[1]); + } + + return { + sources, + sourcesContent + }; + } +} +module.exports = MappingsContext; diff --git a/node_modules/source-list-map/lib/SingleLineNode.js b/node_modules/source-list-map/lib/SingleLineNode.js new file mode 100644 index 0000000..bbc1b5d --- /dev/null +++ b/node_modules/source-list-map/lib/SingleLineNode.js @@ -0,0 +1,93 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const base64VLQ = require("./base64-vlq"); +const getNumberOfLines = require("./helpers").getNumberOfLines; +const getUnfinishedLine = require("./helpers").getUnfinishedLine; + +const LINE_MAPPING = ";AAAA"; + +class SingleLineNode { + + constructor(generatedCode, source, originalSource, line) { + this.generatedCode = generatedCode; + this.originalSource = originalSource; + this.source = source; + this.line = line || 1; + this._numberOfLines = getNumberOfLines(this.generatedCode); + this._endsWithNewLine = generatedCode[generatedCode.length - 1] === "\n"; + } + + clone() { + return new SingleLineNode(this.generatedCode, this.source, this.originalSource, this.line); + } + + getGeneratedCode() { + return this.generatedCode; + } + + getMappings(mappingsContext) { + if(!this.generatedCode) + return ""; + const lines = this._numberOfLines; + const sourceIdx = mappingsContext.ensureSource(this.source, this.originalSource); + let mappings = "A"; // generated column 0 + if(mappingsContext.unfinishedGeneratedLine) + mappings = "," + base64VLQ.encode(mappingsContext.unfinishedGeneratedLine); + mappings += base64VLQ.encode(sourceIdx - mappingsContext.currentSource); // source index + mappings += base64VLQ.encode(this.line - mappingsContext.currentOriginalLine); // original line index + mappings += "A"; // original column 0 + mappingsContext.currentSource = sourceIdx; + mappingsContext.currentOriginalLine = this.line; + const unfinishedGeneratedLine = mappingsContext.unfinishedGeneratedLine = getUnfinishedLine(this.generatedCode) + mappings += Array(lines).join(LINE_MAPPING); + if(unfinishedGeneratedLine === 0) { + mappings += ";"; + } else { + if(lines !== 0) + mappings += LINE_MAPPING; + } + return mappings; + } + + getNormalizedNodes() { + return [this]; + } + + mapGeneratedCode(fn) { + const generatedCode = fn(this.generatedCode); + return new SingleLineNode(generatedCode, this.source, this.originalSource, this.line); + } + + merge(otherNode) { + if(otherNode instanceof SingleLineNode) { + return this.mergeSingleLineNode(otherNode); + } + return false; + } + + mergeSingleLineNode(otherNode) { + if(this.source === otherNode.source && + this.originalSource === otherNode.originalSource) { + if(this.line === otherNode.line) { + this.generatedCode += otherNode.generatedCode; + this._numberOfLines += otherNode._numberOfLines; + this._endsWithNewLine = otherNode._endsWithNewLine; + return this; + } else if(this.line + 1 === otherNode.line && + this._endsWithNewLine && + this._numberOfLines === 1 && + otherNode._numberOfLines <= 1) { + return new SourceNode(this.generatedCode + otherNode.generatedCode, this.source, this.originalSource, this.line); + } + } + return false; + } +} + +module.exports = SingleLineNode; + +const SourceNode = require("./SourceNode"); // circular dependency diff --git a/node_modules/source-list-map/lib/SourceListMap.js b/node_modules/source-list-map/lib/SourceListMap.js new file mode 100644 index 0000000..575b2d7 --- /dev/null +++ b/node_modules/source-list-map/lib/SourceListMap.js @@ -0,0 +1,117 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const CodeNode = require("./CodeNode"); +const SourceNode = require("./SourceNode"); +const MappingsContext = require("./MappingsContext"); +const getNumberOfLines = require("./helpers").getNumberOfLines; + +class SourceListMap { + + constructor(generatedCode, source, originalSource) { + if(Array.isArray(generatedCode)) { + this.children = generatedCode; + } else { + this.children = []; + if(generatedCode || source) + this.add(generatedCode, source, originalSource); + } + } + + add(generatedCode, source, originalSource) { + if(typeof generatedCode === "string") { + if(source) { + this.children.push(new SourceNode(generatedCode, source, originalSource)); + } else if(this.children.length > 0 && this.children[this.children.length - 1] instanceof CodeNode) { + this.children[this.children.length - 1].addGeneratedCode(generatedCode); + } else { + this.children.push(new CodeNode(generatedCode)); + } + } else if(generatedCode.getMappings && generatedCode.getGeneratedCode) { + this.children.push(generatedCode); + } else if(generatedCode.children) { + generatedCode.children.forEach(function(sln) { + this.children.push(sln); + }, this); + } else { + throw new Error("Invalid arguments to SourceListMap.protfotype.add: Expected string, Node or SourceListMap"); + } + }; + + preprend(generatedCode, source, originalSource) { + if(typeof generatedCode === "string") { + if(source) { + this.children.unshift(new SourceNode(generatedCode, source, originalSource)); + } else if(this.children.length > 0 && this.children[this.children.length - 1].preprendGeneratedCode) { + this.children[this.children.length - 1].preprendGeneratedCode(generatedCode); + } else { + this.children.unshift(new CodeNode(generatedCode)); + } + } else if(generatedCode.getMappings && generatedCode.getGeneratedCode) { + this.children.unshift(generatedCode); + } else if(generatedCode.children) { + generatedCode.children.slice().reverse().forEach(function(sln) { + this.children.unshift(sln); + }, this); + } else { + throw new Error("Invalid arguments to SourceListMap.protfotype.prerend: Expected string, Node or SourceListMap"); + } + }; + + mapGeneratedCode(fn) { + const normalizedNodes = []; + this.children.forEach(function(sln) { + sln.getNormalizedNodes().forEach(function(newNode) { + normalizedNodes.push(newNode); + }); + }); + const optimizedNodes = []; + normalizedNodes.forEach(function(sln) { + sln = sln.mapGeneratedCode(fn); + if(optimizedNodes.length === 0) { + optimizedNodes.push(sln); + } else { + const last = optimizedNodes[optimizedNodes.length - 1]; + const mergedNode = last.merge(sln); + if(mergedNode) { + optimizedNodes[optimizedNodes.length - 1] = mergedNode; + } else { + optimizedNodes.push(sln); + } + } + }); + return new SourceListMap(optimizedNodes); + }; + + toString() { + return this.children.map(function(sln) { + return sln.getGeneratedCode(); + }).join(""); + }; + + toStringWithSourceMap(options) { + const mappingsContext = new MappingsContext(); + const source = this.children.map(function(sln) { + return sln.getGeneratedCode(); + }).join(""); + const mappings = this.children.map(function(sln) { + return sln.getMappings(mappingsContext); + }).join(""); + const arrays = mappingsContext.getArrays(); + return { + source, + map: { + version: 3, + file: options && options.file, + sources: arrays.sources, + sourcesContent: mappingsContext.hasSourceContent ? arrays.sourcesContent : undefined, + mappings: mappings + } + }; + } +} + +module.exports = SourceListMap; diff --git a/node_modules/source-list-map/lib/SourceNode.js b/node_modules/source-list-map/lib/SourceNode.js new file mode 100644 index 0000000..7dd235e --- /dev/null +++ b/node_modules/source-list-map/lib/SourceNode.js @@ -0,0 +1,129 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const base64VLQ = require("./base64-vlq"); +const getNumberOfLines = require("./helpers").getNumberOfLines; +const getUnfinishedLine = require("./helpers").getUnfinishedLine; + +const LINE_MAPPING = ";AACA"; + +class SourceNode { + + constructor(generatedCode, source, originalSource, startingLine) { + this.generatedCode = generatedCode; + this.originalSource = originalSource; + this.source = source; + this.startingLine = startingLine || 1; + this._numberOfLines = getNumberOfLines(this.generatedCode); + this._endsWithNewLine = generatedCode[generatedCode.length - 1] === "\n"; + } + + clone() { + return new SourceNode(this.generatedCode, this.source, this.originalSource, this.startingLine); + } + + getGeneratedCode() { + return this.generatedCode; + } + + addGeneratedCode(code) { + this.generatedCode += code; + this._numberOfLines += getNumberOfLines(code); + this._endsWithNewLine = code[code.length - 1] === "\n"; + } + + getMappings(mappingsContext) { + if(!this.generatedCode) + return ""; + const lines = this._numberOfLines; + const sourceIdx = mappingsContext.ensureSource(this.source, this.originalSource); + let mappings = "A"; // generated column 0 + if(mappingsContext.unfinishedGeneratedLine) + mappings = "," + base64VLQ.encode(mappingsContext.unfinishedGeneratedLine); + mappings += base64VLQ.encode(sourceIdx - mappingsContext.currentSource); // source index + mappings += base64VLQ.encode(this.startingLine - mappingsContext.currentOriginalLine); // original line index + mappings += "A"; // original column 0 + mappingsContext.currentSource = sourceIdx; + mappingsContext.currentOriginalLine = this.startingLine + lines - 1; + const unfinishedGeneratedLine = mappingsContext.unfinishedGeneratedLine = getUnfinishedLine(this.generatedCode) + mappings += Array(lines).join(LINE_MAPPING); + if(unfinishedGeneratedLine === 0) { + mappings += ";"; + } else { + if(lines !== 0) { + mappings += LINE_MAPPING; + } + mappingsContext.currentOriginalLine++; + } + return mappings; + } + + mapGeneratedCode(fn) { + throw new Error("Cannot map generated code on a SourceMap. Normalize to SingleLineNode first."); + } + + getNormalizedNodes() { + var results = []; + var currentLine = this.startingLine; + var generatedCode = this.generatedCode; + var index = 0; + var indexEnd = generatedCode.length; + while(index < indexEnd) { + // get one generated line + var nextLine = generatedCode.indexOf("\n", index) + 1; + if(nextLine === 0) nextLine = indexEnd; + var lineGenerated = generatedCode.substr(index, nextLine - index); + + results.push(new SingleLineNode(lineGenerated, this.source, this.originalSource, currentLine)); + + // move cursors + index = nextLine; + currentLine++; + } + return results; + } + + merge(otherNode) { + if(otherNode instanceof SourceNode) { + return this.mergeSourceNode(otherNode); + } else if(otherNode instanceof SingleLineNode) { + return this.mergeSingleLineNode(otherNode); + } + return false; + } + + mergeSourceNode(otherNode) { + if(this.source === otherNode.source && + this._endsWithNewLine && + this.startingLine + this._numberOfLines === otherNode.startingLine) { + this.generatedCode += otherNode.generatedCode; + this._numberOfLines += otherNode._numberOfLines; + this._endsWithNewLine = otherNode._endsWithNewLine; + return this; + } + return false; + } + + mergeSingleLineNode(otherNode) { + if(this.source === otherNode.source && + this._endsWithNewLine && + this.startingLine + this._numberOfLines === otherNode.line && + otherNode._numberOfLines <= 1) { + this.addSingleLineNode(otherNode); + return this; + } + return false; + } + + addSingleLineNode(otherNode) { + this.generatedCode += otherNode.generatedCode; + this._numberOfLines += otherNode._numberOfLines + this._endsWithNewLine = otherNode._endsWithNewLine; + } +} + +module.exports = SourceNode; +const SingleLineNode = require("./SingleLineNode"); // circular dependency diff --git a/node_modules/source-list-map/lib/base64-vlq.js b/node_modules/source-list-map/lib/base64-vlq.js new file mode 100644 index 0000000..4483a50 --- /dev/null +++ b/node_modules/source-list-map/lib/base64-vlq.js @@ -0,0 +1,169 @@ +/* -*- Mode: js; js-indent-level: 2; -*- */ +/* + * Copyright 2011 Mozilla Foundation and contributors + * Licensed under the New BSD license. See LICENSE or: + * http://opensource.org/licenses/BSD-3-Clause + * + * Based on the Base 64 VLQ implementation in Closure Compiler: + * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java + * + * Copyright 2011 The Closure Compiler Authors. All rights reserved. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/*eslint no-bitwise:0,quotes:0,global-strict:0*/ + +var charToIntMap = {}; +var intToCharMap = {}; + +'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' + .split('') + .forEach(function (ch, index) { + charToIntMap[ch] = index; + intToCharMap[index] = ch; + }); + +var base64 = {}; +/** + * Encode an integer in the range of 0 to 63 to a single base 64 digit. + */ +base64.encode = function base64_encode(aNumber) { + if (aNumber in intToCharMap) { + return intToCharMap[aNumber]; + } + throw new TypeError("Must be between 0 and 63: " + aNumber); +}; + +/** + * Decode a single base 64 digit to an integer. + */ +base64.decode = function base64_decode(aChar) { + if (aChar in charToIntMap) { + return charToIntMap[aChar]; + } + throw new TypeError("Not a valid base 64 digit: " + aChar); +}; + + + +// A single base 64 digit can contain 6 bits of data. For the base 64 variable +// length quantities we use in the source map spec, the first bit is the sign, +// the next four bits are the actual value, and the 6th bit is the +// continuation bit. The continuation bit tells us whether there are more +// digits in this value following this digit. +// +// Continuation +// | Sign +// | | +// V V +// 101011 + +var VLQ_BASE_SHIFT = 5; + +// binary: 100000 +var VLQ_BASE = 1 << VLQ_BASE_SHIFT; + +// binary: 011111 +var VLQ_BASE_MASK = VLQ_BASE - 1; + +// binary: 100000 +var VLQ_CONTINUATION_BIT = VLQ_BASE; + +/** + * Converts from a two-complement value to a value where the sign bit is + * placed in the least significant bit. For example, as decimals: + * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary) + * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary) + */ +function toVLQSigned(aValue) { + return aValue < 0 + ? ((-aValue) << 1) + 1 + : (aValue << 1) + 0; +} + +/** + * Converts to a two-complement value from a value where the sign bit is + * placed in the least significant bit. For example, as decimals: + * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1 + * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2 + */ +function fromVLQSigned(aValue) { + var isNegative = (aValue & 1) === 1; + var shifted = aValue >> 1; + return isNegative + ? -shifted + : shifted; +} + +/** + * Returns the base 64 VLQ encoded value. + */ +exports.encode = function base64VLQ_encode(aValue) { + var encoded = ""; + var digit; + + var vlq = toVLQSigned(aValue); + + do { + digit = vlq & VLQ_BASE_MASK; + vlq >>>= VLQ_BASE_SHIFT; + if (vlq > 0) { + // There are still more digits in this value, so we must make sure the + // continuation bit is marked. + digit |= VLQ_CONTINUATION_BIT; + } + encoded += base64.encode(digit); + } while (vlq > 0); + + return encoded; +}; + +/** + * Decodes the next base 64 VLQ value from the given string and returns the + * value and the rest of the string via the out parameter. + */ +exports.decode = function base64VLQ_decode(aStr, aOutParam) { + var i = 0; + var strLen = aStr.length; + var result = 0; + var shift = 0; + var continuation, digit; + + do { + if (i >= strLen) { + throw new Error("Expected more digits in base 64 VLQ value."); + } + digit = base64.decode(aStr.charAt(i++)); + continuation = !!(digit & VLQ_CONTINUATION_BIT); + digit &= VLQ_BASE_MASK; + result = result + (digit << shift); + shift += VLQ_BASE_SHIFT; + } while (continuation); + + aOutParam.value = fromVLQSigned(result); + aOutParam.rest = aStr.slice(i); +}; diff --git a/node_modules/source-list-map/lib/fromStringWithSourceMap.js b/node_modules/source-list-map/lib/fromStringWithSourceMap.js new file mode 100644 index 0000000..0148d7e --- /dev/null +++ b/node_modules/source-list-map/lib/fromStringWithSourceMap.js @@ -0,0 +1,102 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +const base64VLQ = require("./base64-vlq"); +const SourceNode = require("./SourceNode"); +const CodeNode = require("./CodeNode"); +const SourceListMap = require("./SourceListMap"); + +module.exports = function fromStringWithSourceMap(code, map) { + const sources = map.sources; + const sourcesContent = map.sourcesContent; + const mappings = map.mappings.split(";"); + const lines = code.split("\n"); + const nodes = []; + let currentNode = null; + let currentLine = 1; + let currentSourceIdx = 0; + let currentSourceNodeLine; + function addCode(generatedCode) { + if(currentNode && currentNode instanceof CodeNode) { + currentNode.addGeneratedCode(generatedCode); + } else if(currentNode && currentNode instanceof SourceNode && !generatedCode.trim()) { + currentNode.addGeneratedCode(generatedCode); + currentSourceNodeLine++; + } else { + currentNode = new CodeNode(generatedCode); + nodes.push(currentNode); + } + } + function addSource(generatedCode, source, originalSource, linePosition) { + if(currentNode && currentNode instanceof SourceNode && + currentNode.source === source && + currentSourceNodeLine === linePosition + ) { + currentNode.addGeneratedCode(generatedCode); + currentSourceNodeLine++; + } else { + currentNode = new SourceNode(generatedCode, source, originalSource, linePosition); + currentSourceNodeLine = linePosition + 1; + nodes.push(currentNode); + } + } + mappings.forEach(function(mapping, idx) { + let line = lines[idx]; + if(typeof line === 'undefined') return; + if(idx !== lines.length - 1) line += "\n"; + if(!mapping) + return addCode(line); + mapping = { value: 0, rest: mapping }; + let lineAdded = false; + while(mapping.rest) + lineAdded = processMapping(mapping, line, lineAdded) || lineAdded; + if(!lineAdded) + addCode(line); + }); + if(mappings.length < lines.length) { + let idx = mappings.length; + while(!lines[idx].trim() && idx < lines.length-1) { + addCode(lines[idx] + "\n"); + idx++; + } + addCode(lines.slice(idx).join("\n")); + } + return new SourceListMap(nodes); + function processMapping(mapping, line, ignore) { + if(mapping.rest && mapping.rest[0] !== ",") { + base64VLQ.decode(mapping.rest, mapping); + } + if(!mapping.rest) + return false; + if(mapping.rest[0] === ",") { + mapping.rest = mapping.rest.substr(1); + return false; + } + + base64VLQ.decode(mapping.rest, mapping); + const sourceIdx = mapping.value + currentSourceIdx; + currentSourceIdx = sourceIdx; + + let linePosition; + if(mapping.rest && mapping.rest[0] !== ",") { + base64VLQ.decode(mapping.rest, mapping); + linePosition = mapping.value + currentLine; + currentLine = linePosition; + } else { + linePosition = currentLine; + } + + if(mapping.rest) { + const next = mapping.rest.indexOf(","); + mapping.rest = next === -1 ? "" : mapping.rest.substr(next); + } + + if(!ignore) { + addSource(line, sources ? sources[sourceIdx] : null, sourcesContent ? sourcesContent[sourceIdx] : null, linePosition) + return true; + } + } +}; diff --git a/node_modules/source-list-map/lib/helpers.js b/node_modules/source-list-map/lib/helpers.js new file mode 100644 index 0000000..d0b4292 --- /dev/null +++ b/node_modules/source-list-map/lib/helpers.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +exports.getNumberOfLines = function getNumberOfLines(str) { + let nr = -1; + let idx = -1; + do { + nr++ + idx = str.indexOf("\n", idx + 1); + } while(idx >= 0); + return nr; +}; + +exports.getUnfinishedLine = function getUnfinishedLine(str) { + const idx = str.lastIndexOf("\n"); + if(idx === -1) + return str.length; + else + return str.length - idx - 1; +}; diff --git a/node_modules/source-list-map/lib/index.js b/node_modules/source-list-map/lib/index.js new file mode 100644 index 0000000..c1ad107 --- /dev/null +++ b/node_modules/source-list-map/lib/index.js @@ -0,0 +1,6 @@ +exports.SourceListMap = require("./SourceListMap"); +exports.SourceNode = require("./SourceNode"); +exports.SingleLineNode = require("./SingleLineNode"); +exports.CodeNode = require("./CodeNode"); +exports.MappingsContext = require("./MappingsContext"); +exports.fromStringWithSourceMap = require("./fromStringWithSourceMap"); -- cgit v1.2.3