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/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 ++ 11 files changed, 713 insertions(+) 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 (limited to 'node_modules/webpack-sources/lib') 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"); -- cgit v1.2.3