From de98e0b232509d5f40c135d540a70e415272ff85 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 3 May 2017 15:35:00 +0200 Subject: node_modules --- node_modules/webpack-sources/README.md | 219 +++++++++++++++++++++ node_modules/webpack-sources/lib/CachedSource.js | 70 +++++++ node_modules/webpack-sources/lib/ConcatSource.js | 63 ++++++ .../webpack-sources/lib/LineToLineMappedSource.js | 48 +++++ node_modules/webpack-sources/lib/OriginalSource.js | 88 +++++++++ node_modules/webpack-sources/lib/PrefixSource.js | 74 +++++++ node_modules/webpack-sources/lib/RawSource.js | 36 ++++ node_modules/webpack-sources/lib/ReplaceSource.js | 192 ++++++++++++++++++ node_modules/webpack-sources/lib/Source.js | 36 ++++ .../webpack-sources/lib/SourceAndMapMixin.js | 36 ++++ .../webpack-sources/lib/SourceMapSource.js | 55 ++++++ node_modules/webpack-sources/lib/index.js | 15 ++ node_modules/webpack-sources/package.json | 49 +++++ 13 files changed, 981 insertions(+) create mode 100644 node_modules/webpack-sources/README.md create mode 100644 node_modules/webpack-sources/lib/CachedSource.js create mode 100644 node_modules/webpack-sources/lib/ConcatSource.js create mode 100644 node_modules/webpack-sources/lib/LineToLineMappedSource.js create mode 100644 node_modules/webpack-sources/lib/OriginalSource.js create mode 100644 node_modules/webpack-sources/lib/PrefixSource.js create mode 100644 node_modules/webpack-sources/lib/RawSource.js create mode 100644 node_modules/webpack-sources/lib/ReplaceSource.js create mode 100644 node_modules/webpack-sources/lib/Source.js create mode 100644 node_modules/webpack-sources/lib/SourceAndMapMixin.js create mode 100644 node_modules/webpack-sources/lib/SourceMapSource.js create mode 100644 node_modules/webpack-sources/lib/index.js create mode 100644 node_modules/webpack-sources/package.json (limited to 'node_modules/webpack-sources') diff --git a/node_modules/webpack-sources/README.md b/node_modules/webpack-sources/README.md new file mode 100644 index 000000000..27c87b920 --- /dev/null +++ b/node_modules/webpack-sources/README.md @@ -0,0 +1,219 @@ +# webpack-sources + +Contains multiple classes which represent a `Source`. A `Source` can be asked for source code, size, source map and hash. + +## `Source` + +Base class for all sources. + +### Public methods + +All methods should be considered as expensive as they may need to do computations. + +#### `source` + +``` js +Source.prototype.source() -> String +``` + +Returns the represented source code as string. + +#### `size` + +``` js +Source.prototype.size() -> Number +``` + +Returns the size in chars of the represented source code. + +#### `map` + +``` js +Source.prototype.map(options: Object) -> Object | null +``` + +Returns the SourceMap of the represented source code as JSON. May return `null` if no SourceMap is available. + +The `options` object can contain the following keys: + +* `columns: Boolean` (default `true`): If set to false the implementation may omit mappings for columns. +* `module: Boolean` (default `true`): If set to false the implementation may omit inner mappings for modules. + +#### `sourceAndMap` + +``` js +Source.prototype.sourceAndMap(options: Object) -> { + code: String, + map: Object +} +``` + +Returns both, source code (like `Source.prototype.source()` and SourceMap (like `Source.prototype.map()`). This method could have better performance than calling `source()` and `map()` separatly. + +See `map()` for `options`. + +#### `updateHash` + +``` js +Source.prototype.updateHash(hash: Hash) -> void +``` + +Updates the provided `Hash` object with the content of the represented source code. (`Hash` is an object with an `update` method, which is called with string values) + +#### `node` (optional) + +``` js +Source.prototype.node(options: Object) -> SourceNode +``` + +This is an optional method. It may be `null` if not implemented. + +Returns a `SourceNode` (see source-map library) for the represented source code. + +See `map()` for `options`. + +#### `listNode` (optional) + +``` js +Source.prototype.listNode(options: Object) -> SourceNode +``` + +This is an optional method. It may be `null` if not implemented. + +Returns a `SourceListMap` (see source-list-map library) for the represented source code. + +See `map()` for `options`. + +## `RawSource` + +Represents source code without SourceMap. + +``` js +new RawSource(sourceCode: String) +``` + +## `OriginalSource` + +Represents source code, which is a copy of the original file. + +``` js +new OriginalSource( + sourceCode: String, + name: String +) +``` + +* `sourceCode`: The source code. +* `name`: The filename of the original source code. + +OriginalSource tries to create column mappings if requested, by splitting the source code at typical statement borders (`;`, `{`, `}`). + +## `SourceMapSource` + +Represents source code with SourceMap, optionally having an additional SourceMap for the original source. + +``` js +new SourceMapSource( + sourceCode: String, + name: String, + sourceMap: Object | String, + originalSource?: String, + innerSourceMap?: Object | String +) +``` + +* `sourceCode`: The source code. +* `name`: The filename of the original source code. +* `sourceMap`: The SourceMap for the source code. +* `originalSource`: The source code of the original file. Can be omitted if the `sourceMap` already contains the original source code. +* `innerSourceMap`: The SourceMap for the `originalSource`/`name`. + +## `LineToLineMappedSource` + +Represents source code, which is mapped line by line to the orginal file. + +``` js +new LineToLineMappedSource( + sourceCode: String, + name: String, + originalSource: String +) +``` + +* `sourceCode`: The source code. +* `name`: The filename of the original source code. +* `originalSource`: The original source code. + +## `CachedSource` + +Decorates a `Source` and caches returned results of `map`, `source`, `size` and `sourceAndMap` in memory. Every other operation is delegated to the wrapped `Source`. + +``` js +new CachedSource(source: Source) +``` + +## `PrefixSource` + +Prefix every line of the decorated `Source` with a provided string. + +``` js +new PrefixSource( + prefix: String, + source: Source +) +``` + +## `ConcatSource` + +Concatenate mulitple `Source`s or strings to a single source. + +``` js +new ConcatSource( + ...items?: Source | String +) +``` + +### Public methods + +#### `add` + +``` js +ConcatSource.prototype.add(item: Source | String) +``` + +Adds an item to the source. + +## `ReplaceSource` + +Decorates a `Source` with replacements and insertions of source code. + +### Public methods + +#### `replace` + +``` js +ReplaceSource.prototype.replace( + start: Number, + end: Number, + replacement: String +) +``` + +Replaces chars from `start` (0-indexed, inclusive) to `end` (0-indexed, inclusive) with `replacement`. + +Locations represents locations in the original source and are not influenced by other replacements or insertions. + +#### `insert` + +``` js +ReplaceSource.prototype.insert( + pos: Number, + insertion: String +) +``` + +Inserts the `insertion` before char `pos` (0-indexed). + +Location represents location in the original source and is not influenced by other replacements or insertions. + + diff --git a/node_modules/webpack-sources/lib/CachedSource.js b/node_modules/webpack-sources/lib/CachedSource.js new file mode 100644 index 000000000..50732aebd --- /dev/null +++ b/node_modules/webpack-sources/lib/CachedSource.js @@ -0,0 +1,70 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function CachedSource(source) { + this._source = source; + this._cachedSource = undefined; + this._cachedSize = undefined; + this._cachedMaps = {}; + + if(source.node) this.node = function(options) { + return this._source.node(options); + }; + + if(source.listMap) this.listMap = function(options) { + return this._source.listMap(options); + }; +} +module.exports = CachedSource; + +CachedSource.prototype.source = function() { + if(typeof this._cachedSource !== "undefined") return this._cachedSource; + return this._cachedSource = this._source.source(); +}; + +CachedSource.prototype.size = function() { + if(typeof this._cachedSize !== "undefined") return this._cachedSize; + if(typeof this._cachedSource !== "undefined") + return this._cachedSize = this._cachedSource.length; + return this._cachedSize = this._source.size(); +}; + +CachedSource.prototype.sourceAndMap = function(options) { + var key = JSON.stringify(options); + if(typeof this._cachedSource !== "undefined" && key in this._cachedMaps) + return { + source: this._cachedSource, + map: this._cachedMaps[key] + }; + else if(typeof this._cachedSource !== "undefined") { + return { + source: this._cachedSource, + map: this._cachedMaps[key] = this._source.map(options) + }; + } else if(key in this._cachedMaps) { + return { + source: this._cachedSource = this._source.source(), + map: this._cachedMaps[key] + }; + } + var result = this._source.sourceAndMap(options); + this._cachedSource = result.source; + this._cachedMaps[key] = result.map; + return { + source: this._cachedSource, + map: this._cachedMaps[key] + }; +}; + +CachedSource.prototype.map = function(options) { + if(!options) options = {}; + var key = JSON.stringify(options); + if(key in this._cachedMaps) + return this._cachedMaps[key]; + return this._cachedMaps[key] = this._source.map(); +}; + +CachedSource.prototype.updateHash = function(hash) { + this._source.updateHash(hash); +}; diff --git a/node_modules/webpack-sources/lib/ConcatSource.js b/node_modules/webpack-sources/lib/ConcatSource.js new file mode 100644 index 000000000..434aa3e5c --- /dev/null +++ b/node_modules/webpack-sources/lib/ConcatSource.js @@ -0,0 +1,63 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var SourceNode = require("source-map").SourceNode; +var SourceListMap = require("source-list-map").SourceListMap; +var Source = require("./Source"); + +function ConcatSource() { + Source.call(this); + this.children = Array.prototype.slice.call(arguments); +} +module.exports = ConcatSource; + +ConcatSource.prototype = Object.create(Source.prototype); +ConcatSource.prototype.constructor = ConcatSource; + +ConcatSource.prototype.add = function(item) { + this.children.push(item); +}; + +ConcatSource.prototype.source = function() { + return this.children.map(function(item) { + return typeof item === "string" ? item : item.source(); + }).join(""); +}; + +ConcatSource.prototype.size = function() { + return this.children.map(function(item) { + return typeof item === "string" ? item.length : item.size(); + }).reduce(function(sum, s) { + return sum + s; + }, 0); +}; + +require("./SourceAndMapMixin")(ConcatSource.prototype); + +ConcatSource.prototype.node = function(options) { + var node = new SourceNode(null, null, null, this.children.map(function(item) { + return typeof item === "string" ? item : item.node(options); + })); + return node; +}; + +ConcatSource.prototype.listMap = function(options) { + var map = new SourceListMap(); + this.children.forEach(function(item) { + if(typeof item === "string") + map.add(item); + else + map.add(item.listMap(options)); + }); + return map; +}; + +ConcatSource.prototype.updateHash = function(hash) { + this.children.forEach(function(item) { + if(typeof item === "string") + hash.update(item); + else + item.updateHash(hash); + }); +}; diff --git a/node_modules/webpack-sources/lib/LineToLineMappedSource.js b/node_modules/webpack-sources/lib/LineToLineMappedSource.js new file mode 100644 index 000000000..bca32cd73 --- /dev/null +++ b/node_modules/webpack-sources/lib/LineToLineMappedSource.js @@ -0,0 +1,48 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var SourceNode = require("source-map").SourceNode; +var SourceMapConsumer = require("source-map").SourceMapConsumer; +var SourceListMap = require("source-list-map").SourceListMap; +var Source = require("./Source"); + +function LineToLineMappedSource(value, name, originalSource) { + Source.call(this); + this._value = value; + this._name = name; + this._originalSource = originalSource; +} + +module.exports = LineToLineMappedSource; + +LineToLineMappedSource.prototype = Object.create(Source.prototype); +LineToLineMappedSource.prototype.constructor = LineToLineMappedSource; + +LineToLineMappedSource.prototype.source = function() { + return this._value; +}; + +require("./SourceAndMapMixin")(LineToLineMappedSource.prototype); + +LineToLineMappedSource.prototype.node = function(options) { + var value = this._value; + var name = this._name; + var lines = value.split("\n"); + var node = new SourceNode(null, null, null, + lines.map(function(line, idx) { + return new SourceNode(idx + 1, 0, name, (line + (idx != lines.length - 1 ? "\n" : ""))); + }) + ); + node.setSourceContent(name, this._originalSource); + return node; +}; + +LineToLineMappedSource.prototype.listMap = function(options) { + return new SourceListMap(this._value, this._name, this._originalSource) +}; + +LineToLineMappedSource.prototype.updateHash = function(hash) { + hash.update(this._value); + hash.update(this._originalSource); +}; diff --git a/node_modules/webpack-sources/lib/OriginalSource.js b/node_modules/webpack-sources/lib/OriginalSource.js new file mode 100644 index 000000000..ac80db8a2 --- /dev/null +++ b/node_modules/webpack-sources/lib/OriginalSource.js @@ -0,0 +1,88 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var SourceNode = require("source-map").SourceNode; +var SourceMapConsumer = require("source-map").SourceMapConsumer; +var SourceListMap = require("source-list-map").SourceListMap; +var Source = require("./Source"); + +function isSplitter(c) { + switch(c) { + case 10: // \n + case 13: // \r + case 59: // ; + case 123: // { + case 125: // } + return true; + } + return false; +} + +function _splitCode(code) { + var result = []; + var i = 0; + var j = 0; + for(; i < code.length; i++) { + if(isSplitter(code.charCodeAt(i))) { + while(isSplitter(code.charCodeAt(++i))); + result.push(code.substring(j, i)); + j = i; + } + } + if(j < code.length) + result.push(code.substr(j)); + return result; +} + +function OriginalSource(value, name) { + Source.call(this); + this._value = value; + this._name = name; +} + +module.exports = OriginalSource; + +OriginalSource.prototype = Object.create(Source.prototype); +OriginalSource.prototype.constructor = OriginalSource; + +OriginalSource.prototype.source = function() { + return this._value; +}; + +require("./SourceAndMapMixin")(OriginalSource.prototype); + +OriginalSource.prototype.node = function(options) { + options = options || {}; + var sourceMap = this._sourceMap; + var value = this._value; + var name = this._name; + var lines = value.split("\n"); + var node = new SourceNode(null, null, null, + lines.map(function(line, idx) { + var pos = 0; + if(options.columns === false) { + var content = line + (idx != lines.length - 1 ? "\n" : ""); + return new SourceNode(idx + 1, 0, name, content); + } + return new SourceNode(null, null, null, + _splitCode(line + (idx != lines.length - 1 ? "\n" : "")).map(function(item) { + if(/^\s*$/.test(item)) return item; + var res = new SourceNode(idx + 1, pos, name, item); + pos += item.length; + return res; + }) + ); + }) + ); + node.setSourceContent(name, value); + return node; +}; + +OriginalSource.prototype.listMap = function(options) { + return new SourceListMap(this._value, this._name, this._value) +}; + +OriginalSource.prototype.updateHash = function(hash) { + hash.update(this._value); +}; diff --git a/node_modules/webpack-sources/lib/PrefixSource.js b/node_modules/webpack-sources/lib/PrefixSource.js new file mode 100644 index 000000000..4ea819c45 --- /dev/null +++ b/node_modules/webpack-sources/lib/PrefixSource.js @@ -0,0 +1,74 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Source = require("./Source"); +var SourceNode = require("source-map").SourceNode; + +var REPLACE_REGEX = /\n(?=.|\s)/g + +function PrefixSource(prefix, source) { + Source.call(this); + this._source = source; + this._prefix = prefix; +} +module.exports = PrefixSource; + +PrefixSource.prototype = Object.create(Source.prototype); +PrefixSource.prototype.constructor = PrefixSource; + +PrefixSource.prototype.source = function() { + var node = typeof this._source === "string" ? this._source : this._source.source(); + var prefix = this._prefix; + return prefix + node.replace(REPLACE_REGEX, "\n" + prefix); +}; + +require("./SourceAndMapMixin")(PrefixSource.prototype); + +PrefixSource.prototype.node = function(options) { + var node = this._source.node(options); + var append = [this._prefix]; + return new SourceNode(null, null, null, [ + cloneAndPrefix(node, this._prefix, append) + ]); +}; + +PrefixSource.prototype.listMap = function(options) { + var prefix = this._prefix; + var map = this._source.listMap(options); + return map.mapGeneratedCode(function(code) { + return prefix + code.replace(REPLACE_REGEX, "\n" + prefix); + }); +}; + +PrefixSource.prototype.updateHash = function(hash) { + if(typeof this._source === "string") + hash.update(this._source); + else + this._source.updateHash(hash); + if(typeof this._prefix === "string") + hash.update(this._prefix); + else + this._prefix.updateHash(hash); +}; + +function cloneAndPrefix(node, prefix, append) { + if(typeof node === "string") { + var result = node.replace(REPLACE_REGEX, "\n" + prefix); + if(append.length > 0) result = append.pop() + result; + if(/\n$/.test(node)) append.push(prefix); + return result; + } else { + var newNode = new SourceNode( + node.line, + node.column, + node.source, + node.children.map(function(node) { + return cloneAndPrefix(node, prefix, append); + }), + node.name + ); + newNode.sourceContents = node.sourceContents; + return newNode; + } +}; diff --git a/node_modules/webpack-sources/lib/RawSource.js b/node_modules/webpack-sources/lib/RawSource.js new file mode 100644 index 000000000..0b9763938 --- /dev/null +++ b/node_modules/webpack-sources/lib/RawSource.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Source = require("./Source"); +var SourceNode = require("source-map").SourceNode; +var SourceListMap = require("source-list-map").SourceListMap; + +function RawSource(value) { + Source.call(this); + this._value = value; +} +module.exports = RawSource; + +RawSource.prototype = Object.create(Source.prototype); +RawSource.prototype.constructor = RawSource; + +RawSource.prototype.source = function() { + return this._value; +}; + +RawSource.prototype.map = function(options) { + return null; +}; + +RawSource.prototype.node = function(options) { + return new SourceNode(null, null, null, this._value); +}; + +RawSource.prototype.listMap = function(options) { + return new SourceListMap(this._value); +}; + +RawSource.prototype.updateHash = function(hash) { + hash.update(this._value); +}; diff --git a/node_modules/webpack-sources/lib/ReplaceSource.js b/node_modules/webpack-sources/lib/ReplaceSource.js new file mode 100644 index 000000000..63087d6de --- /dev/null +++ b/node_modules/webpack-sources/lib/ReplaceSource.js @@ -0,0 +1,192 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Source = require("./Source"); +var SourceNode = require("source-map").SourceNode; +var SourceListMap = require("source-list-map").SourceListMap; +var fromStringWithSourceMap = require("source-list-map").fromStringWithSourceMap; +var SourceMapConsumer = require("source-map").SourceMapConsumer; + +function ReplaceSource(source, name) { + Source.call(this); + this._source = source; + this._name = name; + this.replacements = []; +} +module.exports = ReplaceSource; + +ReplaceSource.prototype = Object.create(Source.prototype); +ReplaceSource.prototype.constructor = ReplaceSource; + +ReplaceSource.prototype.replace = function(start, end, newValue) { + if(typeof newValue !== "string") + throw new Error("insertion must be a string, but is a " + typeof newValue); + this.replacements.push([start, end, newValue, this.replacements.length]); +}; + +ReplaceSource.prototype.insert = function(pos, newValue) { + if(typeof newValue !== "string") + throw new Error("insertion must be a string, but is a " + typeof newValue + ": " + newValue); + this.replacements.push([pos, pos - 1, newValue, this.replacements.length]); +}; + +ReplaceSource.prototype.source = function(options) { + return this._replaceString(this._source.source()); +}; + +ReplaceSource.prototype._sortReplacements = function() { + this.replacements.sort(function(a, b) { + var diff = b[1] - a[1]; + if(diff !== 0) + return diff; + diff = b[0] - a[0]; + if(diff !== 0) + return diff; + return b[3] - a[3]; + }); +}; + +ReplaceSource.prototype._replaceString = function(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[1] + 1)); + var splitted2 = this._splitString(splitted1[0], Math.floor(repl[0])); + result.push(splitted1[1], repl[2], splitted2[0]); + }, this); + result = result.reverse(); + return result.join(""); +}; + +require("./SourceAndMapMixin")(ReplaceSource.prototype); + +ReplaceSource.prototype.node = function(options) { + this._sortReplacements(); + var result = [this._source.node(options)]; + this.replacements.forEach(function(repl) { + var remSource = result.pop(); + var splitted1 = this._splitSourceNode(remSource, Math.floor(repl[1] + 1)); + var splitted2; + if(Array.isArray(splitted1)) { + splitted2 = this._splitSourceNode(splitted1[0], Math.floor(repl[0])); + if(Array.isArray(splitted2)) { + result.push(splitted1[1], this._replacementToSourceNode(splitted2[1], repl[2]), splitted2[0]); + } else { + result.push(splitted1[1], this._replacementToSourceNode(splitted1[1], repl[2]), splitted1[0]); + } + } else { + splitted2 = this._splitSourceNode(remSource, Math.floor(repl[0])); + if(Array.isArray(splitted2)) { + result.push(this._replacementToSourceNode(splitted2[1], repl[2]), splitted2[0]); + } else { + result.push(repl[2], remSource); + } + } + }, this); + result = result.reverse(); + return new SourceNode(null, null, null, result); +}; + +ReplaceSource.prototype.listMap = function(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][0] < newCurrentIndex) { + var repl = replacements[idxReplacement]; + var start = Math.floor(repl[0]); + var end = Math.floor(repl[1] + 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[2]; + str = after; + currentIndex = Math.max(currentIndex, end); + } else { + finalStr += before + repl[2]; + str = ""; + removeChars = end - newCurrentIndex; + } + idxReplacement--; + } + str = finalStr + str; + } + currentIndex = newCurrentIndex; + return str; + }); + var extraCode = ""; + while(idxReplacement >= 0) { + extraCode += replacements[idxReplacement][2]; + idxReplacement--; + } + if(extraCode) { + map.add(extraCode); + } + return map; +}; + +ReplaceSource.prototype._replacementToSourceNode = function(oldNode, newString) { + var map = oldNode.toStringWithSourceMap({ + file: "?" + }).map; + var original = new SourceMapConsumer(map.toJSON()).originalPositionFor({ + line: 1, + column: 0 + }); + if(original) { + return new SourceNode(original.line, original.column, original.source, newString); + } else { + return newString; + } +}; + +ReplaceSource.prototype._splitSourceNode = function(node, position) { + if(typeof node === "string") { + if(node.length <= position) return position - node.length; + return position <= 0 ? ["", node] : [node.substr(0, position), node.substr(position)]; + } else { + for(var i = 0; i < node.children.length; i++) { + position = this._splitSourceNode(node.children[i], position); + if(Array.isArray(position)) { + var leftNode = new SourceNode( + node.line, + node.column, + node.source, + node.children.slice(0, i).concat([position[0]]), + node.name + ); + var rightNode = new SourceNode( + node.line, + node.column, + node.source, [position[1]].concat(node.children.slice(i + 1)), + node.name + ); + leftNode.sourceContents = node.sourceContents; + return [leftNode, rightNode]; + } + } + return position; + } +}; + +ReplaceSource.prototype._splitString = function(str, position) { + return position <= 0 ? ["", str] : [str.substr(0, position), str.substr(position)]; +}; diff --git a/node_modules/webpack-sources/lib/Source.js b/node_modules/webpack-sources/lib/Source.js new file mode 100644 index 000000000..1c729fcf1 --- /dev/null +++ b/node_modules/webpack-sources/lib/Source.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var SourceNode = require("source-map").SourceNode; +var SourceMapConsumer = require("source-map").SourceMapConsumer; + +function Source() {} + +module.exports = Source; + +Source.prototype.source = null; + +Source.prototype.size = function() { + return this.source().length; +}; + +Source.prototype.map = function(options) { + return null; +}; + +Source.prototype.sourceAndMap = function(options) { + return { + source: this.source(), + map: this.map() + }; +}; + +Source.prototype.node = null; + +Source.prototype.listNode = null; + +Source.prototype.updateHash = function(hash) { + var source = this.source(); + hash.update(source || ""); +}; diff --git a/node_modules/webpack-sources/lib/SourceAndMapMixin.js b/node_modules/webpack-sources/lib/SourceAndMapMixin.js new file mode 100644 index 000000000..e677c6235 --- /dev/null +++ b/node_modules/webpack-sources/lib/SourceAndMapMixin.js @@ -0,0 +1,36 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function mixinSourceAndMap(proto) { + proto.map = function(options) { + options = options || {}; + if(options.columns === false) { + return this.listMap(options).toStringWithSourceMap({ + file: "x" + }).map; + } + + return this.node(options).toStringWithSourceMap({ + file: "x" + }).map.toJSON(); + }; + + proto.sourceAndMap = function(options) { + options = options || {}; + if(options.columns === false) { + //console.log(this.listMap(options).debugInfo()); + return this.listMap(options).toStringWithSourceMap({ + file: "x" + }); + } + + var res = this.node(options).toStringWithSourceMap({ + file: "x" + }); + return { + source: res.code, + map: res.map.toJSON() + }; + }; +} diff --git a/node_modules/webpack-sources/lib/SourceMapSource.js b/node_modules/webpack-sources/lib/SourceMapSource.js new file mode 100644 index 000000000..3a7e75a47 --- /dev/null +++ b/node_modules/webpack-sources/lib/SourceMapSource.js @@ -0,0 +1,55 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var SourceNode = require("source-map").SourceNode; +var SourceMapConsumer = require("source-map").SourceMapConsumer; +var SourceMapGenerator = require("source-map").SourceMapGenerator; +var SourceListMap = require("source-list-map").SourceListMap; +var fromStringWithSourceMap = require("source-list-map").fromStringWithSourceMap; +var Source = require("./Source"); + +function SourceMapSource(value, name, sourceMap, originalSource, innerSourceMap) { + Source.call(this); + this._value = value; + this._name = name; + this._sourceMap = sourceMap; + this._originalSource = originalSource; + this._innerSourceMap = innerSourceMap; +} +module.exports = SourceMapSource; + +SourceMapSource.prototype = Object.create(Source.prototype); +SourceMapSource.prototype.constructor = SourceMapSource; + +SourceMapSource.prototype.source = function() { + return this._value; +}; + +require("./SourceAndMapMixin")(SourceMapSource.prototype); + +SourceMapSource.prototype.node = function(options) { + var innerSourceMap = this._innerSourceMap; + var sourceMap = this._sourceMap; + if(innerSourceMap) { + sourceMap = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(sourceMap)); + if(this._originalSource) + sourceMap.setSourceContent(this._name, this._originalSource); + innerSourceMap = new SourceMapConsumer(innerSourceMap); + sourceMap.applySourceMap(innerSourceMap, this._name); + sourceMap = sourceMap.toJSON(); + } + return SourceNode.fromStringWithSourceMap(this._value, new SourceMapConsumer(sourceMap)); +}; + +SourceMapSource.prototype.listMap = function(options) { + if(options.module === false) + return new SourceListMap(this._value, this._name, this._value); + return fromStringWithSourceMap(this._value, typeof this._sourceMap === "string" ? JSON.parse(this._sourceMap) : this._sourceMap); +}; + +SourceMapSource.prototype.updateHash = function(hash) { + hash.update(this._value); + if(this._originalSource) + hash.update(this._originalSource); +}; diff --git a/node_modules/webpack-sources/lib/index.js b/node_modules/webpack-sources/lib/index.js new file mode 100644 index 000000000..0141d3589 --- /dev/null +++ b/node_modules/webpack-sources/lib/index.js @@ -0,0 +1,15 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +exports.Source = require("./Source"); + +exports.RawSource = require("./RawSource"); +exports.OriginalSource = require("./OriginalSource"); +exports.SourceMapSource = require("./SourceMapSource"); +exports.LineToLineMappedSource = require("./LineToLineMappedSource"); + +exports.CachedSource = require("./CachedSource"); +exports.ConcatSource = require("./ConcatSource"); +exports.ReplaceSource = require("./ReplaceSource"); +exports.PrefixSource = require("./PrefixSource"); diff --git a/node_modules/webpack-sources/package.json b/node_modules/webpack-sources/package.json new file mode 100644 index 000000000..e5d6c4634 --- /dev/null +++ b/node_modules/webpack-sources/package.json @@ -0,0 +1,49 @@ +{ + "name": "webpack-sources", + "version": "0.2.3", + "description": "Source code handling classes for webpack", + "main": "./lib/index.js", + "scripts": { + "pretest": "npm run lint && npm run beautify-lint", + "test": "mocha --full-trace --check-leaks", + "travis": "npm run cover -- --report lcovonly", + "lint": "eslint lib test", + "beautify-lint": "beautify-lint lib/**.js test/**.js", + "beautify": "beautify-rewrite lib/**.js test/**.js", + "precover": "npm run lint && npm run beautify-lint", + "cover": "istanbul cover node_modules/mocha/bin/_mocha", + "publish-patch": "npm test && npm version patch && git push && git push --tags && npm publish" + }, + "dependencies": { + "source-map": "~0.5.3", + "source-list-map": "^1.1.1" + }, + "devDependencies": { + "beautify-lint": "^1.0.3", + "codecov.io": "^0.1.6", + "coveralls": "^2.11.6", + "eslint": "^1.1.0", + "eslint-plugin-nodeca": "^1.0.3", + "istanbul": "^0.4.1", + "js-beautify": "^1.5.10", + "mocha": "^2.3.4", + "should": "^8.0.2" + }, + "files": [ + "lib/" + ], + "repository": { + "type": "git", + "url": "git+https://github.com/webpack/webpack-sources.git" + }, + "keywords": [ + "webpack", + "source-map" + ], + "author": "Tobias Koppers @sokra", + "license": "MIT", + "bugs": { + "url": "https://github.com/webpack/webpack-sources/issues" + }, + "homepage": "https://github.com/webpack/webpack-sources#readme" +} -- cgit v1.2.3