diff options
| author | Florian Dold <florian.dold@gmail.com> | 2017-05-03 15:35:00 +0200 |
|---|---|---|
| committer | Florian Dold <florian.dold@gmail.com> | 2017-05-03 15:35:00 +0200 |
| commit | de98e0b232509d5f40c135d540a70e415272ff85 (patch) | |
| tree | a79222a5b58484ab3b80d18efcaaa7ccc4769b33 /node_modules/webpack/lib/dependencies | |
| parent | e0c9d480a73fa629c1e4a47d3e721f1d2d345406 (diff) | |
node_modules
Diffstat (limited to 'node_modules/webpack/lib/dependencies')
76 files changed, 3891 insertions, 0 deletions
diff --git a/node_modules/webpack/lib/dependencies/AMDDefineDependency.js b/node_modules/webpack/lib/dependencies/AMDDefineDependency.js new file mode 100644 index 000000000..7d81ec123 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDDefineDependency.js @@ -0,0 +1,142 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class AMDDefineDependency extends NullDependency {
+ constructor(range, arrayRange, functionRange, objectRange, namedModule) {
+ super();
+ this.range = range;
+ this.arrayRange = arrayRange;
+ this.functionRange = functionRange;
+ this.objectRange = objectRange;
+ this.namedModule = namedModule;
+ }
+
+ get type() {
+ return "amd define";
+ }
+}
+
+AMDDefineDependency.Template = class AMDDefineDependencyTemplate {
+ get definitions() {
+ return {
+ f: [
+ "var __WEBPACK_AMD_DEFINE_RESULT__;",
+ `!(__WEBPACK_AMD_DEFINE_RESULT__ = #.call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`
+ ],
+ o: [
+ "",
+ "!(module.exports = #)"
+ ],
+ of: [
+ "var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+ `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+ __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+ (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
+ __WEBPACK_AMD_DEFINE_FACTORY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`
+ ],
+ af: [
+ "var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+ `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_RESULT__ = #.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`
+ ],
+ ao: [
+ "",
+ "!(#, module.exports = #)"
+ ],
+ aof: [
+ "var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+ `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+ __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+ (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`
+ ],
+ lf: [
+ "var XXX, XXXmodule;",
+ "!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = #.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))"
+ ],
+ lo: [
+ "var XXX;",
+ "!(XXX = #)"
+ ],
+ lof: [
+ "var XXX, XXXfactory, XXXmodule;",
+ "!(XXXfactory = (#), (XXXmodule = { id: YYY, exports: {}, loaded: false }), XXX = (typeof XXXfactory === 'function' ? (XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)) : XXXfactory), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports))"
+ ],
+ laf: [
+ "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX;",
+ "!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)))"
+ ],
+ lao: [
+ "var XXX;",
+ "!(#, XXX = #)"
+ ],
+ laof: [
+ "var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_FACTORY__, XXX;",
+ `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+ XXX = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+ (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__))`
+ ]
+ };
+ }
+
+ apply(dependency, source) {
+ const branch = this.branch(dependency);
+ const defAndText = this.definitions[branch];
+ const definitions = defAndText[0];
+ const text = defAndText[1];
+ this.replace(dependency, source, definitions, text);
+ }
+
+ localModuleVar(dependency) {
+ return dependency.localModule && dependency.localModule.used && dependency.localModule.variableName();
+ }
+
+ branch(dependency) {
+ const localModuleVar = this.localModuleVar(dependency) ? "l" : "";
+ const arrayRange = dependency.arrayRange ? "a" : "";
+ const objectRange = dependency.objectRange ? "o" : "";
+ const functionRange = dependency.functionRange ? "f" : "";
+ return localModuleVar + arrayRange + objectRange + functionRange;
+ }
+
+ replace(dependency, source, definition, text) {
+ const localModuleVar = this.localModuleVar(dependency);
+ if(localModuleVar) {
+ text = text.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$"));
+ definition = definition.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$"));
+ }
+
+ if(dependency.namedModule) {
+ text = text.replace(/YYY/g, JSON.stringify(dependency.namedModule));
+ }
+
+ const texts = text.split("#");
+
+ if(definition) source.insert(0, definition);
+
+ let current = dependency.range[0];
+ if(dependency.arrayRange) {
+ source.replace(current, dependency.arrayRange[0] - 1, texts.shift());
+ current = dependency.arrayRange[1];
+ }
+
+ if(dependency.objectRange) {
+ source.replace(current, dependency.objectRange[0] - 1, texts.shift());
+ current = dependency.objectRange[1];
+ } else if(dependency.functionRange) {
+ source.replace(current, dependency.functionRange[0] - 1, texts.shift());
+ current = dependency.functionRange[1];
+ }
+ source.replace(current, dependency.range[1] - 1, texts.shift());
+ if(texts.length > 0)
+ throw new Error("Implementation error");
+ }
+};
+
+module.exports = AMDDefineDependency;
diff --git a/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js new file mode 100644 index 000000000..8590162c6 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js @@ -0,0 +1,250 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const ConstDependency = require("./ConstDependency");
+const AMDDefineDependency = require("./AMDDefineDependency");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModulesHelpers = require("./LocalModulesHelpers");
+
+function isBoundFunctionExpression(expr) {
+ if(expr.type !== "CallExpression") return false;
+ if(expr.callee.type !== "MemberExpression") return false;
+ if(expr.callee.computed) return false;
+ if(expr.callee.object.type !== "FunctionExpression") return false;
+ if(expr.callee.property.type !== "Identifier") return false;
+ if(expr.callee.property.name !== "bind") return false;
+ return true;
+}
+
+class AMDDefineDependencyParserPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(parser) {
+ const options = this.options;
+ parser.plugin("call define", (expr) => {
+ let array, fn, obj, namedModule;
+ switch(expr.arguments.length) {
+ case 1:
+ if(expr.arguments[0].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[0])) {
+ // define(f() {...})
+ fn = expr.arguments[0];
+ } else if(expr.arguments[0].type === "ObjectExpression") {
+ // define({...})
+ obj = expr.arguments[0];
+ } else {
+ // define(expr)
+ // unclear if function or object
+ obj = fn = expr.arguments[0];
+ }
+ break;
+ case 2:
+ if(expr.arguments[0].type === "Literal") {
+ namedModule = expr.arguments[0].value;
+ // define("...", ...)
+ if(expr.arguments[1].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[1])) {
+ // define("...", f() {...})
+ fn = expr.arguments[1];
+ } else if(expr.arguments[1].type === "ObjectExpression") {
+ // define("...", {...})
+ obj = expr.arguments[1];
+ } else {
+ // define("...", expr)
+ // unclear if function or object
+ obj = fn = expr.arguments[1];
+ }
+ } else {
+ array = expr.arguments[0];
+ if(expr.arguments[1].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[1])) {
+ // define([...], f() {})
+ fn = expr.arguments[1];
+ } else if(expr.arguments[1].type === "ObjectExpression") {
+ // define([...], {...})
+ obj = expr.arguments[1];
+ } else {
+ // define([...], expr)
+ // unclear if function or object
+ obj = fn = expr.arguments[1];
+ }
+ }
+ break;
+ case 3:
+ // define("...", [...], f() {...})
+ namedModule = expr.arguments[0].value;
+ array = expr.arguments[1];
+ if(expr.arguments[2].type === "FunctionExpression" || isBoundFunctionExpression(expr.arguments[2])) {
+ // define("...", [...], f() {})
+ fn = expr.arguments[2];
+ } else if(expr.arguments[2].type === "ObjectExpression") {
+ // define("...", [...], {...})
+ obj = expr.arguments[2];
+ } else {
+ // define("...", [...], expr)
+ // unclear if function or object
+ obj = fn = expr.arguments[2];
+ }
+ break;
+ default:
+ return;
+ }
+ let fnParams = null;
+ let fnParamsOffset = 0;
+ if(fn) {
+ if(fn.type === "FunctionExpression") fnParams = fn.params;
+ else if(isBoundFunctionExpression(fn)) {
+ fnParams = fn.callee.object.params;
+ fnParamsOffset = fn.arguments.length - 1;
+ if(fnParamsOffset < 0) fnParamsOffset = 0;
+ }
+ }
+ let fnRenames = Object.create(parser.scope.renames);
+ let identifiers;
+ if(array) {
+ identifiers = {};
+ const param = parser.evaluateExpression(array);
+ const result = parser.applyPluginsBailResult("call define:amd:array", expr, param, identifiers, namedModule);
+ if(!result) return;
+ if(fnParams) fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+ if(identifiers[idx]) {
+ fnRenames["$" + param.name] = identifiers[idx];
+ return false;
+ }
+ return true;
+ });
+ } else {
+ identifiers = ["require", "exports", "module"];
+ if(fnParams) fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+ if(identifiers[idx]) {
+ fnRenames["$" + param.name] = identifiers[idx];
+ return false;
+ }
+ return true;
+ });
+ }
+ let inTry;
+ if(fn && fn.type === "FunctionExpression") {
+ inTry = parser.scope.inTry;
+ parser.inScope(fnParams, () => {
+ parser.scope.renames = fnRenames;
+ parser.scope.inTry = inTry;
+ if(fn.body.type === "BlockStatement")
+ parser.walkStatement(fn.body);
+ else
+ parser.walkExpression(fn.body);
+ });
+ } else if(fn && isBoundFunctionExpression(fn)) {
+ inTry = parser.scope.inTry;
+ parser.inScope(fn.callee.object.params.filter((i) => ["require", "module", "exports"].indexOf(i.name) < 0), () => {
+ parser.scope.renames = fnRenames;
+ parser.scope.inTry = inTry;
+ if(fn.callee.object.body.type === "BlockStatement")
+ parser.walkStatement(fn.callee.object.body);
+ else
+ parser.walkExpression(fn.callee.object.body);
+ });
+ if(fn.arguments)
+ parser.walkExpressions(fn.arguments);
+ } else if(fn || obj) {
+ parser.walkExpression(fn || obj);
+ }
+
+ const dep = new AMDDefineDependency(
+ expr.range,
+ array ? array.range : null,
+ fn ? fn.range : null,
+ obj ? obj.range : null,
+ namedModule ? namedModule : null
+ );
+ dep.loc = expr.loc;
+ if(namedModule) {
+ dep.localModule = LocalModulesHelpers.addLocalModule(parser.state, namedModule);
+ }
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("call define:amd:array", (expr, param, identifiers, namedModule) => {
+ if(param.isArray()) {
+ param.items.forEach((param, idx) => {
+ if(param.isString() && ["require", "module", "exports"].indexOf(param.string) >= 0)
+ identifiers[idx] = param.string;
+ const result = parser.applyPluginsBailResult("call define:amd:item", expr, param, namedModule);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call define:amd:context", expr, param);
+ }
+ });
+ return true;
+ } else if(param.isConstArray()) {
+ const deps = [];
+ param.array.forEach((request, idx) => {
+ let dep;
+ let localModule;
+ if(request === "require") {
+ identifiers[idx] = request;
+ dep = "__webpack_require__";
+ } else if(["exports", "module"].indexOf(request) >= 0) {
+ identifiers[idx] = request;
+ dep = request;
+ } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign
+ dep = new LocalModuleDependency(localModule);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ } else {
+ dep = new AMDRequireItemDependency(request);
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ }
+ deps.push(dep);
+ });
+ const dep = new AMDRequireArrayDependency(deps, param.range);
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call define:amd:item", (expr, param, namedModule) => {
+ if(param.isConditional()) {
+ param.options.forEach((param) => {
+ const result = parser.applyPluginsBailResult("call define:amd:item", expr, param);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call define:amd:context", expr, param);
+ }
+ });
+ return true;
+ } else if(param.isString()) {
+ let dep, localModule;
+ if(param.string === "require") {
+ dep = new ConstDependency("__webpack_require__", param.range);
+ } else if(["require", "exports", "module"].indexOf(param.string) >= 0) {
+ dep = new ConstDependency(param.string, param.range);
+ } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string, namedModule)) { // eslint-disable-line no-cond-assign
+ dep = new LocalModuleDependency(localModule, param.range);
+ } else {
+ dep = new AMDRequireItemDependency(param.string, param.range);
+ }
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call define:amd:context", (expr, param) => {
+ const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
+ if(!dep) return;
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+}
+module.exports = AMDDefineDependencyParserPlugin;
diff --git a/node_modules/webpack/lib/dependencies/AMDPlugin.js b/node_modules/webpack/lib/dependencies/AMDPlugin.js new file mode 100644 index 000000000..d1d5cf09e --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDPlugin.js @@ -0,0 +1,119 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const path = require("path");
+const AMDRequireDependency = require("./AMDRequireDependency");
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDDefineDependency = require("./AMDDefineDependency");
+const UnsupportedDependency = require("./UnsupportedDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+
+const NullFactory = require("../NullFactory");
+
+const AMDRequireDependenciesBlockParserPlugin = require("./AMDRequireDependenciesBlockParserPlugin");
+const AMDDefineDependencyParserPlugin = require("./AMDDefineDependencyParserPlugin");
+
+const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
+
+const ParserHelpers = require("../ParserHelpers");
+
+class AMDPlugin {
+ constructor(options, amdOptions) {
+ this.amdOptions = amdOptions;
+ this.options = options;
+ }
+
+ apply(compiler) {
+ const options = this.options;
+ const amdOptions = this.amdOptions;
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+ const contextModuleFactory = params.contextModuleFactory;
+
+ compilation.dependencyFactories.set(AMDRequireDependency, new NullFactory());
+ compilation.dependencyTemplates.set(AMDRequireDependency, new AMDRequireDependency.Template());
+
+ compilation.dependencyFactories.set(AMDRequireItemDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(AMDRequireItemDependency, new AMDRequireItemDependency.Template());
+
+ compilation.dependencyFactories.set(AMDRequireArrayDependency, new NullFactory());
+ compilation.dependencyTemplates.set(AMDRequireArrayDependency, new AMDRequireArrayDependency.Template());
+
+ compilation.dependencyFactories.set(AMDRequireContextDependency, contextModuleFactory);
+ compilation.dependencyTemplates.set(AMDRequireContextDependency, new AMDRequireContextDependency.Template());
+
+ compilation.dependencyFactories.set(AMDDefineDependency, new NullFactory());
+ compilation.dependencyTemplates.set(AMDDefineDependency, new AMDDefineDependency.Template());
+
+ compilation.dependencyFactories.set(UnsupportedDependency, new NullFactory());
+ compilation.dependencyTemplates.set(UnsupportedDependency, new UnsupportedDependency.Template());
+
+ compilation.dependencyFactories.set(LocalModuleDependency, new NullFactory());
+ compilation.dependencyTemplates.set(LocalModuleDependency, new LocalModuleDependency.Template());
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.amd !== "undefined" && !parserOptions.amd)
+ return;
+
+ function setExpressionToModule(outerExpr, module) {
+ parser.plugin("expression " + outerExpr, (expr) => {
+ const dep = new AMDRequireItemDependency(module, expr.range);
+ dep.userRequest = outerExpr;
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+
+ parser.apply(
+ new AMDRequireDependenciesBlockParserPlugin(options),
+ new AMDDefineDependencyParserPlugin(options)
+ );
+ setExpressionToModule("require.amd", "!!webpack amd options");
+ setExpressionToModule("define.amd", "!!webpack amd options");
+ setExpressionToModule("define", "!!webpack amd define");
+ parser.plugin("expression __webpack_amd_options__", () =>
+ parser.state.current.addVariable("__webpack_amd_options__", JSON.stringify(amdOptions)));
+ parser.plugin("evaluate typeof define.amd", ParserHelpers.evaluateToString(typeof amdOptions));
+ parser.plugin("evaluate typeof require.amd", ParserHelpers.evaluateToString(typeof amdOptions));
+ parser.plugin("evaluate Identifier define.amd", ParserHelpers.evaluateToBoolean(true));
+ parser.plugin("evaluate Identifier require.amd", ParserHelpers.evaluateToBoolean(true));
+ parser.plugin("typeof define", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+ parser.plugin("evaluate typeof define", ParserHelpers.evaluateToString("function"));
+ parser.plugin("can-rename define", ParserHelpers.approve);
+ parser.plugin("rename define", (expr) => {
+ const dep = new AMDRequireItemDependency("!!webpack amd define", expr.range);
+ dep.userRequest = "define";
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return false;
+ });
+ parser.plugin("typeof require", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+ parser.plugin("evaluate typeof require", ParserHelpers.evaluateToString("function"));
+ });
+ });
+ compiler.plugin("after-resolvers", () => {
+ compiler.resolvers.normal.apply(
+ new AliasPlugin("described-resolve", {
+ name: "amdefine",
+ alias: path.join(__dirname, "..", "..", "buildin", "amd-define.js")
+ }, "resolve"),
+ new AliasPlugin("described-resolve", {
+ name: "webpack amd options",
+ alias: path.join(__dirname, "..", "..", "buildin", "amd-options.js")
+ }, "resolve"),
+ new AliasPlugin("described-resolve", {
+ name: "webpack amd define",
+ alias: path.join(__dirname, "..", "..", "buildin", "amd-define.js")
+ }, "resolve")
+ );
+ });
+ }
+}
+module.exports = AMDPlugin;
diff --git a/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js new file mode 100644 index 000000000..666a887e3 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js @@ -0,0 +1,56 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+const webpackMissingModuleModule = require("./WebpackMissingModule").module;
+
+class AMDRequireArrayDependency extends Dependency {
+ constructor(depsArray, range) {
+ super();
+ this.depsArray = depsArray;
+ this.range = range;
+ }
+
+ get type() {
+ return "amd require array";
+ }
+}
+
+AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const content = this.getContent(dep, outputOptions, requestShortener);
+ source.replace(dep.range[0], dep.range[1] - 1, content);
+ }
+
+ getContent(dep, outputOptions, requestShortener) {
+ const requires = dep.depsArray.map((dependency) => {
+ const optionalComment = this.optionalComment(outputOptions.pathinfo, requestShortener.shorten(dependency.request));
+ return this.contentForDependency(dependency, optionalComment);
+ });
+ return `[${requires.join(", ")}]`;
+ }
+
+ optionalComment(pathInfo, shortenedRequest) {
+ if(!pathInfo) {
+ return "";
+ }
+ return `/*! ${shortenedRequest} */ `;
+ }
+
+ contentForDependency(dep, comment) {
+ if(typeof dep === "string") {
+ return dep;
+ }
+
+ if(dep.module) {
+ const stringifiedId = JSON.stringify(dep.module.id);
+ return `__webpack_require__(${comment}${stringifiedId})`;
+ }
+
+ return webpackMissingModuleModule(dep.request);
+ }
+};
+
+module.exports = AMDRequireArrayDependency;
diff --git a/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js new file mode 100644 index 000000000..9248927e1 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js @@ -0,0 +1,29 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ContextDependency = require("./ContextDependency");
+const CriticalDependencyWarning = require("./CriticalDependencyWarning");
+class AMDRequireContextDependency extends ContextDependency {
+ constructor(request, recursive, regExp, range, valueRange) {
+ super(request, recursive, regExp);
+ this.range = range;
+ this.valueRange = valueRange;
+ }
+
+ get type() {
+ return "amd require context";
+ }
+
+ getWarnings() {
+ if(this.critical) {
+ return [
+ new CriticalDependencyWarning(this.critical)
+ ];
+ }
+ }
+}
+AMDRequireContextDependency.Template = require("./ContextDependencyTemplateAsRequireCall");
+module.exports = AMDRequireContextDependency;
diff --git a/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js new file mode 100644 index 000000000..92f5299ee --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.js @@ -0,0 +1,33 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const AMDRequireDependency = require("./AMDRequireDependency");
+
+module.exports = class AMDRequireDependenciesBlock extends AsyncDependenciesBlock {
+ constructor(expr, arrayRange, functionRange, errorCallbackRange, module, loc) {
+ super(null, module, loc);
+ this.expr = expr;
+ this.outerRange = expr.range;
+ this.arrayRange = arrayRange;
+ this.functionRange = functionRange;
+ this.errorCallbackRange = errorCallbackRange;
+ this.bindThis = true;
+ if(arrayRange && functionRange && errorCallbackRange) {
+ this.range = [arrayRange[0], errorCallbackRange[1]];
+ } else if(arrayRange && functionRange) {
+ this.range = [arrayRange[0], functionRange[1]];
+ } else if(arrayRange) {
+ this.range = arrayRange;
+ } else if(functionRange) {
+ this.range = functionRange;
+ } else {
+ this.range = expr.range;
+ }
+ const dep = new AMDRequireDependency(this);
+ dep.loc = loc;
+ this.addDependency(dep);
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js new file mode 100644 index 000000000..8bd7ae425 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js @@ -0,0 +1,177 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
+const UnsupportedDependency = require("./UnsupportedDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModulesHelpers = require("./LocalModulesHelpers");
+const ConstDependency = require("./ConstDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+
+class AMDRequireDependenciesBlockParserPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ processFunctionArgument(parser, expression) {
+ let bindThis = true;
+ const fnData = getFunctionExpression(expression);
+ if(fnData) {
+ parser.inScope(fnData.fn.params.filter((i) => {
+ return ["require", "module", "exports"].indexOf(i.name) < 0;
+ }), () => {
+ if(fnData.fn.body.type === "BlockStatement")
+ parser.walkStatement(fnData.fn.body);
+ else
+ parser.walkExpression(fnData.fn.body);
+ });
+ parser.walkExpressions(fnData.expressions);
+ if(fnData.needThis === false) {
+ bindThis = false;
+ }
+ } else {
+ parser.walkExpression(expression);
+ }
+ return bindThis;
+ }
+
+ apply(parser) {
+ const options = this.options;
+ parser.plugin("call require", (expr) => {
+ let param;
+ let dep;
+ let result;
+
+ const old = parser.state.current;
+
+ if(expr.arguments.length >= 1) {
+ param = parser.evaluateExpression(expr.arguments[0]);
+ dep = new AMDRequireDependenciesBlock(
+ expr,
+ param.range,
+ (expr.arguments.length > 1) ? expr.arguments[1].range : null,
+ (expr.arguments.length > 2) ? expr.arguments[2].range : null,
+ parser.state.module,
+ expr.loc
+ );
+ parser.state.current = dep;
+ }
+
+ if(expr.arguments.length === 1) {
+ parser.inScope([], () => {
+ result = parser.applyPluginsBailResult("call require:amd:array", expr, param);
+ });
+ parser.state.current = old;
+ if(!result) return;
+ parser.state.current.addBlock(dep);
+ return true;
+ }
+
+ if(expr.arguments.length === 2 || expr.arguments.length === 3) {
+ try {
+ parser.inScope([], () => {
+ result = parser.applyPluginsBailResult("call require:amd:array", expr, param);
+ });
+ if(!result) {
+ dep = new UnsupportedDependency("unsupported", expr.range);
+ old.addDependency(dep);
+ if(parser.state.module)
+ parser.state.module.errors.push(new UnsupportedFeatureWarning(parser.state.module, "Cannot statically analyse 'require(..., ...)' in line " + expr.loc.start.line));
+ dep = null;
+ return true;
+ }
+ dep.functionBindThis = this.processFunctionArgument(parser, expr.arguments[1]);
+ if(expr.arguments.length === 3) {
+ dep.errorCallbackBindThis = this.processFunctionArgument(parser, expr.arguments[2]);
+ }
+ } finally {
+ parser.state.current = old;
+ if(dep)
+ parser.state.current.addBlock(dep);
+ }
+ return true;
+ }
+ });
+ parser.plugin("call require:amd:array", (expr, param) => {
+ if(param.isArray()) {
+ param.items.forEach((param) => {
+ const result = parser.applyPluginsBailResult("call require:amd:item", expr, param);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call require:amd:context", expr, param);
+ }
+ });
+ return true;
+ } else if(param.isConstArray()) {
+ const deps = [];
+ param.array.forEach((request) => {
+ let dep, localModule;
+ if(request === "require") {
+ dep = "__webpack_require__";
+ } else if(["exports", "module"].indexOf(request) >= 0) {
+ dep = request;
+ } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign
+ dep = new LocalModuleDependency(localModule);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ } else {
+ dep = new AMDRequireItemDependency(request);
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ }
+ deps.push(dep);
+ });
+ const dep = new AMDRequireArrayDependency(deps, param.range);
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call require:amd:item", (expr, param) => {
+ if(param.isConditional()) {
+ param.options.forEach((param) => {
+ const result = parser.applyPluginsBailResult("call require:amd:item", expr, param);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call require:amd:context", expr, param);
+ }
+ });
+ return true;
+ } else if(param.isString()) {
+ let dep, localModule;
+ if(param.string === "require") {
+ dep = new ConstDependency("__webpack_require__", param.string);
+ } else if(param.string === "module") {
+ dep = new ConstDependency(parser.state.module.moduleArgument || "module", param.range);
+ } else if(param.string === "exports") {
+ dep = new ConstDependency(parser.state.module.exportsArgument || "exports", param.range);
+ } else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string)) { // eslint-disable-line no-cond-assign
+ dep = new LocalModuleDependency(localModule, param.range);
+ } else {
+ dep = new AMDRequireItemDependency(param.string, param.range);
+ }
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call require:amd:context", (expr, param) => {
+ const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
+ if(!dep) return;
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+}
+module.exports = AMDRequireDependenciesBlockParserPlugin;
diff --git a/node_modules/webpack/lib/dependencies/AMDRequireDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireDependency.js new file mode 100644 index 000000000..6cfaa2de2 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireDependency.js @@ -0,0 +1,67 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const DepBlockHelpers = require("./DepBlockHelpers");
+
+class AMDRequireDependency extends NullDependency {
+ constructor(block) {
+ super();
+ this.block = block;
+ }
+}
+
+AMDRequireDependency.Template = class AMDRequireDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const depBlock = dep.block;
+ const wrapper = DepBlockHelpers.getLoadDepBlockWrapper(depBlock, outputOptions, requestShortener, "require");
+
+ // has array range but no function range
+ if(depBlock.arrayRange && !depBlock.functionRange) {
+ const startBlock = wrapper[0] + "function() {";
+ const endBlock = `;}${wrapper[1]}__webpack_require__.oe${wrapper[2]}`;
+ source.replace(depBlock.outerRange[0], depBlock.arrayRange[0] - 1, startBlock);
+ source.replace(depBlock.arrayRange[1], depBlock.outerRange[1] - 1, endBlock);
+ return;
+ }
+
+ // has function range but no array range
+ if(depBlock.functionRange && !depBlock.arrayRange) {
+ const startBlock = wrapper[0] + "function() {(";
+ const endBlock = `.call(exports, __webpack_require__, exports, module));}${wrapper[1]}__webpack_require__.oe${wrapper[2]}`;
+ source.replace(depBlock.outerRange[0], depBlock.functionRange[0] - 1, startBlock);
+ source.replace(depBlock.functionRange[1], depBlock.outerRange[1] - 1, endBlock);
+ return;
+ }
+
+ // has array range, function range, and errorCallbackRange
+ if(depBlock.arrayRange && depBlock.functionRange && depBlock.errorCallbackRange) {
+ const startBlock = wrapper[0] + "function() { ";
+ const errorRangeBlock = `}${depBlock.functionBindThis ? ".bind(this)" : ""}${wrapper[1]}`;
+ const endBlock = `${depBlock.errorCallbackBindThis ? ".bind(this)" : ""}${wrapper[2]}`;
+
+ source.replace(depBlock.outerRange[0], depBlock.arrayRange[0] - 1, startBlock);
+ source.insert(depBlock.arrayRange[0] + 0.9, "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+ source.replace(depBlock.arrayRange[1], depBlock.functionRange[0] - 1, "; (");
+ source.insert(depBlock.functionRange[1], ".apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__));");
+ source.replace(depBlock.functionRange[1], depBlock.errorCallbackRange[0] - 1, errorRangeBlock);
+ source.replace(depBlock.errorCallbackRange[1], depBlock.outerRange[1] - 1, endBlock);
+ return;
+ }
+
+ // has array range, function range, but no errorCallbackRange
+ if(depBlock.arrayRange && depBlock.functionRange) {
+ const startBlock = wrapper[0] + "function() { ";
+ const endBlock = `}${depBlock.functionBindThis ? ".bind(this)" : ""}${wrapper[1]}__webpack_require__.oe${wrapper[2]}`;
+ source.replace(depBlock.outerRange[0], depBlock.arrayRange[0] - 1, startBlock);
+ source.insert(depBlock.arrayRange[0] + 0.9, "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+ source.replace(depBlock.arrayRange[1], depBlock.functionRange[0] - 1, "; (");
+ source.insert(depBlock.functionRange[1], ".apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__));");
+ source.replace(depBlock.functionRange[1], depBlock.outerRange[1] - 1, endBlock);
+ }
+ }
+};
+
+module.exports = AMDRequireDependency;
diff --git a/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js b/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js new file mode 100644 index 000000000..60401d533 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js @@ -0,0 +1,22 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+class AMDRequireItemDependency extends ModuleDependency {
+ constructor(request, range) {
+ super(request);
+ this.range = range;
+ }
+
+ get type() {
+ return "amd require";
+ }
+}
+
+AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = AMDRequireItemDependency;
diff --git a/node_modules/webpack/lib/dependencies/CommonJsPlugin.js b/node_modules/webpack/lib/dependencies/CommonJsPlugin.js new file mode 100644 index 000000000..e514fd99e --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsPlugin.js @@ -0,0 +1,88 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ConstDependency = require("./ConstDependency");
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+
+const NullFactory = require("../NullFactory");
+
+const RequireResolveDependencyParserPlugin = require("./RequireResolveDependencyParserPlugin");
+const CommonJsRequireDependencyParserPlugin = require("./CommonJsRequireDependencyParserPlugin");
+
+const ParserHelpers = require("../ParserHelpers");
+
+class CommonJsPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(compiler) {
+ const options = this.options;
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+ const contextModuleFactory = params.contextModuleFactory;
+
+ compilation.dependencyFactories.set(CommonJsRequireDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(CommonJsRequireDependency, new CommonJsRequireDependency.Template());
+
+ compilation.dependencyFactories.set(CommonJsRequireContextDependency, contextModuleFactory);
+ compilation.dependencyTemplates.set(CommonJsRequireContextDependency, new CommonJsRequireContextDependency.Template());
+
+ compilation.dependencyFactories.set(RequireResolveDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(RequireResolveDependency, new RequireResolveDependency.Template());
+
+ compilation.dependencyFactories.set(RequireResolveContextDependency, contextModuleFactory);
+ compilation.dependencyTemplates.set(RequireResolveContextDependency, new RequireResolveContextDependency.Template());
+
+ compilation.dependencyFactories.set(RequireResolveHeaderDependency, new NullFactory());
+ compilation.dependencyTemplates.set(RequireResolveHeaderDependency, new RequireResolveHeaderDependency.Template());
+
+ compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory());
+ compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template());
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.commonjs !== "undefined" && !parserOptions.commonjs)
+ return;
+
+ const requireExpressions = ["require", "require.resolve", "require.resolveWeak"];
+ for(let expression of requireExpressions) {
+ parser.plugin(`typeof ${expression}`, ParserHelpers.toConstantDependency("function"));
+ parser.plugin(`evaluate typeof ${expression}`, ParserHelpers.evaluateToString("function"));
+ }
+
+ parser.plugin("evaluate typeof module", ParserHelpers.evaluateToString("object"));
+ parser.plugin("assign require", (expr) => {
+ // to not leak to global "require", we need to define a local require here.
+ const dep = new ConstDependency("var require;", 0);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ parser.scope.definitions.push("require");
+ return true;
+ });
+ parser.plugin("can-rename require", () => true);
+ parser.plugin("rename require", (expr) => {
+ // define the require variable. It's still undefined, but not "not defined".
+ const dep = new ConstDependency("var require;", 0);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return false;
+ });
+ parser.plugin("typeof module", () => true);
+ parser.plugin("evaluate typeof exports", ParserHelpers.evaluateToString("object"));
+ parser.apply(
+ new CommonJsRequireDependencyParserPlugin(options),
+ new RequireResolveDependencyParserPlugin(options)
+ );
+ });
+ });
+ }
+}
+module.exports = CommonJsPlugin;
diff --git a/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js b/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js new file mode 100644 index 000000000..74822aebd --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js @@ -0,0 +1,34 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ContextDependency = require("./ContextDependency");
+const CriticalDependencyWarning = require("./CriticalDependencyWarning");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class CommonJsRequireContextDependency extends ContextDependency {
+ constructor(request, recursive, regExp, range, valueRange) {
+ super(request, recursive, regExp);
+ this.range = range;
+ this.valueRange = valueRange;
+ }
+
+ get type() {
+ return "cjs require context";
+ }
+
+ getWarnings() {
+ if(!this.critical) {
+ return;
+ }
+
+ return [
+ new CriticalDependencyWarning(this.critical)
+ ];
+ }
+}
+
+CommonJsRequireContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = CommonJsRequireContextDependency;
diff --git a/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js b/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js new file mode 100644 index 000000000..bd9e68e46 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js @@ -0,0 +1,22 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+class CommonJsRequireDependency extends ModuleDependency {
+ constructor(request, range) {
+ super(request);
+ this.range = range;
+ }
+
+ get type() {
+ return "cjs require";
+ }
+}
+
+CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = CommonJsRequireDependency;
diff --git a/node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js new file mode 100644 index 000000000..2e2fee613 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CommonJsRequireDependencyParserPlugin.js @@ -0,0 +1,89 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModulesHelpers = require("./LocalModulesHelpers");
+const ParserHelpers = require("../ParserHelpers");
+
+class CommonJsRequireDependencyParserPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(parser) {
+ const options = this.options;
+ parser.plugin("expression require.cache", ParserHelpers.toConstantDependency("__webpack_require__.c"));
+ parser.plugin("expression require", (expr) => {
+ const dep = new CommonJsRequireContextDependency(options.unknownContextRequest, options.unknownContextRecursive, options.unknownContextRegExp, expr.range);
+ dep.critical = options.unknownContextCritical && "require function is used in a way in which dependencies cannot be statically extracted";
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("call require", (expr) => {
+ if(expr.arguments.length !== 1) return;
+ let localModule;
+ const param = parser.evaluateExpression(expr.arguments[0]);
+ if(param.isConditional()) {
+ let isExpression = false;
+ const prevLength = parser.state.current.dependencies.length;
+ const dep = new RequireHeaderDependency(expr.callee.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ param.options.forEach(function(param) {
+ const result = parser.applyPluginsBailResult("call require:commonjs:item", expr, param);
+ if(result === undefined) {
+ isExpression = true;
+ }
+ });
+ if(isExpression) {
+ parser.state.current.dependencies.length = prevLength;
+ } else {
+ return true;
+ }
+ }
+ if(param.isString() && (localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string))) {
+ const dep = new LocalModuleDependency(localModule, expr.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ } else {
+ const result = parser.applyPluginsBailResult("call require:commonjs:item", expr, param);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call require:commonjs:context", expr, param);
+ } else {
+ const dep = new RequireHeaderDependency(expr.callee.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ }
+ return true;
+ }
+ });
+ parser.plugin("call require:commonjs:item", (expr, param) => {
+ if(param.isString()) {
+ const dep = new CommonJsRequireDependency(param.string, param.range);
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call require:commonjs:context", (expr, param) => {
+ const dep = ContextDependencyHelpers.create(CommonJsRequireContextDependency, expr.range, param, expr, options);
+ if(!dep) return;
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+}
+module.exports = CommonJsRequireDependencyParserPlugin;
diff --git a/node_modules/webpack/lib/dependencies/ConstDependency.js b/node_modules/webpack/lib/dependencies/ConstDependency.js new file mode 100644 index 000000000..2bf2008e5 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ConstDependency.js @@ -0,0 +1,32 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class ConstDependency extends NullDependency {
+ constructor(expression, range) {
+ super();
+ this.expression = expression;
+ this.range = range;
+ }
+
+ updateHash(hash) {
+ hash.update(this.range + "");
+ hash.update(this.expression + "");
+ }
+}
+
+ConstDependency.Template = class ConstDependencyTemplate {
+ apply(dep, source) {
+ if(typeof dep.range === "number") {
+ source.insert(dep.range, dep.expression);
+ return;
+ }
+
+ source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
+ }
+};
+
+module.exports = ConstDependency;
diff --git a/node_modules/webpack/lib/dependencies/ContextDependency.js b/node_modules/webpack/lib/dependencies/ContextDependency.js new file mode 100644 index 000000000..7f8772a55 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependency.js @@ -0,0 +1,29 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class ContextDependency extends Dependency {
+ constructor(request, recursive, regExp) {
+ super();
+ this.request = request;
+ this.userRequest = request;
+ this.recursive = recursive;
+ this.regExp = regExp;
+ this.async = false;
+ }
+
+ isEqualResource(other) {
+ if(!(other instanceof ContextDependency))
+ return false;
+
+ return this.request === other.request &&
+ this.recursive === other.recursive &&
+ this.regExp === other.regExp &&
+ this.async === other.async;
+ }
+}
+
+module.exports = ContextDependency;
diff --git a/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js b/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js new file mode 100644 index 000000000..412cee701 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js @@ -0,0 +1,71 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ContextDependencyHelpers = exports;
+
+/**
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @return {string} Escaped string
+ */
+function quotemeta(str) {
+ return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+}
+
+ContextDependencyHelpers.create = function(Dep, range, param, expr, options, chunkName) {
+ let dep;
+ let prefix;
+ let postfix;
+ let prefixRange;
+ let valueRange;
+ let idx;
+ let context;
+ let regExp;
+ if(param.isTemplateString()) {
+ prefix = param.quasis[0].string;
+ postfix = param.quasis.length > 1 ? param.quasis[param.quasis.length - 1].string : "";
+ prefixRange = [param.quasis[0].range[0], param.quasis[0].range[1]];
+ valueRange = param.range;
+ idx = prefix.lastIndexOf("/");
+ context = ".";
+ if(idx >= 0) {
+ context = prefix.substr(0, idx);
+ prefix = `.${prefix.substr(idx)}`;
+ }
+ // If there are more than two quasis, maybe the generated RegExp can be more precise?
+ regExp = new RegExp(`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(postfix)}$`);
+ dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange, chunkName);
+ dep.loc = expr.loc;
+ dep.replaces = [{
+ range: prefixRange,
+ value: prefix
+ }];
+ dep.critical = options.wrappedContextCritical && "a part of the request of a dependency is an expression";
+ return dep;
+ } else if(param.isWrapped() && (param.prefix && param.prefix.isString() || param.postfix && param.postfix.isString())) {
+ prefix = param.prefix && param.prefix.isString() ? param.prefix.string : "";
+ postfix = param.postfix && param.postfix.isString() ? param.postfix.string : "";
+ prefixRange = param.prefix && param.prefix.isString() ? param.prefix.range : null;
+ valueRange = [prefixRange ? prefixRange[1] : param.range[0], param.range[1]];
+ idx = prefix.lastIndexOf("/");
+ context = ".";
+ if(idx >= 0) {
+ context = prefix.substr(0, idx);
+ prefix = `.${prefix.substr(idx)}`;
+ }
+ regExp = new RegExp(`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(postfix)}$`);
+ dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange, chunkName);
+ dep.loc = expr.loc;
+ dep.prepend = param.prefix && param.prefix.isString() ? prefix : null;
+ dep.critical = options.wrappedContextCritical && "a part of the request of a dependency is an expression";
+ return dep;
+ } else {
+ dep = new Dep(options.exprContextRequest, options.exprContextRecursive, options.exprContextRegExp, range, param.range, chunkName);
+ dep.loc = expr.loc;
+ dep.critical = options.exprContextCritical && "the request of a dependency is an expression";
+ return dep;
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js new file mode 100644 index 000000000..f88f6c85c --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js @@ -0,0 +1,32 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class ContextDependencyTemplateAsId {
+
+ apply(dep, source, outputOptions, requestShortener) {
+ const comment = outputOptions.pathinfo ?
+ "/*! " + requestShortener.shorten(dep.request) + " */ " : "";
+
+ if(dep.module && dep.module.dependencies && dep.module.dependencies.length > 0) {
+ if(dep.valueRange) {
+ if(Array.isArray(dep.replaces)) {
+ for(let i = 0; i < dep.replaces.length; i++) {
+ const rep = dep.replaces[i];
+ source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+ }
+ }
+ source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+ source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
+ } else {
+ source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve");
+ }
+ } else {
+ const content = require("./WebpackMissingModule").module(dep.request);
+ source.replace(dep.range[0], dep.range[1] - 1, content);
+ }
+ }
+}
+module.exports = ContextDependencyTemplateAsId;
diff --git a/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js new file mode 100644 index 000000000..eeb135f38 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js @@ -0,0 +1,34 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class ContextDependencyTemplateAsRequireCall {
+
+ apply(dep, source, outputOptions, requestShortener) {
+ const comment = outputOptions.pathinfo ?
+ "/*! " + requestShortener.shorten(dep.request) + " */ " : "";
+
+ const containsDeps = dep.module && dep.module.dependencies && dep.module.dependencies.length > 0;
+ const isAsync = dep.module && dep.module.async;
+ if(dep.module && (isAsync || containsDeps)) {
+ if(dep.valueRange) {
+ if(Array.isArray(dep.replaces)) {
+ for(let i = 0; i < dep.replaces.length; i++) {
+ const rep = dep.replaces[i];
+ source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+ }
+ }
+ source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+ source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
+ } else {
+ source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")");
+ }
+ } else {
+ const content = require("./WebpackMissingModule").module(dep.request);
+ source.replace(dep.range[0], dep.range[1] - 1, content);
+ }
+ }
+}
+module.exports = ContextDependencyTemplateAsRequireCall;
diff --git a/node_modules/webpack/lib/dependencies/ContextElementDependency.js b/node_modules/webpack/lib/dependencies/ContextElementDependency.js new file mode 100644 index 000000000..8e5fafe52 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ContextElementDependency.js @@ -0,0 +1,21 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class ContextElementDependency extends ModuleDependency {
+ constructor(request, userRequest) {
+ super(request);
+ if(userRequest) {
+ this.userRequest = userRequest;
+ }
+ }
+
+ get type() {
+ return "context element";
+ }
+}
+
+module.exports = ContextElementDependency;
diff --git a/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js b/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js new file mode 100644 index 000000000..990109782 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js @@ -0,0 +1,20 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("../WebpackError");
+
+class CriticalDependencyWarning extends WebpackError {
+ constructor(message) {
+ super();
+
+ this.name = "CriticalDependencyWarning";
+ this.message = "Critical dependency: " + message;
+
+ Error.captureStackTrace(this, this.constructor);
+ }
+}
+
+module.exports = CriticalDependencyWarning;
diff --git a/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js b/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js new file mode 100644 index 000000000..86341d59a --- /dev/null +++ b/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js @@ -0,0 +1,18 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class DelegatedSourceDependency extends ModuleDependency {
+ constructor(request) {
+ super(request);
+ }
+
+ get type() {
+ return "delegated source";
+ }
+}
+
+module.exports = DelegatedSourceDependency;
diff --git a/node_modules/webpack/lib/dependencies/DepBlockHelpers.js b/node_modules/webpack/lib/dependencies/DepBlockHelpers.js new file mode 100644 index 000000000..aef63fded --- /dev/null +++ b/node_modules/webpack/lib/dependencies/DepBlockHelpers.js @@ -0,0 +1,42 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+var DepBlockHelpers = exports;
+
+DepBlockHelpers.getLoadDepBlockWrapper = function(depBlock, outputOptions, requestShortener, name) {
+ var promiseCode = DepBlockHelpers.getDepBlockPromise(depBlock, outputOptions, requestShortener, name);
+ return [
+ promiseCode + ".then(",
+ ").catch(",
+ ")"
+ ];
+};
+
+DepBlockHelpers.getDepBlockPromise = function(depBlock, outputOptions, requestShortener, name) {
+ if(depBlock.chunks) {
+ var chunks = depBlock.chunks.filter(function(chunk) {
+ return !chunk.hasRuntime() && chunk.id !== null;
+ });
+ if(chunks.length === 1) {
+ var chunk = chunks[0];
+ return "__webpack_require__.e" + asComment(name) + "(" + JSON.stringify(chunk.id) + "" +
+ (outputOptions.pathinfo && depBlock.chunkName ? "/*! " + requestShortener.shorten(depBlock.chunkName) + " */" : "") +
+ asComment(depBlock.chunkReason) + ")";
+ } else if(chunks.length > 0) {
+ return "Promise.all" + asComment(name) + "(" +
+ (outputOptions.pathinfo && depBlock.chunkName ? "/*! " + requestShortener.shorten(depBlock.chunkName) + " */" : "") +
+ "[" +
+ chunks.map(function(chunk) {
+ return "__webpack_require__.e(" + JSON.stringify(chunk.id) + ")";
+ }).join(", ") +
+ "])";
+ }
+ }
+ return "Promise.resolve()";
+};
+
+function asComment(str) {
+ if(!str) return "";
+ return "/* " + str + " */";
+}
diff --git a/node_modules/webpack/lib/dependencies/DllEntryDependency.js b/node_modules/webpack/lib/dependencies/DllEntryDependency.js new file mode 100644 index 000000000..113249de8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/DllEntryDependency.js @@ -0,0 +1,20 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class DllEntryDependency extends Dependency {
+ constructor(dependencies, name) {
+ super();
+ this.dependencies = dependencies;
+ this.name = name;
+ }
+
+ get type() {
+ return "dll entry";
+ }
+}
+
+module.exports = DllEntryDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js b/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js new file mode 100644 index 000000000..91998126a --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js @@ -0,0 +1,42 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const makeHarmonyImportStatement = require("./HarmonyImportDependency").makeImportStatement;
+
+class HarmonyAcceptDependency extends NullDependency {
+ constructor(range, dependencies, hasCallback) {
+ super();
+ this.range = range;
+ this.dependencies = dependencies;
+ this.hasCallback = hasCallback;
+ }
+
+ get type() {
+ return "accepted harmony modules";
+ }
+}
+
+HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const content = dep.dependencies
+ .map(dependency => makeHarmonyImportStatement(
+ false,
+ dependency,
+ outputOptions,
+ requestShortener
+ )).join("");
+
+ if(dep.hasCallback) {
+ source.insert(dep.range[0], `function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`);
+ source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
+ return;
+ }
+
+ source.insert(dep.range[1] - 0.5, `, function() { ${content} }`);
+ }
+};
+
+module.exports = HarmonyAcceptDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js b/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js new file mode 100644 index 000000000..8b0689ad7 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js @@ -0,0 +1,22 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+
+class HarmonyAcceptImportDependency extends HarmonyImportDependency {
+ constructor(request, importedVar, range) {
+ super(request, importedVar, range);
+ }
+
+ get type() {
+ return "harmony accept";
+ }
+}
+
+HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {}
+};
+
+module.exports = HarmonyAcceptImportDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js b/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js new file mode 100644 index 000000000..8016dac80 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js @@ -0,0 +1,30 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class HarmonyCompatibilityDependency extends NullDependency {
+ constructor(originModule) {
+ super();
+ this.originModule = originModule;
+ }
+
+ get type() {
+ return "harmony export header";
+ }
+}
+
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate {
+ apply(dep, source) {
+ const usedExports = dep.originModule.usedExports;
+ if(usedExports && !Array.isArray(usedExports)) {
+ const exportName = dep.originModule.exportsArgument || "exports";
+ const content = `Object.defineProperty(${exportName}, \"__esModule\", { value: true });\n`;
+ source.insert(-1, content);
+ }
+ }
+};
+
+module.exports = HarmonyCompatibilityDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js new file mode 100644 index 000000000..59eceecd8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js @@ -0,0 +1,56 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
+
+module.exports = class HarmonyDetectionParserPlugin {
+ apply(parser) {
+ parser.plugin("program", (ast) => {
+ var isHarmony = ast.body.some(statement => {
+ return /^(Import|Export).*Declaration$/.test(statement.type);
+ });
+ if(isHarmony) {
+ const module = parser.state.module;
+ const dep = new HarmonyCompatibilityDependency(module);
+ dep.loc = {
+ start: {
+ line: -1,
+ column: 0
+ },
+ end: {
+ line: -1,
+ column: 0
+ },
+ index: -2
+ };
+ module.addDependency(dep);
+ module.meta.harmonyModule = true;
+ module.strict = true;
+ module.exportsArgument = "__webpack_exports__";
+ }
+ });
+ var nonHarmonyIdentifiers = ["define", "exports"];
+ nonHarmonyIdentifiers.forEach(identifer => {
+ parser.plugin(`evaluate typeof ${identifer}`, nullInHarmony);
+ parser.plugin(`typeof ${identifer}`, skipInHarmony);
+ parser.plugin(`evaluate ${identifer}`, nullInHarmony);
+ parser.plugin(`expression ${identifer}`, skipInHarmony);
+ parser.plugin(`call ${identifer}`, skipInHarmony);
+ });
+
+ function skipInHarmony() {
+ const module = this.state.module;
+ if(module && module.meta && module.meta.harmonyModule)
+ return true;
+ }
+
+ function nullInHarmony() {
+ const module = this.state.module;
+ if(module && module.meta && module.meta.harmonyModule)
+ return null;
+ }
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js new file mode 100644 index 000000000..3edf6e642 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js @@ -0,0 +1,75 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
+const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
+const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+const HarmonyModulesHelpers = require("./HarmonyModulesHelpers");
+
+module.exports = class HarmonyExportDependencyParserPlugin {
+ apply(parser) {
+ parser.plugin("export", statement => {
+ const dep = new HarmonyExportHeaderDependency(statement.declaration && statement.declaration.range, statement.range);
+ dep.loc = Object.create(statement.loc);
+ dep.loc.index = -1;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("export import", (statement, source) => {
+ const dep = new HarmonyImportDependency(source, HarmonyModulesHelpers.getNewModuleVar(parser.state, source), statement.range);
+ dep.loc = Object.create(statement.loc);
+ dep.loc.index = -1;
+ parser.state.current.addDependency(dep);
+ parser.state.lastHarmonyImport = dep;
+ return true;
+ });
+ parser.plugin("export expression", (statement, expr) => {
+ const dep = new HarmonyExportExpressionDependency(parser.state.module, expr.range, statement.range);
+ dep.loc = Object.create(statement.loc);
+ dep.loc.index = -1;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("export declaration", statement => {});
+ parser.plugin("export specifier", (statement, id, name, idx) => {
+ const rename = parser.scope.renames[`$${id}`];
+ let dep;
+ if(rename === "imported var") {
+ const settings = parser.state.harmonySpecifier[`$${id}`];
+ dep = new HarmonyExportImportedSpecifierDependency(parser.state.module, settings[0], settings[1], settings[2], name);
+ } else {
+ const immutable = statement.declaration && isImmutableStatement(statement.declaration);
+ const hoisted = statement.declaration && isHoistedStatement(statement.declaration);
+ dep = new HarmonyExportSpecifierDependency(parser.state.module, id, name, !immutable || hoisted ? -0.5 : (statement.range[1] + 0.5), immutable);
+ }
+ dep.loc = Object.create(statement.loc);
+ dep.loc.index = idx;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("export import specifier", (statement, source, id, name, idx) => {
+ const dep = new HarmonyExportImportedSpecifierDependency(parser.state.module, parser.state.lastHarmonyImport, HarmonyModulesHelpers.getModuleVar(parser.state, source), id, name);
+ dep.loc = Object.create(statement.loc);
+ dep.loc.index = idx;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+};
+
+function isImmutableStatement(statement) {
+ if(statement.type === "FunctionDeclaration") return true;
+ if(statement.type === "ClassDeclaration") return true;
+ if(statement.type === "VariableDeclaration" && statement.kind === "const") return true;
+ return false;
+}
+
+function isHoistedStatement(statement) {
+ if(statement.type === "FunctionDeclaration") return true;
+ return false;
+}
diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js new file mode 100644 index 000000000..17881438f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js @@ -0,0 +1,57 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class HarmonyExportExpressionDependency extends NullDependency {
+ constructor(originModule, range, rangeStatement) {
+ super();
+ this.originModule = originModule;
+ this.range = range;
+ this.rangeStatement = rangeStatement;
+ }
+
+ get type() {
+ return "harmony export expression";
+ }
+
+ getExports() {
+ return {
+ exports: ["default"]
+ };
+ }
+
+ describeHarmonyExport() {
+ return {
+ exportedName: "default",
+ precedence: 1,
+ };
+ }
+}
+
+HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate {
+ apply(dep, source) {
+ const used = dep.originModule.isUsed("default");
+ const content = this.getContent(dep.originModule, used);
+
+ if(dep.range) {
+ source.replace(dep.rangeStatement[0], dep.range[0] - 1, content + "(");
+ source.replace(dep.range[1], dep.rangeStatement[1] - 1, ");");
+ return;
+ }
+
+ source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
+ }
+
+ getContent(module, used) {
+ const exportsName = module.exportsArgument || "exports";
+ if(used) {
+ return `/* harmony default export */ ${exportsName}[${JSON.stringify(used)}] = `;
+ }
+ return "/* unused harmony default export */ var _unused_webpack_default_export = ";
+ }
+};
+
+module.exports = HarmonyExportExpressionDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js new file mode 100644 index 000000000..86033ce95 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js @@ -0,0 +1,28 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class HarmonyExportHeaderDependency extends NullDependency {
+ constructor(range, rangeStatement) {
+ super();
+ this.range = range;
+ this.rangeStatement = rangeStatement;
+ }
+
+ get type() {
+ return "harmony export header";
+ }
+}
+
+HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate {
+ apply(dep, source) {
+ const content = "";
+ const replaceUntil = dep.range ? dep.range[0] - 1 : dep.rangeStatement[1] - 1;
+ source.replace(dep.rangeStatement[0], replaceUntil, content);
+ }
+};
+
+module.exports = HarmonyExportHeaderDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js new file mode 100644 index 000000000..114bd455a --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency.js @@ -0,0 +1,286 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const HarmonyModulesHelpers = require("./HarmonyModulesHelpers");
+
+class HarmonyExportImportedSpecifierDependency extends NullDependency {
+ constructor(originModule, importDependency, importedVar, id, name) {
+ super();
+ this.originModule = originModule;
+ this.importDependency = importDependency;
+ this.importedVar = importedVar;
+ this.id = id;
+ this.name = name;
+ }
+
+ get type() {
+ return "harmony export imported specifier";
+ }
+
+ getReference() {
+ const name = this.name;
+ const used = this.originModule.isUsed(name);
+ const active = HarmonyModulesHelpers.isActive(this.originModule, this);
+ const importedModule = this.importDependency.module;
+
+ if(!importedModule || !used || !active) return null;
+ if(!this.originModule.usedExports) return null;
+
+ if(name) {
+ const nameIsNotInUsedExports = Array.isArray(this.originModule.usedExports) && this.originModule.usedExports.indexOf(name) < 0;
+ if(nameIsNotInUsedExports) return null;
+
+ // export { name as name }
+ if(this.id) {
+ return {
+ module: importedModule,
+ importedNames: [this.id]
+ };
+ }
+
+ // export { * as name }
+ return {
+ module: importedModule,
+ importedNames: true
+ };
+ }
+
+ // export *
+ if(Array.isArray(this.originModule.usedExports)) {
+ // reexport * with known used exports
+ var activeExports = HarmonyModulesHelpers.getActiveExports(this.originModule, this);
+ if(Array.isArray(importedModule.providedExports)) {
+ return {
+ module: importedModule,
+ importedNames: this.originModule.usedExports.filter((id) => {
+ const notInActiveExports = activeExports.indexOf(id) < 0;
+ const notDefault = id !== "default";
+ const inProvidedExports = importedModule.providedExports.indexOf(id) >= 0;
+ return notInActiveExports && notDefault && inProvidedExports;
+ }),
+ };
+ }
+
+ return {
+ module: importedModule,
+ importedNames: this.originModule.usedExports.filter(id => {
+ const notInActiveExports = activeExports.indexOf(id) < 0;
+ const notDefault = id !== "default";
+ return notInActiveExports && notDefault;
+ }),
+ };
+ }
+
+ if(Array.isArray(importedModule.providedExports)) {
+ return {
+ module: importedModule,
+ importedNames: importedModule.providedExports.filter(id => id !== "default"),
+ };
+ }
+
+ return {
+ module: importedModule,
+ importedNames: true,
+ };
+ }
+
+ getExports() {
+ if(this.name) {
+ return {
+ exports: [this.name]
+ };
+ }
+
+ const importedModule = this.importDependency.module;
+
+ if(!importedModule) {
+ // no imported module available
+ return {
+ exports: null
+ };
+ }
+
+ if(Array.isArray(importedModule.providedExports)) {
+ return {
+ exports: importedModule.providedExports.filter(id => id !== "default"),
+ dependencies: [importedModule]
+ };
+ }
+
+ if(importedModule.providedExports) {
+ return {
+ exports: true
+ };
+ }
+
+ return {
+ exports: null,
+ dependencies: [importedModule]
+ };
+ }
+
+ describeHarmonyExport() {
+ const importedModule = this.importDependency.module;
+ if(!this.name && importedModule && Array.isArray(importedModule.providedExports)) {
+ // for a star export and when we know which exports are provided, we can tell so
+ return {
+ exportedName: importedModule.providedExports,
+ precedence: 3
+ };
+ }
+
+ return {
+ exportedName: this.name,
+ precedence: this.name ? 2 : 3
+ };
+ }
+
+ updateHash(hash) {
+ super.updateHash(hash);
+ const hashValue = this.getHashValue(this.importDependency.module);
+ hash.update(hashValue);
+ }
+
+ getHashValue(importedModule) {
+ if(!importedModule) {
+ return "";
+ }
+
+ const stringifiedUsedExport = JSON.stringify(importedModule.usedExports);
+ const stringifiedProvidedExport = JSON.stringify(importedModule.providedExports);
+ return importedModule.used + stringifiedUsedExport + stringifiedProvidedExport;
+ }
+}
+
+module.exports = HarmonyExportImportedSpecifierDependency;
+
+HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const content = this.getContent(dep);
+ source.insert(-1, content);
+ }
+
+ getContent(dep) {
+ const name = dep.importedVar;
+ const used = dep.originModule.isUsed(dep.name);
+ const importedModule = dep.importDependency.module;
+ const active = HarmonyModulesHelpers.isActive(dep.originModule, dep);
+ const importsExportsUnknown = !importedModule || !Array.isArray(importedModule.providedExports);
+
+ const getReexportStatement = this.reexportStatementCreator(dep.originModule, importsExportsUnknown, name);
+
+ // we want to rexport something, but the export isn't used
+ if(!used) {
+ return "/* unused harmony reexport " + dep.name + " */\n";
+ }
+
+ // we want to reexport something but another exports overrides this one
+ if(!active) {
+ return "/* inactive harmony reexport " + (dep.name || "namespace") + " */\n";
+ }
+
+ // we want to reexport the default export from a non-hamory module
+ const isNotAHarmonyModule = !(importedModule && (!importedModule.meta || importedModule.meta.harmonyModule));
+ if(dep.name && dep.id === "default" && isNotAHarmonyModule) {
+ return "/* harmony reexport (default from non-hamory) */ " + getReexportStatement(JSON.stringify(used), null);
+ }
+
+ // we want to reexport a key as new key
+ if(dep.name && dep.id) {
+ var idUsed = importedModule && importedModule.isUsed(dep.id);
+ return "/* harmony reexport (binding) */ " + getReexportStatement(JSON.stringify(used), JSON.stringify(idUsed));
+ }
+
+ // we want to reexport the module object as named export
+ if(dep.name) {
+ return "/* harmony reexport (module object) */ " + getReexportStatement(JSON.stringify(used), "");
+ }
+
+ // we know which exports are used
+ if(Array.isArray(dep.originModule.usedExports)) {
+ const activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule, dep);
+ const items = dep.originModule.usedExports.map(function(id) {
+ if(id === "default") return;
+ if(activeExports.indexOf(id) >= 0) return;
+ if(importedModule.isProvided(id) === false) return;
+ var exportUsed = dep.originModule.isUsed(id);
+ var idUsed = importedModule && importedModule.isUsed(id);
+ return [exportUsed, idUsed];
+ }).filter(Boolean);
+
+ if(items.length === 0) {
+ return "/* unused harmony namespace reexport */\n";
+ }
+
+ return items.map(function(item) {
+ return "/* harmony namespace reexport (by used) */ " + getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1]));
+ }).join("");
+ }
+
+ // not sure which exports are used, but we know which are provided
+ if(dep.originModule.usedExports && importedModule && Array.isArray(importedModule.providedExports)) {
+ const activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule, dep);
+ const items = importedModule.providedExports.map(function(id) {
+ if(id === "default") return;
+ if(activeExports.indexOf(id) >= 0) return;
+ var exportUsed = dep.originModule.isUsed(id);
+ var idUsed = importedModule && importedModule.isUsed(id);
+ return [exportUsed, idUsed];
+ }).filter(Boolean);
+
+ if(items.length === 0) {
+ return "/* empty harmony namespace reexport */\n";
+ }
+
+ return items.map(function(item) {
+ return "/* harmony namespace reexport (by provided) */ " + getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1]));
+ }).join("");
+ }
+
+ // not sure which exports are used and provided
+ if(dep.originModule.usedExports) {
+ const activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule, dep);
+ let content = "/* harmony namespace reexport (unknown) */ for(var __WEBPACK_IMPORT_KEY__ in " + name + ") ";
+
+ // Filter out exports which are defined by other exports
+ // and filter out default export because it cannot be reexported with *
+ if(activeExports.length > 0)
+ content += "if(" + JSON.stringify(activeExports.concat("default")) + ".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
+ else
+ content += "if(__WEBPACK_IMPORT_KEY__ !== 'default') ";
+ const exportsName = dep.originModule.exportsArgument || "exports";
+ return content + `(function(key) { __webpack_require__.d(${exportsName}, key, function() { return ${name}[key]; }) }(__WEBPACK_IMPORT_KEY__));\n`;
+ }
+
+ return "/* unused harmony reexport namespace */\n";
+ }
+
+ reexportStatementCreator(module, importsExportsUnknown, name) {
+ const exportsName = module.exportsArgument || "exports";
+ const getReexportStatement = (key, valueKey) => {
+ const conditional = this.getConditional(importsExportsUnknown, valueKey, name);
+ const returnValue = this.getReturnValue(valueKey);
+ return `${conditional}__webpack_require__.d(${exportsName}, ${key}, function() { return ${name}${returnValue}; });\n`;
+ };
+ return getReexportStatement;
+ }
+
+ getConditional(importsExportsUnknown, valueKey, name) {
+ if(!importsExportsUnknown || !valueKey) {
+ return "";
+ }
+
+ return `if(__webpack_require__.o(${name}, ${valueKey})) `;
+ }
+
+ getReturnValue(valueKey) {
+ if(valueKey === null) {
+ return "_default.a";
+ }
+
+ return valueKey && "[" + valueKey + "]";
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js b/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js new file mode 100644 index 000000000..024ceeb00 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js @@ -0,0 +1,67 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const HarmonyModulesHelpers = require("./HarmonyModulesHelpers");
+
+class HarmonyExportSpecifierDependency extends NullDependency {
+ constructor(originModule, id, name, position, immutable) {
+ super();
+ this.originModule = originModule;
+ this.id = id;
+ this.name = name;
+ this.position = position;
+ this.immutable = immutable;
+ }
+
+ get type() {
+ return "harmony export specifier";
+ }
+
+ getExports() {
+ return {
+ exports: [this.name]
+ };
+ }
+
+ describeHarmonyExport() {
+ return {
+ exportedName: this.name,
+ precedence: 1
+ };
+ }
+}
+
+HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate {
+ apply(dep, source) {
+ const content = this.getPrefix(dep) + this.getContent(dep);
+ source.insert(dep.position, content);
+ }
+
+ getPrefix(dep) {
+ return dep.position > 0 ? "\n" : "";
+ }
+
+ getContent(dep) {
+ const used = dep.originModule.isUsed(dep.name);
+ const active = HarmonyModulesHelpers.isActive(dep.originModule, dep);
+ if(!used) {
+ return `/* unused harmony export ${(dep.name || "namespace")} */\n`;
+ }
+
+ if(!active) {
+ return `/* inactive harmony export ${(dep.name || "namespace")} */\n`;
+ }
+
+ const exportsName = dep.originModule.exportsArgument || "exports";
+ if(dep.immutable) {
+ return `/* harmony export (immutable) */ ${exportsName}[${JSON.stringify(used)}] = ${dep.id};\n`;
+ }
+
+ return `/* harmony export (binding) */ __webpack_require__.d(${exportsName}, ${JSON.stringify(used)}, function() { return ${dep.id}; });\n`;
+ }
+};
+
+module.exports = HarmonyExportSpecifierDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js b/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js new file mode 100644 index 000000000..f20b3cee2 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js @@ -0,0 +1,72 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+var ModuleDependency = require("./ModuleDependency");
+
+class HarmonyImportDependency extends ModuleDependency {
+ constructor(request, importedVar, range) {
+ super(request);
+ this.range = range;
+ this.importedVar = importedVar;
+ }
+
+ get type() {
+ return "harmony import";
+ }
+
+ getReference() {
+ if(!this.module) return null;
+
+ return {
+ module: this.module,
+ importedNames: false
+ };
+ }
+
+ updateHash(hash) {
+ super.updateHash(hash);
+ hash.update((this.module && (!this.module.meta || this.module.meta.harmonyModule)) + "");
+ }
+}
+
+HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const content = makeImportStatement(true, dep, outputOptions, requestShortener);
+ source.replace(dep.range[0], dep.range[1] - 1, "");
+ source.insert(-1, content);
+ }
+};
+
+function getOptionalComment(pathinfo, shortenedRequest) {
+ if(!pathinfo) {
+ return "";
+ }
+ return `/*! ${shortenedRequest} */ `;
+}
+
+function makeImportStatement(declare, dep, outputOptions, requestShortener) {
+ const comment = getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request));
+ const declaration = declare ? "var " : "";
+ const newline = declare ? "\n" : " ";
+
+ if(!dep.module) {
+ const stringifiedError = JSON.stringify(`Cannot find module "${dep.request}"`);
+ return `throw new Error(${stringifiedError});${newline}`;
+ }
+
+ if(dep.importedVar) {
+ const isHarmonyModule = dep.module.meta && dep.module.meta.harmonyModule;
+ const content = `/* harmony import */ ${declaration}${dep.importedVar} = __webpack_require__(${comment}${JSON.stringify(dep.module.id)});${newline}`;
+ if(isHarmonyModule) {
+ return content;
+ }
+ return `${content}/* harmony import */ ${declaration}${dep.importedVar}_default = __webpack_require__.n(${dep.importedVar});${newline}`;
+ }
+
+ return "";
+}
+HarmonyImportDependency.makeImportStatement = makeImportStatement;
+
+module.exports = HarmonyImportDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js new file mode 100644 index 000000000..973383551 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js @@ -0,0 +1,102 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
+const HarmonyModulesHelpers = require("./HarmonyModulesHelpers");
+
+module.exports = class HarmonyImportDependencyParserPlugin {
+ constructor(moduleOptions) {
+ this.strictExportPresence = moduleOptions.strictExportPresence;
+ }
+
+ apply(parser) {
+ parser.plugin("import", (statement, source) => {
+ const dep = new HarmonyImportDependency(source, HarmonyModulesHelpers.getNewModuleVar(parser.state, source), statement.range);
+ dep.loc = statement.loc;
+ parser.state.current.addDependency(dep);
+ parser.state.lastHarmonyImport = dep;
+ return true;
+ });
+ parser.plugin("import specifier", (statement, source, id, name) => {
+ parser.scope.definitions.length--;
+ parser.scope.renames[`$${name}`] = "imported var";
+ if(!parser.state.harmonySpecifier) parser.state.harmonySpecifier = {};
+ parser.state.harmonySpecifier[`$${name}`] = [parser.state.lastHarmonyImport, HarmonyModulesHelpers.getModuleVar(parser.state, source), id];
+ return true;
+ });
+ parser.plugin("expression imported var", (expr) => {
+ const name = expr.name;
+ const settings = parser.state.harmonySpecifier[`$${name}`];
+ const dep = new HarmonyImportSpecifierDependency(settings[0], settings[1], settings[2], name, expr.range, this.strictExportPresence);
+ dep.shorthand = parser.scope.inShorthand;
+ dep.directImport = true;
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("expression imported var.*", (expr) => {
+ const name = expr.object.name;
+ const settings = parser.state.harmonySpecifier[`$${name}`];
+ if(settings[2] !== null)
+ return false;
+ const dep = new HarmonyImportSpecifierDependency(settings[0], settings[1], expr.property.name || expr.property.value, name, expr.range, this.strictExportPresence);
+ dep.shorthand = parser.scope.inShorthand;
+ dep.directImport = false;
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ parser.plugin("call imported var", (expr) => {
+ const args = expr.arguments;
+ const fullExpr = expr;
+ expr = expr.callee;
+ const name = expr.name;
+ const settings = parser.state.harmonySpecifier[`$${name}`];
+ const dep = new HarmonyImportSpecifierDependency(settings[0], settings[1], settings[2], name, expr.range, this.strictExportPresence);
+ dep.directImport = true;
+ dep.callArgs = args;
+ dep.call = fullExpr;
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ if(args)
+ parser.walkExpressions(args);
+ return true;
+ });
+ parser.plugin("hot accept callback", (expr, requests) => {
+ const dependencies = requests
+ .filter(request => HarmonyModulesHelpers.checkModuleVar(parser.state, request))
+ .map(request => {
+ const dep = new HarmonyAcceptImportDependency(request, HarmonyModulesHelpers.getModuleVar(parser.state, request), expr.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return dep;
+ });
+ if(dependencies.length > 0) {
+ const dep = new HarmonyAcceptDependency(expr.range, dependencies, true);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ }
+ });
+ parser.plugin("hot accept without callback", (expr, requests) => {
+ const dependencies = requests
+ .filter(request => HarmonyModulesHelpers.checkModuleVar(parser.state, request))
+ .map(request => {
+ const dep = new HarmonyAcceptImportDependency(request, HarmonyModulesHelpers.getModuleVar(parser.state, request), expr.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return dep;
+ });
+ if(dependencies.length > 0) {
+ const dep = new HarmonyAcceptDependency(expr.range, dependencies, false);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ }
+ });
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js b/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js new file mode 100644 index 000000000..01290b962 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js @@ -0,0 +1,125 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class HarmonyImportSpecifierDependency extends NullDependency {
+ constructor(importDependency, importedVar, id, name, range, strictExportPresence) {
+ super();
+ this.importDependency = importDependency;
+ this.importedVar = importedVar;
+ this.id = id;
+ this.name = name;
+ this.range = range;
+ this.strictExportPresence = strictExportPresence;
+ }
+
+ get type() {
+ return "harmony import specifier";
+ }
+
+ getReference() {
+ if(!this.importDependency.module) return null;
+ return {
+ module: this.importDependency.module,
+ importedNames: this.id ? [this.id] : true
+ };
+ }
+
+ getWarnings() {
+ if(this.strictExportPresence) {
+ return [];
+ }
+ return this._getErrors();
+ }
+
+ getErrors() {
+ if(this.strictExportPresence) {
+ return this._getErrors();
+ }
+ return [];
+ }
+
+ _getErrors() {
+ const importedModule = this.importDependency.module;
+ if(!importedModule || !importedModule.meta || !importedModule.meta.harmonyModule) {
+ return;
+ }
+
+ if(!this.id) {
+ return;
+ }
+
+ if(importedModule.isProvided(this.id) !== false) {
+ return;
+ }
+
+ const idIsNotNameMessage = this.id !== this.name ? ` (imported as '${this.name}')` : "";
+ const errorMessage = `"export '${this.id}'${idIsNotNameMessage} was not found in '${this.importDependency.userRequest}'`;
+ const err = new Error(errorMessage);
+ err.hideStack = true;
+ return [err];
+ }
+
+ updateHash(hash) {
+ super.updateHash(hash);
+ const importedModule = this.importDependency.module;
+ hash.update((importedModule && importedModule.id) + "");
+ hash.update((importedModule && this.id) + "");
+ hash.update((importedModule && this.importedVar) + "");
+ hash.update((importedModule && this.id && importedModule.isUsed(this.id)) + "");
+ hash.update((importedModule && (!importedModule.meta || importedModule.meta.harmonyModule)) + "");
+ hash.update((importedModule && (importedModule.used + JSON.stringify(importedModule.usedExports))) + "");
+ }
+}
+
+HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate {
+ apply(dep, source) {
+ const content = this.getContent(dep);
+ source.replace(dep.range[0], dep.range[1] - 1, content);
+ }
+
+ getContent(dep) {
+ const importedModule = dep.importDependency.module;
+ const defaultImport = dep.directImport && dep.id === "default" && !(importedModule && (!importedModule.meta || importedModule.meta.harmonyModule));
+ const shortHandPrefix = this.getShortHandPrefix(dep);
+ const importedVar = dep.importedVar;
+ const importedVarSuffix = this.getImportVarSuffix(dep, defaultImport, importedModule);
+
+ if(dep.call && defaultImport) {
+ return `${shortHandPrefix}${importedVar}_default()`;
+ }
+
+ if(dep.call && dep.id) {
+ return `${shortHandPrefix}__webpack_require__.i(${importedVar}${importedVarSuffix})`;
+ }
+
+ return `${shortHandPrefix}${importedVar}${importedVarSuffix}`;
+ }
+
+ getImportVarSuffix(dep, defaultImport, importedModule) {
+ if(defaultImport) {
+ return "_default.a";
+ }
+
+ if(dep.id) {
+ const used = importedModule ? importedModule.isUsed(dep.id) : dep.id;
+ const optionalComment = dep.id !== used ? " /* " + dep.id + " */" : "";
+ return `[${JSON.stringify(used)}${optionalComment}]`;
+ }
+
+ return "";
+ }
+
+ getShortHandPrefix(dep) {
+ if(!dep.shorthand) {
+ return "";
+ }
+
+ return dep.name + ": ";
+ }
+};
+
+module.exports = HarmonyImportSpecifierDependency;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js b/node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js new file mode 100644 index 000000000..cd3b63115 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyModulesHelpers.js @@ -0,0 +1,85 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class HarmonyModulesHelpers {
+
+ static getModuleVar(state, request) {
+ if(!state.harmonyModules) state.harmonyModules = [];
+ var idx = state.harmonyModules.indexOf(request);
+ if(idx < 0) {
+ idx = state.harmonyModules.length;
+ state.harmonyModules.push(request);
+ }
+ return "__WEBPACK_IMPORTED_MODULE_" + idx + "_" + request.replace(/[^A-Za-z0-9_]/g, "_").replace(/__+/g, "_") + "__";
+ }
+
+ static getNewModuleVar(state, request) {
+ if(state.harmonyModules && state.harmonyModules.indexOf(request) >= 0)
+ return null;
+ return this.getModuleVar(state, request);
+ }
+
+ static checkModuleVar(state, request) {
+ if(!state.harmonyModules || state.harmonyModules.indexOf(request) < 0)
+ return null;
+ return this.getModuleVar(state, request);
+ }
+
+ // checks if an harmony dependency is active in a module according to
+ // precedence rules.
+ static isActive(module, depInQuestion) {
+ var desc = depInQuestion.describeHarmonyExport();
+ if(!desc.exportedName) return true;
+ var before = true;
+ for(var i = 0; i < module.dependencies.length; i++) {
+ var dep = module.dependencies[i];
+ if(dep === depInQuestion) {
+ before = false;
+ continue;
+ }
+ if(!dep.describeHarmonyExport) continue;
+ var d = dep.describeHarmonyExport();
+ if(!d || !d.exportedName) continue;
+ if(d.exportedName === desc.exportedName) {
+ if(d.precedence < desc.precedence) {
+ return false;
+ }
+ if(d.precedence === desc.precedence && !before) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ // get a list of named exports defined in a module
+ // doesn't include * reexports.
+ static getActiveExports(module, currentDependency) {
+ var desc = currentDependency && currentDependency.describeHarmonyExport();
+ var currentIndex = currentDependency ? module.dependencies.indexOf(currentDependency) : -1;
+ return module.dependencies.map((dep, idx) => {
+ return {
+ dep: dep,
+ idx: idx
+ };
+ }).reduce((arr, data) => {
+ var dep = data.dep;
+ if(!dep.describeHarmonyExport) return arr;
+ var d = dep.describeHarmonyExport();
+ if(!d) return arr;
+ if(!desc || (d.precedence < desc.precedence) || (d.precedence === desc.precedence && data.idx < currentIndex)) {
+ var names = [].concat(d.exportedName);
+ names.forEach(function(name) {
+ if(name && arr.indexOf(name) < 0)
+ arr.push(name);
+ });
+ }
+ return arr;
+ }, []);
+ }
+}
+
+module.exports = HarmonyModulesHelpers;
diff --git a/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js b/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js new file mode 100644 index 000000000..896d8a2bb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js @@ -0,0 +1,72 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+const HarmonyCompatiblilityDependency = require("./HarmonyCompatibilityDependency");
+const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
+const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
+const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
+const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+
+const NullFactory = require("../NullFactory");
+
+const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
+const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
+const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
+
+class HarmonyModulesPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(compiler) {
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+
+ compilation.dependencyFactories.set(HarmonyImportDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(HarmonyImportDependency, new HarmonyImportDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyImportSpecifierDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyImportSpecifierDependency, new HarmonyImportSpecifierDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyCompatiblilityDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyCompatiblilityDependency, new HarmonyCompatiblilityDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyExportHeaderDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyExportHeaderDependency, new HarmonyExportHeaderDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyExportExpressionDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyExportExpressionDependency, new HarmonyExportExpressionDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyExportSpecifierDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyExportSpecifierDependency, new HarmonyExportSpecifierDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyExportImportedSpecifierDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyExportImportedSpecifierDependency, new HarmonyExportImportedSpecifierDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyAcceptDependency, new NullFactory());
+ compilation.dependencyTemplates.set(HarmonyAcceptDependency, new HarmonyAcceptDependency.Template());
+
+ compilation.dependencyFactories.set(HarmonyAcceptImportDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(HarmonyAcceptImportDependency, new HarmonyAcceptImportDependency.Template());
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.harmony !== "undefined" && !parserOptions.harmony)
+ return;
+
+ parser.apply(
+ new HarmonyDetectionParserPlugin(),
+ new HarmonyImportDependencyParserPlugin(this.options),
+ new HarmonyExportDependencyParserPlugin()
+ );
+ });
+ });
+ }
+}
+module.exports = HarmonyModulesPlugin;
diff --git a/node_modules/webpack/lib/dependencies/ImportContextDependency.js b/node_modules/webpack/lib/dependencies/ImportContextDependency.js new file mode 100644 index 000000000..7b688d5d9 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportContextDependency.js @@ -0,0 +1,36 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ContextDependency = require("./ContextDependency");
+const CriticalDependencyWarning = require("./CriticalDependencyWarning");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportContextDependency extends ContextDependency {
+ constructor(request, recursive, regExp, range, valueRange, chunkName) {
+ super(request, recursive, regExp);
+ this.range = range;
+ this.valueRange = valueRange;
+ this.async = true;
+ this.chunkName = chunkName;
+ }
+
+ get type() {
+ return "import() context";
+ }
+
+ getWarnings() {
+ if(!this.critical) {
+ return;
+ }
+
+ return [
+ new CriticalDependencyWarning(this.critical)
+ ];
+ }
+}
+
+ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportContextDependency;
diff --git a/node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js b/node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js new file mode 100644 index 000000000..2797276b9 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportDependenciesBlock.js @@ -0,0 +1,17 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const ImportDependency = require("./ImportDependency");
+
+module.exports = class ImportDependenciesBlock extends AsyncDependenciesBlock {
+ constructor(request, range, chunkName, module, loc) {
+ super(chunkName, module, loc);
+ this.range = range;
+ const dep = new ImportDependency(request, this);
+ dep.loc = loc;
+ this.addDependency(dep);
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/ImportDependency.js b/node_modules/webpack/lib/dependencies/ImportDependency.js new file mode 100644 index 000000000..8858ba20b --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportDependency.js @@ -0,0 +1,54 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const DepBlockHelpers = require("./DepBlockHelpers");
+const webpackMissingPromiseModule = require("./WebpackMissingModule").promise;
+
+class ImportDependency extends ModuleDependency {
+ constructor(request, block) {
+ super(request);
+ this.block = block;
+ }
+
+ get type() {
+ return "import()";
+ }
+}
+
+ImportDependency.Template = class ImportDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const depBlock = dep.block;
+ const promise = DepBlockHelpers.getDepBlockPromise(depBlock, outputOptions, requestShortener, "import()");
+ const comment = this.getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request));
+
+ const content = this.getContent(promise, dep, comment);
+ source.replace(depBlock.range[0], depBlock.range[1] - 1, content);
+ }
+
+ getOptionalComment(pathinfo, shortenedRequest) {
+ if(!pathinfo) {
+ return "";
+ }
+
+ return `/*! ${shortenedRequest} */ `;
+ }
+
+ getContent(promise, dep, comment) {
+ if(promise && dep.module) {
+ const stringifiedId = JSON.stringify(dep.module.id);
+ return `${promise}.then(__webpack_require__.bind(null, ${comment}${stringifiedId}))`;
+ }
+
+ if(dep.module) {
+ const stringifiedId = JSON.stringify(dep.module.id);
+ return `Promise.resolve(__webpack_require__(${comment}${stringifiedId}))`;
+ }
+
+ return webpackMissingPromiseModule(dep.request);
+ }
+};
+
+module.exports = ImportDependency;
diff --git a/node_modules/webpack/lib/dependencies/ImportParserPlugin.js b/node_modules/webpack/lib/dependencies/ImportParserPlugin.js new file mode 100644 index 000000000..73972ebee --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportParserPlugin.js @@ -0,0 +1,51 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ImportContextDependency = require("./ImportContextDependency");
+const ImportDependenciesBlock = require("./ImportDependenciesBlock");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+
+class ImportParserPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(parser) {
+ const options = this.options;
+
+ parser.plugin(["call System.import", "import-call"], (expr) => {
+ if(expr.arguments.length !== 1)
+ throw new Error("Incorrect number of arguments provided to 'import(module: string) -> Promise'.");
+
+ const param = parser.evaluateExpression(expr.arguments[0]);
+
+ let chunkName = null;
+
+ const importOptions = parser.getCommentOptions(expr.range);
+ if(importOptions) {
+ if(typeof importOptions.webpackChunkName !== "undefined") {
+ if(typeof importOptions.webpackChunkName !== "string")
+ throw new Error(`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`);
+ chunkName = importOptions.webpackChunkName;
+ }
+ }
+
+ if(param.isString()) {
+ const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
+ parser.state.current.addBlock(depBlock);
+ return true;
+ } else {
+ const dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options, chunkName);
+ if(!dep) return;
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ }
+}
+module.exports = ImportParserPlugin;
diff --git a/node_modules/webpack/lib/dependencies/ImportPlugin.js b/node_modules/webpack/lib/dependencies/ImportPlugin.js new file mode 100644 index 000000000..487b97455 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ImportPlugin.js @@ -0,0 +1,40 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ImportDependency = require("./ImportDependency");
+const ImportContextDependency = require("./ImportContextDependency");
+const ImportParserPlugin = require("./ImportParserPlugin");
+
+class ImportPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(compiler) {
+ const options = this.options;
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+ const contextModuleFactory = params.contextModuleFactory;
+
+ compilation.dependencyFactories.set(ImportDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template());
+
+ compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory);
+ compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template());
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.import !== "undefined" && !parserOptions.import)
+ return;
+
+ parser.apply(
+ new ImportParserPlugin(options)
+ );
+ });
+ });
+ }
+}
+module.exports = ImportPlugin;
diff --git a/node_modules/webpack/lib/dependencies/LoaderDependency.js b/node_modules/webpack/lib/dependencies/LoaderDependency.js new file mode 100644 index 000000000..4b5aff7c5 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LoaderDependency.js @@ -0,0 +1,18 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class LoaderDependency extends ModuleDependency {
+ constructor(request) {
+ super(request);
+ }
+
+ get type() {
+ return "loader";
+ }
+}
+
+module.exports = LoaderDependency;
diff --git a/node_modules/webpack/lib/dependencies/LoaderPlugin.js b/node_modules/webpack/lib/dependencies/LoaderPlugin.js new file mode 100644 index 000000000..a565ebbc4 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LoaderPlugin.js @@ -0,0 +1,60 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const LoaderDependency = require("./LoaderDependency");
+
+class LoaderPlugin {
+
+ apply(compiler) {
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+
+ compilation.dependencyFactories.set(LoaderDependency, normalModuleFactory);
+ });
+ compiler.plugin("compilation", (compilation) => {
+ compilation.plugin("normal-module-loader", (loaderContext, module) => {
+ loaderContext.loadModule = function loadModule(request, callback) {
+ const dep = new LoaderDependency(request);
+ dep.loc = request;
+ compilation.addModuleDependencies(module, [
+ [dep]
+ ], true, "lm", false, (err) => {
+ if(err) return callback(err);
+
+ if(!dep.module) return callback(new Error("Cannot load the module"));
+ if(dep.module.building) dep.module.building.push(next);
+ else next();
+
+ function next(err) {
+ if(err) return callback(err);
+
+ if(dep.module.error) return callback(dep.module.error);
+ if(!dep.module._source) throw new Error("The module created for a LoaderDependency must have a property _source");
+ let source, map;
+ const moduleSource = dep.module._source;
+ if(moduleSource.sourceAndMap) {
+ const sourceAndMap = moduleSource.sourceAndMap();
+ map = sourceAndMap.map;
+ source = sourceAndMap.source;
+ } else {
+ map = moduleSource.map();
+ source = moduleSource.source();
+ }
+ if(dep.module.fileDependencies) {
+ dep.module.fileDependencies.forEach((dep) => loaderContext.addDependency(dep));
+ }
+ if(dep.module.contextDependencies) {
+ dep.module.contextDependencies.forEach((dep) => loaderContext.addContextDependency(dep));
+ }
+ return callback(null, source, map, dep.module);
+ }
+ });
+ };
+ });
+ });
+ }
+}
+module.exports = LoaderPlugin;
diff --git a/node_modules/webpack/lib/dependencies/LocalModule.js b/node_modules/webpack/lib/dependencies/LocalModule.js new file mode 100644 index 000000000..7245828cb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LocalModule.js @@ -0,0 +1,23 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class LocalModule {
+ constructor(module, name, idx) {
+ this.module = module;
+ this.name = name;
+ this.idx = idx;
+ this.used = false;
+ }
+
+ flagUsed() {
+ this.used = true;
+ }
+
+ variableName() {
+ return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+ }
+}
+module.exports = LocalModule;
diff --git a/node_modules/webpack/lib/dependencies/LocalModuleDependency.js b/node_modules/webpack/lib/dependencies/LocalModuleDependency.js new file mode 100644 index 000000000..0358dca26 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LocalModuleDependency.js @@ -0,0 +1,24 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class LocalModuleDependency extends NullDependency {
+ constructor(localModule, range) {
+ super();
+ localModule.flagUsed();
+ this.localModule = localModule;
+ this.range = range;
+ }
+}
+
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate {
+ apply(dep, source) {
+ if(!dep.range) return;
+ source.replace(dep.range[0], dep.range[1] - 1, dep.localModule.variableName());
+ }
+};
+
+module.exports = LocalModuleDependency;
diff --git a/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js b/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js new file mode 100644 index 000000000..4e2301e16 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js @@ -0,0 +1,46 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const LocalModule = require("./LocalModule");
+const LocalModulesHelpers = exports;
+
+const lookup = (parent, mod) => {
+ if(mod.charAt(0) !== ".") return mod;
+
+ var path = parent.split("/"),
+ segs = mod.split("/");
+ path.pop();
+
+ for(var i = 0; i < segs.length; i++) {
+ var seg = segs[i];
+ if(seg === "..") path.pop();
+ else if(seg !== ".") path.push(seg);
+ }
+
+ return path.join("/");
+};
+
+LocalModulesHelpers.addLocalModule = (state, name) => {
+ if(!state.localModules) state.localModules = [];
+ var m = new LocalModule(state.module, name, state.localModules.length);
+ state.localModules.push(m);
+ return m;
+};
+
+LocalModulesHelpers.getLocalModule = (state, name, namedModule) => {
+ if(!state.localModules) return null;
+ if(namedModule) {
+ // resolve dependency name relative to the defining named module
+ name = lookup(namedModule, name);
+ }
+ for(var i = 0; i < state.localModules.length; i++) {
+ if(state.localModules[i].name === name)
+ return state.localModules[i];
+ }
+ return null;
+};
+
+module.exports = LocalModulesHelpers;
diff --git a/node_modules/webpack/lib/dependencies/ModuleDependency.js b/node_modules/webpack/lib/dependencies/ModuleDependency.js new file mode 100644 index 000000000..b8cfb47bc --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleDependency.js @@ -0,0 +1,23 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class ModuleDependency extends Dependency {
+ constructor(request) {
+ super();
+ this.request = request;
+ this.userRequest = request;
+ }
+
+ isEqualResource(other) {
+ if(!(other instanceof ModuleDependency))
+ return false;
+
+ return this.request === other.request;
+ }
+}
+
+module.exports = ModuleDependency;
diff --git a/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js new file mode 100644 index 000000000..a83924819 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js @@ -0,0 +1,21 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class ModuleDependencyTemplateAsId {
+
+ apply(dep, source, outputOptions, requestShortener) {
+ if(!dep.range) return;
+ const comment = outputOptions.pathinfo ?
+ `/*! ${requestShortener.shorten(dep.request)} */ ` : "";
+ let content;
+ if(dep.module)
+ content = comment + JSON.stringify(dep.module.id);
+ else
+ content = require("./WebpackMissingModule").module(dep.request);
+ source.replace(dep.range[0], dep.range[1] - 1, content);
+ }
+}
+module.exports = ModuleDependencyTemplateAsId;
diff --git a/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js new file mode 100644 index 000000000..863ed3b31 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js @@ -0,0 +1,21 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class ModuleDependencyTemplateAsRequireId {
+
+ apply(dep, source, outputOptions, requestShortener) {
+ if(!dep.range) return;
+ const comment = outputOptions.pathinfo ?
+ `/*! ${requestShortener.shorten(dep.request)} */ ` : "";
+ let content;
+ if(dep.module)
+ content = `__webpack_require__(${comment}${JSON.stringify(dep.module.id)})`;
+ else
+ content = require("./WebpackMissingModule").module(dep.request);
+ source.replace(dep.range[0], dep.range[1] - 1, content);
+ }
+}
+module.exports = ModuleDependencyTemplateAsRequireId;
diff --git a/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js b/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js new file mode 100644 index 000000000..4297e57d8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js @@ -0,0 +1,23 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+class ModuleHotAcceptDependency extends ModuleDependency {
+ constructor(request, range) {
+ super(request);
+ this.range = range;
+ this.weak = true;
+ }
+
+ get type() {
+ return "module.hot.accept";
+ }
+}
+
+ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotAcceptDependency;
diff --git a/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js b/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js new file mode 100644 index 000000000..cab86cecb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js @@ -0,0 +1,23 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+class ModuleHotDeclineDependency extends ModuleDependency {
+ constructor(request, range) {
+ super(request);
+ this.range = range;
+ this.weak = true;
+ }
+
+ get type() {
+ return "module.hot.decline";
+ }
+}
+
+ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotDeclineDependency;
diff --git a/node_modules/webpack/lib/dependencies/MultiEntryDependency.js b/node_modules/webpack/lib/dependencies/MultiEntryDependency.js new file mode 100644 index 000000000..6196b95a5 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/MultiEntryDependency.js @@ -0,0 +1,20 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class MultiEntryDependency extends Dependency {
+ constructor(dependencies, name) {
+ super();
+ this.dependencies = dependencies;
+ this.name = name;
+ }
+
+ get type() {
+ return "multi entry";
+ }
+}
+
+module.exports = MultiEntryDependency;
diff --git a/node_modules/webpack/lib/dependencies/NullDependency.js b/node_modules/webpack/lib/dependencies/NullDependency.js new file mode 100644 index 000000000..5d389e67e --- /dev/null +++ b/node_modules/webpack/lib/dependencies/NullDependency.js @@ -0,0 +1,24 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class NullDependency extends Dependency {
+ get type() {
+ return "null";
+ }
+
+ isEqualResource() {
+ return false;
+ }
+
+ updateHash() {}
+}
+
+NullDependency.Template = class NullDependencyTemplate {
+ apply() {}
+};
+
+module.exports = NullDependency;
diff --git a/node_modules/webpack/lib/dependencies/PrefetchDependency.js b/node_modules/webpack/lib/dependencies/PrefetchDependency.js new file mode 100644 index 000000000..98ca185b8 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/PrefetchDependency.js @@ -0,0 +1,18 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class PrefetchDependency extends ModuleDependency {
+ constructor(request) {
+ super(request);
+ }
+
+ get type() {
+ return "prefetch";
+ }
+}
+
+module.exports = PrefetchDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireContextDependency.js b/node_modules/webpack/lib/dependencies/RequireContextDependency.js new file mode 100644 index 000000000..c0f6bdc75 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireContextDependency.js @@ -0,0 +1,22 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+class RequireContextDependency extends ContextDependency {
+ constructor(request, recursive, regExp, range) {
+ super(request, recursive, regExp);
+ this.range = range;
+ }
+
+ get type() {
+ return "require.context";
+ }
+}
+
+RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = RequireContextDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js new file mode 100644 index 000000000..8587fba8d --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js @@ -0,0 +1,42 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+
+module.exports = class RequireContextDependencyParserPlugin {
+ apply(parser) {
+ parser.plugin("call require.context", expr => {
+ let regExp = /^\.\/.*$/;
+ let recursive = true;
+ switch(expr.arguments.length) {
+ case 3:
+ {
+ const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+ if(!regExpExpr.isRegExp()) return;
+ regExp = regExpExpr.regExp;
+ }
+ // falls through
+ case 2:
+ {
+ const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+ if(!recursiveExpr.isBoolean()) return;
+ recursive = recursiveExpr.bool;
+ }
+ // falls through
+ case 1:
+ {
+ const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+ if(!requestExpr.isString()) return;
+ const dep = new RequireContextDependency(requestExpr.string, recursive, regExp, expr.range);
+ dep.loc = expr.loc;
+ dep.optional = parser.scope.inTry;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ }
+ });
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/RequireContextPlugin.js b/node_modules/webpack/lib/dependencies/RequireContextPlugin.js new file mode 100644 index 000000000..57acda586 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireContextPlugin.js @@ -0,0 +1,77 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+const ContextElementDependency = require("./ContextElementDependency");
+
+const RequireContextDependencyParserPlugin = require("./RequireContextDependencyParserPlugin");
+
+class RequireContextPlugin {
+ constructor(modulesDirectories, extensions) {
+ if(!Array.isArray(modulesDirectories))
+ throw new Error("modulesDirectories must be an array");
+ if(!Array.isArray(extensions))
+ throw new Error("extensions must be an array");
+ this.modulesDirectories = modulesDirectories;
+ this.extensions = extensions;
+ }
+
+ apply(compiler) {
+ const modulesDirectories = this.modulesDirectories;
+ const extensions = this.extensions;
+ compiler.plugin("compilation", (compilation, params) => {
+ const contextModuleFactory = params.contextModuleFactory;
+ const normalModuleFactory = params.normalModuleFactory;
+
+ compilation.dependencyFactories.set(RequireContextDependency, contextModuleFactory);
+ compilation.dependencyTemplates.set(RequireContextDependency, new RequireContextDependency.Template());
+
+ compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory);
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.requireContext !== "undefined" && !parserOptions.requireContext)
+ return;
+
+ parser.apply(new RequireContextDependencyParserPlugin());
+ });
+
+ params.contextModuleFactory.plugin("alternatives", (items, callback) => {
+ if(items.length === 0) return callback(null, items);
+
+ callback(null, items.map((obj) => {
+ return extensions.filter((ext) => {
+ const l = obj.request.length;
+ return l > ext.length && obj.request.substr(l - ext.length, l) === ext;
+ }).map((ext) => {
+ const l = obj.request.length;
+ return {
+ context: obj.context,
+ request: obj.request.substr(0, l - ext.length)
+ };
+ }).concat(obj);
+ }).reduce((a, b) => a.concat(b), []));
+ });
+
+ params.contextModuleFactory.plugin("alternatives", (items, callback) => {
+ if(items.length === 0) return callback(null, items);
+
+ callback(null, items.map((obj) => {
+ for(let i = 0; i < modulesDirectories.length; i++) {
+ const dir = modulesDirectories[i];
+ const idx = obj.request.indexOf("./" + dir + "/");
+ if(idx === 0) {
+ obj.request = obj.request.slice(dir.length + 3);
+ break;
+ }
+ }
+ return obj;
+ }));
+ });
+ });
+ }
+}
+module.exports = RequireContextPlugin;
diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js new file mode 100644 index 000000000..4b3a378e9 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js @@ -0,0 +1,28 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+
+module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
+ constructor(expr, successExpression, errorExpression, chunkName, chunkNameRange, module, loc) {
+ super(chunkName, module, loc);
+ this.expr = expr;
+ const successBodyRange = successExpression && successExpression.body && successExpression.body.range;
+ const errorBodyRange = errorExpression && errorExpression.body && errorExpression.body.range;
+ this.range = null;
+ if(successBodyRange) {
+ if(errorBodyRange) {
+ this.range = [successBodyRange[0] + 1, errorBodyRange[1] - 1];
+ } else {
+ this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1];
+ }
+ }
+ this.chunkNameRange = chunkNameRange;
+ const dep = new RequireEnsureDependency(this);
+ dep.loc = loc;
+ this.addDependency(dep);
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js new file mode 100644 index 000000000..73b7d0c8c --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js @@ -0,0 +1,102 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireEnsureDependenciesBlock = require("./RequireEnsureDependenciesBlock");
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+
+module.exports = class RequireEnsureDependenciesBlockParserPlugin {
+ apply(parser) {
+ parser.plugin("call require.ensure", expr => {
+ let chunkName = null;
+ let chunkNameRange = null;
+ let errorExpressionArg = null;
+ let errorExpression = null;
+ switch(expr.arguments.length) {
+ case 4:
+ {
+ const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+ if(!chunkNameExpr.isString()) return;
+ chunkNameRange = chunkNameExpr.range;
+ chunkName = chunkNameExpr.string;
+ }
+ // falls through
+ case 3:
+ {
+ errorExpressionArg = expr.arguments[2];
+ errorExpression = getFunctionExpression(errorExpressionArg);
+
+ if(!errorExpression && !chunkName) {
+ const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]);
+ if(!chunkNameExpr.isString()) return;
+ chunkNameRange = chunkNameExpr.range;
+ chunkName = chunkNameExpr.string;
+ }
+ }
+ // falls through
+ case 2:
+ {
+ const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]);
+ const dependenciesItems = dependenciesExpr.isArray() ? dependenciesExpr.items : [dependenciesExpr];
+ const successExpressionArg = expr.arguments[1];
+ const successExpression = getFunctionExpression(successExpressionArg);
+
+ if(successExpression) {
+ parser.walkExpressions(successExpression.expressions);
+ }
+ if(errorExpression) {
+ parser.walkExpressions(errorExpression.expressions);
+ }
+
+ const dep = new RequireEnsureDependenciesBlock(expr,
+ successExpression ? successExpression.fn : successExpressionArg,
+ errorExpression ? errorExpression.fn : errorExpressionArg,
+ chunkName, chunkNameRange, parser.state.module, expr.loc);
+ const old = parser.state.current;
+ parser.state.current = dep;
+ try {
+ let failed = false;
+ parser.inScope([], () => {
+ dependenciesItems.forEach(ee => {
+ if(ee.isString()) {
+ const edep = new RequireEnsureItemDependency(ee.string, ee.range);
+ edep.loc = dep.loc;
+ dep.addDependency(edep);
+ } else {
+ failed = true;
+ }
+ });
+ });
+ if(failed) {
+ return;
+ }
+ if(successExpression) {
+ if(successExpression.fn.body.type === "BlockStatement")
+ parser.walkStatement(successExpression.fn.body);
+ else
+ parser.walkExpression(successExpression.fn.body);
+ }
+ old.addBlock(dep);
+ } finally {
+ parser.state.current = old;
+ }
+ if(!successExpression) {
+ parser.walkExpression(successExpressionArg);
+ }
+ if(errorExpression) {
+ if(errorExpression.fn.body.type === "BlockStatement")
+ parser.walkStatement(errorExpression.fn.body);
+ else
+ parser.walkExpression(errorExpression.fn.body);
+ } else if(errorExpressionArg) {
+ parser.walkExpression(errorExpressionArg);
+ }
+ return true;
+ }
+ }
+ });
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js b/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js new file mode 100644 index 000000000..65a9c8a3f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js @@ -0,0 +1,38 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const DepBlockHelpers = require("./DepBlockHelpers");
+
+class RequireEnsureDependency extends NullDependency {
+ constructor(block) {
+ super();
+ this.block = block;
+ }
+
+ get type() {
+ return "require.ensure";
+ }
+}
+
+RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const depBlock = dep.block;
+ const wrapper = DepBlockHelpers.getLoadDepBlockWrapper(depBlock, outputOptions, requestShortener, "require.ensure");
+ const errorCallbackExists = depBlock.expr.arguments.length === 4 || (!depBlock.chunkName && depBlock.expr.arguments.length === 3);
+ const startBlock = wrapper[0] + "(";
+ const middleBlock = `).bind(null, __webpack_require__)${wrapper[1]}`;
+ const endBlock = `${middleBlock}__webpack_require__.oe${wrapper[2]}`;
+ source.replace(depBlock.expr.range[0], depBlock.expr.arguments[1].range[0] - 1, startBlock);
+ if(errorCallbackExists) {
+ source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.arguments[2].range[0] - 1, middleBlock);
+ source.replace(depBlock.expr.arguments[2].range[1], depBlock.expr.range[1] - 1, wrapper[2]);
+ } else {
+ source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.range[1] - 1, endBlock);
+ }
+ }
+};
+
+module.exports = RequireEnsureDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js b/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js new file mode 100644 index 000000000..ca2b699ae --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js @@ -0,0 +1,21 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const NullDependency = require("./NullDependency");
+
+class RequireEnsureItemDependency extends ModuleDependency {
+ constructor(request) {
+ super(request);
+ }
+
+ get type() {
+ return "require.ensure item";
+ }
+}
+
+RequireEnsureItemDependency.Template = NullDependency.Template;
+
+module.exports = RequireEnsureItemDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js b/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js new file mode 100644 index 000000000..b8a66727d --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js @@ -0,0 +1,40 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+
+const NullFactory = require("../NullFactory");
+
+const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
+
+const ParserHelpers = require("../ParserHelpers");
+
+class RequireEnsurePlugin {
+
+ apply(compiler) {
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+
+ compilation.dependencyFactories.set(RequireEnsureItemDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(RequireEnsureItemDependency, new RequireEnsureItemDependency.Template());
+
+ compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
+ compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure)
+ return;
+
+ parser.apply(new RequireEnsureDependenciesBlockParserPlugin());
+ parser.plugin("evaluate typeof require.ensure", ParserHelpers.evaluateToString("function"));
+ parser.plugin("typeof require.ensure", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+ });
+ });
+ }
+}
+module.exports = RequireEnsurePlugin;
diff --git a/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js b/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js new file mode 100644 index 000000000..7ba24ca0b --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js @@ -0,0 +1,26 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class RequireHeaderDependency extends NullDependency {
+ constructor(range) {
+ super();
+ if(!Array.isArray(range)) throw new Error("range must be valid");
+ this.range = range;
+ }
+}
+
+RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate {
+ apply(dep, source) {
+ source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__");
+ }
+
+ applyAsTemplateArgument(name, dep, source) {
+ source.replace(dep.range[0], dep.range[1] - 1, "require");
+ }
+};
+
+module.exports = RequireHeaderDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js b/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js new file mode 100644 index 000000000..474e3696f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js @@ -0,0 +1,33 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class RequireIncludeDependency extends ModuleDependency {
+ constructor(request, range) {
+ super(request);
+ this.range = range;
+ }
+
+ get type() {
+ return "require.include";
+ }
+}
+
+RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ const comment = this.getOptionalComment(outputOptions.pathinfo && dep.module, requestShortener.shorten(dep.request));
+ source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`);
+ }
+
+ getOptionalComment(shouldHaveComment, shortenedRequest) {
+ if(shouldHaveComment) {
+ return "";
+ }
+ return `/*! require.include ${shortenedRequest} */`;
+ }
+};
+
+module.exports = RequireIncludeDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js new file mode 100644 index 000000000..b7b233145 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireIncludeDependencyParserPlugin.js @@ -0,0 +1,21 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireIncludeDependency = require("./RequireIncludeDependency");
+
+module.exports = class RequireIncludeDependencyParserPlugin {
+ apply(parser) {
+ parser.plugin("call require.include", expr => {
+ if(expr.arguments.length !== 1) return;
+ const param = parser.evaluateExpression(expr.arguments[0]);
+ if(!param.isString()) return;
+ const dep = new RequireIncludeDependency(param.string, expr.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+};
diff --git a/node_modules/webpack/lib/dependencies/RequireIncludePlugin.js b/node_modules/webpack/lib/dependencies/RequireIncludePlugin.js new file mode 100644 index 000000000..f80e9b91f --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireIncludePlugin.js @@ -0,0 +1,33 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireIncludeDependency = require("./RequireIncludeDependency");
+const RequireIncludeDependencyParserPlugin = require("./RequireIncludeDependencyParserPlugin");
+
+const ParserHelpers = require("../ParserHelpers");
+
+class RequireIncludePlugin {
+
+ apply(compiler) {
+ compiler.plugin("compilation", (compilation, params) => {
+ const normalModuleFactory = params.normalModuleFactory;
+
+ compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory);
+ compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template());
+
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.requireInclude !== "undefined" && !parserOptions.requireInclude)
+ return;
+
+ parser.apply(new RequireIncludeDependencyParserPlugin());
+ parser.plugin("evaluate typeof require.include", ParserHelpers.evaluateToString("function"));
+ parser.plugin("typeof require.include", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+ });
+ });
+ }
+}
+module.exports = RequireIncludePlugin;
diff --git a/node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js b/node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js new file mode 100644 index 000000000..161319e82 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveContextDependency.js @@ -0,0 +1,34 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ContextDependency = require("./ContextDependency");
+const CriticalDependencyWarning = require("./CriticalDependencyWarning");
+const ContextDependencyTemplateAsId = require("./ContextDependencyTemplateAsId");
+
+class RequireResolveContextDependency extends ContextDependency {
+ constructor(request, recursive, regExp, range, valueRange) {
+ super(request, recursive, regExp);
+ this.range = range;
+ this.valueRange = valueRange;
+ }
+
+ get type() {
+ return "amd require context";
+ }
+
+ getWarnings() {
+ if(!this.critical) {
+ return;
+ }
+
+ return [
+ new CriticalDependencyWarning(this.critical)
+ ];
+ }
+}
+
+RequireResolveContextDependency.Template = ContextDependencyTemplateAsId;
+
+module.exports = RequireResolveContextDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireResolveDependency.js b/node_modules/webpack/lib/dependencies/RequireResolveDependency.js new file mode 100644 index 000000000..72ac48aab --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveDependency.js @@ -0,0 +1,22 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyAsId = require("./ModuleDependencyTemplateAsId");
+
+class RequireResolveDependency extends ModuleDependency {
+ constructor(request, range) {
+ super(request);
+ this.range = range;
+ }
+
+ get type() {
+ return "require.resolve";
+ }
+}
+
+RequireResolveDependency.Template = ModuleDependencyAsId;
+
+module.exports = RequireResolveDependency;
diff --git a/node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js b/node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js new file mode 100644 index 000000000..09dd60788 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveDependencyParserPlugin.js @@ -0,0 +1,71 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+
+class RequireResolveDependencyParserPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(parser) {
+ const options = this.options;
+ parser.plugin("call require.resolve", (expr) => {
+ return parser.applyPluginsBailResult("call require.resolve(Weak)", expr, false);
+ });
+ parser.plugin("call require.resolveWeak", (expr) => {
+ return parser.applyPluginsBailResult("call require.resolve(Weak)", expr, true);
+ });
+ parser.plugin("call require.resolve(Weak)", (expr, weak) => {
+ if(expr.arguments.length !== 1) return;
+ const param = parser.evaluateExpression(expr.arguments[0]);
+ if(param.isConditional()) {
+ param.options.forEach((option) => {
+ const result = parser.applyPluginsBailResult("call require.resolve(Weak):item", expr, option, weak);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call require.resolve(Weak):context", expr, option, weak);
+ }
+ });
+ const dep = new RequireResolveHeaderDependency(expr.callee.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ } else {
+ const result = parser.applyPluginsBailResult("call require.resolve(Weak):item", expr, param, weak);
+ if(result === undefined) {
+ parser.applyPluginsBailResult("call require.resolve(Weak):context", expr, param, weak);
+ }
+ const dep = new RequireResolveHeaderDependency(expr.callee.range);
+ dep.loc = expr.loc;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call require.resolve(Weak):item", (expr, param, weak) => {
+ if(param.isString()) {
+ const dep = new RequireResolveDependency(param.string, param.range);
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ dep.weak = weak;
+ parser.state.current.addDependency(dep);
+ return true;
+ }
+ });
+ parser.plugin("call require.resolve(Weak):context", (expr, param, weak) => {
+ const dep = ContextDependencyHelpers.create(RequireResolveContextDependency, param.range, param, expr, options);
+ if(!dep) return;
+ dep.loc = expr.loc;
+ dep.optional = !!parser.scope.inTry;
+ dep.weak = weak;
+ parser.state.current.addDependency(dep);
+ return true;
+ });
+ }
+}
+module.exports = RequireResolveDependencyParserPlugin;
diff --git a/node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js b/node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js new file mode 100644 index 000000000..d96ff7ddb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/RequireResolveHeaderDependency.js @@ -0,0 +1,26 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class RequireResolveHeaderDependency extends NullDependency {
+ constructor(range) {
+ super();
+ if(!Array.isArray(range)) throw new Error("range must be valid");
+ this.range = range;
+ }
+}
+
+RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate {
+ apply(dep, source) {
+ source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+ }
+
+ applyAsTemplateArgument(name, dep, source) {
+ source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+ }
+};
+
+module.exports = RequireResolveHeaderDependency;
diff --git a/node_modules/webpack/lib/dependencies/SingleEntryDependency.js b/node_modules/webpack/lib/dependencies/SingleEntryDependency.js new file mode 100644 index 000000000..02ccd8986 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/SingleEntryDependency.js @@ -0,0 +1,18 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class SingleEntryDependency extends ModuleDependency {
+ constructor(request) {
+ super(request);
+ }
+
+ get type() {
+ return "single entry";
+ }
+}
+
+module.exports = SingleEntryDependency;
diff --git a/node_modules/webpack/lib/dependencies/SystemPlugin.js b/node_modules/webpack/lib/dependencies/SystemPlugin.js new file mode 100644 index 000000000..dd457ae7c --- /dev/null +++ b/node_modules/webpack/lib/dependencies/SystemPlugin.js @@ -0,0 +1,44 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const ParserHelpers = require("../ParserHelpers");
+
+class SystemPlugin {
+ constructor(options) {
+ this.options = options;
+ }
+
+ apply(compiler) {
+ compiler.plugin("compilation", (compilation, params) => {
+ params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+ if(typeof parserOptions.system !== "undefined" && !parserOptions.system)
+ return;
+
+ function setNotSupported(name) {
+ parser.plugin("evaluate typeof " + name, ParserHelpers.evaluateToString("undefined"));
+ parser.plugin("expression " + name,
+ ParserHelpers.expressionIsUnsupported(name + " is not supported by webpack.")
+ );
+ }
+
+ parser.plugin("typeof System.import", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+ parser.plugin("evaluate typeof System.import", ParserHelpers.evaluateToString("function"));
+ parser.plugin("typeof System", ParserHelpers.toConstantDependency(JSON.stringify("object")));
+ parser.plugin("evaluate typeof System", ParserHelpers.evaluateToString("object"));
+
+ setNotSupported("System.set");
+ setNotSupported("System.get");
+ setNotSupported("System.register");
+ parser.plugin("expression System", function() {
+ const systemPolyfillRequire = ParserHelpers.requireFileAsExpression(
+ this.state.module.context, require.resolve("../../buildin/system.js"));
+ return ParserHelpers.addParsedVariableToModule(this, "System", systemPolyfillRequire);
+ });
+ });
+ });
+ }
+}
+module.exports = SystemPlugin;
diff --git a/node_modules/webpack/lib/dependencies/UnsupportedDependency.js b/node_modules/webpack/lib/dependencies/UnsupportedDependency.js new file mode 100644 index 000000000..48f0971b6 --- /dev/null +++ b/node_modules/webpack/lib/dependencies/UnsupportedDependency.js @@ -0,0 +1,23 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const webpackMissingModule = require("./WebpackMissingModule").module;
+
+class UnsupportedDependency extends NullDependency {
+ constructor(request, range) {
+ super();
+ this.request = request;
+ this.range = range;
+ }
+}
+
+UnsupportedDependency.Template = class UnsupportedDependencyTemplate {
+ apply(dep, source, outputOptions, requestShortener) {
+ source.replace(dep.range[0], dep.range[1], webpackMissingModule(dep.request));
+ }
+};
+
+module.exports = UnsupportedDependency;
diff --git a/node_modules/webpack/lib/dependencies/WebpackMissingModule.js b/node_modules/webpack/lib/dependencies/WebpackMissingModule.js new file mode 100644 index 000000000..64e76cffb --- /dev/null +++ b/node_modules/webpack/lib/dependencies/WebpackMissingModule.js @@ -0,0 +1,18 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+"use strict";
+const toErrorCode = err => `var e = new Error(${JSON.stringify(err)}); e.code = 'MODULE_NOT_FOUND';`;
+
+exports.module = request => `!(function webpackMissingModule() { ${exports.moduleCode(request)} }())`;
+
+exports.promise = (request) => {
+ const errorCode = toErrorCode(`Cannot find module "${request}"`);
+ return `Promise.reject(function webpackMissingModule() { ${errorCode}; return e; }())`;
+};
+
+exports.moduleCode = (request) => {
+ const errorCode = toErrorCode(`Cannot find module "${request}"`);
+ return `${errorCode} throw e;`;
+};
diff --git a/node_modules/webpack/lib/dependencies/getFunctionExpression.js b/node_modules/webpack/lib/dependencies/getFunctionExpression.js new file mode 100644 index 000000000..cc32585ab --- /dev/null +++ b/node_modules/webpack/lib/dependencies/getFunctionExpression.js @@ -0,0 +1,44 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+module.exports = function(expr) {
+ // <FunctionExpression>
+ if(expr.type === "FunctionExpression" || expr.type === "ArrowFunctionExpression") {
+ return {
+ fn: expr,
+ expressions: [],
+ needThis: false
+ };
+ }
+
+ // <FunctionExpression>.bind(<Expression>)
+ if(expr.type === "CallExpression" &&
+ expr.callee.type === "MemberExpression" &&
+ expr.callee.object.type === "FunctionExpression" &&
+ expr.callee.property.type === "Identifier" &&
+ expr.callee.property.name === "bind" &&
+ expr.arguments.length === 1) {
+ return {
+ fn: expr.callee.object,
+ expressions: [expr.arguments[0]]
+ };
+ }
+ // (function(_this) {return <FunctionExpression>})(this) (Coffeescript)
+ if(expr.type === "CallExpression" &&
+ expr.callee.type === "FunctionExpression" &&
+ expr.callee.body.type === "BlockStatement" &&
+ expr.arguments.length === 1 &&
+ expr.arguments[0].type === "ThisExpression" &&
+ expr.callee.body.body &&
+ expr.callee.body.body.length === 1 &&
+ expr.callee.body.body[0].type === "ReturnStatement" &&
+ expr.callee.body.body[0].argument &&
+ expr.callee.body.body[0].argument.type === "FunctionExpression") {
+ return {
+ fn: expr.callee.body.body[0].argument,
+ expressions: [],
+ needThis: true
+ };
+ }
+};
|