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/webpack-sources/lib/ReplaceSource.js | 330 ++++++++++++++++++++++ 1 file changed, 330 insertions(+) create mode 100644 node_modules/webpack-sources/lib/ReplaceSource.js (limited to 'node_modules/webpack-sources/lib/ReplaceSource.js') diff --git a/node_modules/webpack-sources/lib/ReplaceSource.js b/node_modules/webpack-sources/lib/ReplaceSource.js new file mode 100644 index 0000000..d7a7f2a --- /dev/null +++ b/node_modules/webpack-sources/lib/ReplaceSource.js @@ -0,0 +1,330 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +"use strict"; + +var Source = require("./Source"); +var SourceNode = require("source-map").SourceNode; + +class Replacement { + constructor(start, end, content, insertIndex, name) { + this.start = start; + this.end = end; + this.content = content; + this.insertIndex = insertIndex; + this.name = name; + } +} + +class ReplaceSource extends Source { + constructor(source, name) { + super(); + this._source = source; + this._name = name; + /** @type {Replacement[]} */ + this.replacements = []; + } + + replace(start, end, newValue, name) { + if(typeof newValue !== "string") + throw new Error("insertion must be a string, but is a " + typeof newValue); + this.replacements.push(new Replacement(start, end, newValue, this.replacements.length, name)); + } + + insert(pos, newValue, name) { + if(typeof newValue !== "string") + throw new Error("insertion must be a string, but is a " + typeof newValue + ": " + newValue); + this.replacements.push(new Replacement(pos, pos - 1, newValue, this.replacements.length, name)); + } + + source(options) { + return this._replaceString(this._source.source()); + } + + original() { + return this._source; + } + + _sortReplacements() { + this.replacements.sort(function(a, b) { + var diff = b.end - a.end; + if(diff !== 0) + return diff; + diff = b.start - a.start; + if(diff !== 0) + return diff; + return b.insertIndex - a.insertIndex; + }); + } + + _replaceString(str) { + if(typeof str !== "string") + throw new Error("str must be a string, but is a " + typeof str + ": " + str); + this._sortReplacements(); + var result = [str]; + this.replacements.forEach(function(repl) { + var remSource = result.pop(); + var splitted1 = this._splitString(remSource, Math.floor(repl.end + 1)); + var splitted2 = this._splitString(splitted1[0], Math.floor(repl.start)); + result.push(splitted1[1], repl.content, splitted2[0]); + }, this); + + // write out result array in reverse order + let resultStr = ""; + for(let i = result.length - 1; i >= 0; --i) { + resultStr += result[i]; + } + return resultStr; + } + + node(options) { + var node = this._source.node(options); + if(this.replacements.length === 0) { + return node; + } + this._sortReplacements(); + var replace = new ReplacementEnumerator(this.replacements); + var output = []; + var position = 0; + var sources = Object.create(null); + var sourcesInLines = Object.create(null); + + // We build a new list of SourceNodes in "output" + // from the original mapping data + + var result = new SourceNode(); + + // We need to add source contents manually + // because "walk" will not handle it + node.walkSourceContents(function(sourceFile, sourceContent) { + result.setSourceContent(sourceFile, sourceContent); + sources["$" + sourceFile] = sourceContent; + }); + + var replaceInStringNode = this._replaceInStringNode.bind(this, output, replace, function getOriginalSource(mapping) { + var key = "$" + mapping.source; + var lines = sourcesInLines[key]; + if(!lines) { + var source = sources[key]; + if(!source) return null; + lines = source.split("\n").map(function(line) { + return line + "\n"; + }); + sourcesInLines[key] = lines; + } + // line is 1-based + if(mapping.line > lines.length) return null; + var line = lines[mapping.line - 1]; + return line.substr(mapping.column); + }); + + node.walk(function(chunk, mapping) { + position = replaceInStringNode(chunk, position, mapping); + }); + + // If any replacements occur after the end of the original file, then we append them + // directly to the end of the output + var remaining = replace.footer(); + if(remaining) { + output.push(remaining); + } + + result.add(output); + + return result; + } + + listMap(options) { + this._sortReplacements(); + var map = this._source.listMap(options); + var currentIndex = 0; + var replacements = this.replacements; + var idxReplacement = replacements.length - 1; + var removeChars = 0; + map = map.mapGeneratedCode(function(str) { + var newCurrentIndex = currentIndex + str.length; + if(removeChars > str.length) { + removeChars -= str.length; + str = ""; + } else { + if(removeChars > 0) { + str = str.substr(removeChars); + currentIndex += removeChars; + removeChars = 0; + } + var finalStr = ""; + while(idxReplacement >= 0 && replacements[idxReplacement].start < newCurrentIndex) { + var repl = replacements[idxReplacement]; + var start = Math.floor(repl.start); + var end = Math.floor(repl.end + 1); + var before = str.substr(0, Math.max(0, start - currentIndex)); + if(end <= newCurrentIndex) { + var after = str.substr(Math.max(0, end - currentIndex)); + finalStr += before + repl.content; + str = after; + currentIndex = Math.max(currentIndex, end); + } else { + finalStr += before + repl.content; + str = ""; + removeChars = end - newCurrentIndex; + } + idxReplacement--; + } + str = finalStr + str; + } + currentIndex = newCurrentIndex; + return str; + }); + var extraCode = ""; + while(idxReplacement >= 0) { + extraCode += replacements[idxReplacement].content; + idxReplacement--; + } + if(extraCode) { + map.add(extraCode); + } + return map; + } + + _splitString(str, position) { + return position <= 0 ? ["", str] : [str.substr(0, position), str.substr(position)]; + } + + _replaceInStringNode(output, replace, getOriginalSource, node, position, mapping) { + var original = undefined; + + do { + var splitPosition = replace.position - position; + // If multiple replaces occur in the same location then the splitPosition may be + // before the current position for the subsequent splits. Ensure it is >= 0 + if(splitPosition < 0) { + splitPosition = 0; + } + if(splitPosition >= node.length || replace.done) { + if(replace.emit) { + var nodeEnd = new SourceNode( + mapping.line, + mapping.column, + mapping.source, + node, + mapping.name + ); + output.push(nodeEnd); + } + return position + node.length; + } + + var originalColumn = mapping.column; + + // Try to figure out if generated code matches original code of this segement + // If this is the case we assume that it's allowed to move mapping.column + // Because getOriginalSource can be expensive we only do it when neccessary + + var nodePart; + if(splitPosition > 0) { + nodePart = node.slice(0, splitPosition); + if(original === undefined) { + original = getOriginalSource(mapping); + } + if(original && original.length >= splitPosition && original.startsWith(nodePart)) { + mapping.column += splitPosition; + original = original.substr(splitPosition); + } + } + + var emit = replace.next(); + if(!emit) { + // Stop emitting when we have found the beginning of the string to replace. + // Emit the part of the string before splitPosition + if(splitPosition > 0) { + var nodeStart = new SourceNode( + mapping.line, + originalColumn, + mapping.source, + nodePart, + mapping.name + ); + output.push(nodeStart); + } + + // Emit the replacement value + if(replace.value) { + output.push(new SourceNode( + mapping.line, + mapping.column, + mapping.source, + replace.value, + mapping.name || replace.name + )); + } + } + + // Recurse with remainder of the string as there may be multiple replaces within a single node + node = node.substr(splitPosition); + position += splitPosition; + } while (true); + } +} + +class ReplacementEnumerator { + /** + * @param {Replacement[]} replacements list of replacements + */ + constructor(replacements) { + this.replacements = replacements || []; + this.index = this.replacements.length; + this.done = false; + this.emit = false; + // Set initial start position + this.next(); + } + + next() { + if(this.done) + return true; + if(this.emit) { + // Start point found. stop emitting. set position to find end + var repl = this.replacements[this.index]; + var end = Math.floor(repl.end + 1); + this.position = end; + this.value = repl.content; + this.name = repl.name; + } else { + // End point found. start emitting. set position to find next start + this.index--; + if(this.index < 0) { + this.done = true; + } else { + var nextRepl = this.replacements[this.index]; + var start = Math.floor(nextRepl.start); + this.position = start; + } + } + if(this.position < 0) + this.position = 0; + this.emit = !this.emit; + return this.emit; + } + + footer() { + if(!this.done && !this.emit) + this.next(); // If we finished _replaceInNode mid emit we advance to next entry + if(this.done) { + return []; + } else { + var resultStr = ""; + for(var i = this.index; i >= 0; i--) { + var repl = this.replacements[i]; + // this doesn't need to handle repl.name, because in SourceMaps generated code + // without pointer to original source can't have a name + resultStr += repl.content; + } + return resultStr; + } + } +} + +require("./SourceAndMapMixin")(ReplaceSource.prototype); + +module.exports = ReplaceSource; -- cgit v1.2.3