sgmc-be 1.0.0

package/src/log/node_modules/webpack/lib/dependencies/AMDDefineDependency.js

@@ -0,0 +1,265 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @type {Record<string, { definition: string, content: string, requests: string[] }>} */
+const DEFINITIONS = {
+	f: {
+		definition: "var __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_RESULT__ = (#).call(exports, ${RuntimeGlobals.require}, exports, module),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [
+			RuntimeGlobals.require,
+			RuntimeGlobals.exports,
+			RuntimeGlobals.module
+		]
+	},
+	o: {
+		definition: "",
+		content: "!(module.exports = #)",
+		requests: [RuntimeGlobals.module]
+	},
+	of: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, ${RuntimeGlobals.require}, exports, module)) :
+		__WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [
+			RuntimeGlobals.require,
+			RuntimeGlobals.exports,
+			RuntimeGlobals.module
+		]
+	},
+	af: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__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__))`,
+		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
+	},
+	ao: {
+		definition: "",
+		content: "!(#, module.exports = #)",
+		requests: [RuntimeGlobals.module]
+	},
+	aof: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__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__))`,
+		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
+	},
+	lf: {
+		definition: "var XXX, XXXmodule;",
+		content: `!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = (#).call(XXXmodule.exports, ${RuntimeGlobals.require}, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))`,
+		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
+	},
+	lo: {
+		definition: "var XXX;",
+		content: "!(XXX = #)",
+		requests: []
+	},
+	lof: {
+		definition: "var XXX, XXXfactory, XXXmodule;",
+		content: `!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, ${RuntimeGlobals.require}, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))`,
+		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
+	},
+	laf: {
+		definition: "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX, XXXexports;",
+		content:
+			"!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#).apply(XXXexports = {}, __WEBPACK_AMD_DEFINE_ARRAY__), XXX === undefined && (XXX = XXXexports))",
+		requests: []
+	},
+	lao: {
+		definition: "var XXX;",
+		content: "!(#, XXX = #)",
+		requests: []
+	},
+	laof: {
+		definition: "var XXXarray, XXXfactory, XXXexports, XXX;",
+		content: `!(XXXarray = #, XXXfactory = (#),
+		(typeof XXXfactory === 'function' ?
+			((XXX = XXXfactory.apply(XXXexports = {}, XXXarray)), XXX === undefined && (XXX = XXXexports)) :
+			(XXX = XXXfactory)
+		))`,
+		requests: []
+	}
+};
+
+class AMDDefineDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range} arrayRange array range
+	 * @param {Range} functionRange function range
+	 * @param {Range} objectRange object range
+	 * @param {boolean} namedModule true, when define is called with a name
+	 */
+	constructor(range, arrayRange, functionRange, objectRange, namedModule) {
+		super();
+		this.range = range;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.objectRange = objectRange;
+		this.namedModule = namedModule;
+		this.localModule = null;
+	}
+
+	get type() {
+		return "amd define";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.objectRange);
+		write(this.namedModule);
+		write(this.localModule);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.objectRange = read();
+		this.namedModule = read();
+		this.localModule = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	AMDDefineDependency,
+	"webpack/lib/dependencies/AMDDefineDependency"
+);
+
+AMDDefineDependency.Template = class AMDDefineDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {AMDDefineDependency} */ (dependency);
+		const branch = this.branch(dep);
+		const { definition, content, requests } = DEFINITIONS[branch];
+		for (const req of requests) {
+			runtimeRequirements.add(req);
+		}
+		this.replace(dep, source, definition, content);
+	}
+
+	/**
+	 * @param {AMDDefineDependency} dependency dependency
+	 * @returns {string} variable name
+	 */
+	localModuleVar(dependency) {
+		return (
+			dependency.localModule &&
+			dependency.localModule.used &&
+			dependency.localModule.variableName()
+		);
+	}
+
+	/**
+	 * @param {AMDDefineDependency} dependency dependency
+	 * @returns {string} branch
+	 */
+	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;
+	}
+
+	/**
+	 * @param {AMDDefineDependency} dependency dependency
+	 * @param {ReplaceSource} source source
+	 * @param {string} definition definition
+	 * @param {string} text text
+	 */
+	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,
+				/** @type {string} */ (texts.shift())
+			);
+			current = dependency.arrayRange[1];
+		}
+
+		if (dependency.objectRange) {
+			source.replace(
+				current,
+				dependency.objectRange[0] - 1,
+				/** @type {string} */ (texts.shift())
+			);
+			current = dependency.objectRange[1];
+		} else if (dependency.functionRange) {
+			source.replace(
+				current,
+				dependency.functionRange[0] - 1,
+				/** @type {string} */ (texts.shift())
+			);
+			current = dependency.functionRange[1];
+		}
+		source.replace(
+			current,
+			dependency.range[1] - 1,
+			/** @type {string} */ (texts.shift())
+		);
+		if (texts.length > 0) throw new Error("Implementation error");
+	}
+};
+
+module.exports = AMDDefineDependency;

package/src/log/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -0,0 +1,365 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const AMDDefineDependency = require("./AMDDefineDependency");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const ConstDependency = require("./ConstDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const DynamicExports = require("./DynamicExports");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const { addLocalModule, getLocalModule } = require("./LocalModulesHelpers");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
+/**
+ * @param {CallExpression} expr expression
+ * @returns {boolean} true if it's a bound function expression
+ */
+const 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;
+};
+
+const isUnboundFunctionExpression = expr => {
+	if (expr.type === "FunctionExpression") return true;
+	if (expr.type === "ArrowFunctionExpression") return true;
+	return false;
+};
+
+const isCallable = expr => {
+	if (isUnboundFunctionExpression(expr)) return true;
+	if (isBoundFunctionExpression(expr)) return true;
+	return false;
+};
+
+class AMDDefineDependencyParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.call
+			.for("define")
+			.tap(
+				"AMDDefineDependencyParserPlugin",
+				this.processCallDefine.bind(this, parser)
+			);
+	}
+
+	processArray(parser, expr, param, identifiers, namedModule) {
+		if (param.isArray()) {
+			param.items.forEach((param, idx) => {
+				if (
+					param.isString() &&
+					["require", "module", "exports"].includes(param.string)
+				)
+					identifiers[idx] = param.string;
+				const result = this.processItem(parser, expr, param, namedModule);
+				if (result === undefined) {
+					this.processContext(parser, 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 = RuntimeGlobals.require;
+				} else if (["exports", "module"].includes(request)) {
+					identifiers[idx] = request;
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = expr.loc;
+					dep.optional = !!parser.scope.inTry;
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			});
+			const dep = this.newRequireArrayDependency(deps, param.range);
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processItem(parser, expr, param, namedModule) {
+		if (param.isConditional()) {
+			param.options.forEach(param => {
+				const result = this.processItem(parser, expr, param);
+				if (result === undefined) {
+					this.processContext(parser, expr, param);
+				}
+			});
+			return true;
+		} else if (param.isString()) {
+			let dep, localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency(RuntimeGlobals.require, param.range, [
+					RuntimeGlobals.require
+				]);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency("exports", param.range, [
+					RuntimeGlobals.exports
+				]);
+			} else if (param.string === "module") {
+				dep = new ConstDependency("module", param.range, [
+					RuntimeGlobals.module
+				]);
+			} else if (
+				(localModule = getLocalModule(parser.state, param.string, namedModule))
+			) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(param.string, param.range);
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			param.range,
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
+		);
+		if (!dep) return;
+		dep.loc = expr.loc;
+		dep.optional = !!parser.scope.inTry;
+		parser.state.current.addDependency(dep);
+		return true;
+	}
+
+	processCallDefine(parser, expr) {
+		let array, fn, obj, namedModule;
+		switch (expr.arguments.length) {
+			case 1:
+				if (isCallable(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 (isCallable(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 (isCallable(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 (isCallable(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;
+		}
+		DynamicExports.bailout(parser.state);
+		let fnParams = null;
+		let fnParamsOffset = 0;
+		if (fn) {
+			if (isUnboundFunctionExpression(fn)) {
+				fnParams = fn.params;
+			} else if (isBoundFunctionExpression(fn)) {
+				fnParams = fn.callee.object.params;
+				fnParamsOffset = fn.arguments.length - 1;
+				if (fnParamsOffset < 0) {
+					fnParamsOffset = 0;
+				}
+			}
+		}
+		let fnRenames = new Map();
+		if (array) {
+			const identifiers = {};
+			const param = parser.evaluateExpression(array);
+			const result = this.processArray(
+				parser,
+				expr,
+				param,
+				identifiers,
+				namedModule
+			);
+			if (!result) return;
+			if (fnParams) {
+				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+					if (identifiers[idx]) {
+						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
+						return false;
+					}
+					return true;
+				});
+			}
+		} else {
+			const identifiers = ["require", "exports", "module"];
+			if (fnParams) {
+				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+					if (identifiers[idx]) {
+						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
+						return false;
+					}
+					return true;
+				});
+			}
+		}
+		let inTry;
+		if (fn && isUnboundFunctionExpression(fn)) {
+			inTry = parser.scope.inTry;
+			parser.inScope(fnParams, () => {
+				for (const [name, varInfo] of fnRenames) {
+					parser.setVariable(name, varInfo);
+				}
+				parser.scope.inTry = inTry;
+				if (fn.body.type === "BlockStatement") {
+					parser.detectMode(fn.body.body);
+					const prev = parser.prevStatement;
+					parser.preWalkStatement(fn.body);
+					parser.prevStatement = prev;
+					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"].includes(i.name)
+				),
+				() => {
+					for (const [name, varInfo] of fnRenames) {
+						parser.setVariable(name, varInfo);
+					}
+					parser.scope.inTry = inTry;
+					if (fn.callee.object.body.type === "BlockStatement") {
+						parser.detectMode(fn.callee.object.body.body);
+						const prev = parser.prevStatement;
+						parser.preWalkStatement(fn.callee.object.body);
+						parser.prevStatement = prev;
+						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 = this.newDefineDependency(
+			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 = addLocalModule(parser.state, namedModule);
+		}
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	}
+
+	newDefineDependency(
+		range,
+		arrayRange,
+		functionRange,
+		objectRange,
+		namedModule
+	) {
+		return new AMDDefineDependency(
+			range,
+			arrayRange,
+			functionRange,
+			objectRange,
+			namedModule
+		);
+	}
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+}
+module.exports = AMDDefineDependencyParserPlugin;