first commit

app_vue/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 | null} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} objectRange object range
+	 * @param {string | null} 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;

app_vue/node_modules/webpack/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -0,0 +1,503 @@
+/*
+	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").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").SimpleCallExpression} SimpleCallExpression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+/**
+ * @param {Expression | SpreadElement} expr expression
+ * @returns {expr is CallExpression} 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;
+};
+
+/** @typedef {FunctionExpression | ArrowFunctionExpression} UnboundFunctionExpression */
+
+/**
+ * @param {Expression | SpreadElement} expr expression
+ * @returns {expr is FunctionExpression | ArrowFunctionExpression} true when unbound function expression
+ */
+const isUnboundFunctionExpression = expr => {
+	if (expr.type === "FunctionExpression") return true;
+	if (expr.type === "ArrowFunctionExpression") return true;
+	return false;
+};
+
+/**
+ * @param {Expression | SpreadElement} expr expression
+ * @returns {expr is FunctionExpression | ArrowFunctionExpression | CallExpression} true when callable
+ */
+const isCallable = expr => {
+	if (isUnboundFunctionExpression(expr)) return true;
+	if (isBoundFunctionExpression(expr)) return true;
+	return false;
+};
+
+class AMDDefineDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parserOptions
+	 */
+	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)
+			);
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {Record<number, string>} identifiers identifiers
+	 * @param {string=} namedModule named module
+	 * @returns {boolean | undefined} result
+	 */
+	processArray(parser, expr, param, identifiers, namedModule) {
+		if (param.isArray()) {
+			const items = /** @type {BasicEvaluatedExpression[]} */ (param.items);
+			for (const [idx, item] of items.entries()) {
+				if (
+					item.isString() &&
+					["require", "module", "exports"].includes(
+						/** @type {string} */ (item.string)
+					)
+				)
+					identifiers[/** @type {number} */ (idx)] = /** @type {string} */ (
+						item.string
+					);
+				const result = this.processItem(parser, expr, item, namedModule);
+				if (result === undefined) {
+					this.processContext(parser, expr, item);
+				}
+			}
+			return true;
+		} else if (param.isConstArray()) {
+			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
+			const deps = [];
+			const array = /** @type {string[]} */ (param.array);
+			for (const [idx, request] of array.entries()) {
+				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 = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			}
+			const dep = this.newRequireArrayDependency(
+				deps,
+				/** @type {Range} */ (param.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {string=} namedModule named module
+	 * @returns {boolean | undefined} result
+	 */
+	processItem(parser, expr, param, namedModule) {
+		if (param.isConditional()) {
+			const options = /** @type {BasicEvaluatedExpression[]} */ (param.options);
+			for (const item of options) {
+				const result = this.processItem(parser, expr, item);
+				if (result === undefined) {
+					this.processContext(parser, expr, item);
+				}
+			}
+
+			return true;
+		} else if (param.isString()) {
+			let dep;
+			let localModule;
+
+			if (param.string === "require") {
+				dep = new ConstDependency(
+					RuntimeGlobals.require,
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.require]
+				);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency(
+					"exports",
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.exports]
+				);
+			} else if (param.string === "module") {
+				dep = new ConstDependency(
+					"module",
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.module]
+				);
+			} else if (
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string),
+					namedModule
+				))
+			) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(
+					/** @type {string} */ (param.string),
+					param.range
+				);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			/** @type {Range} */ (param.range),
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @returns {boolean | undefined} result
+	 */
+	processCallDefine(parser, expr) {
+		/** @type {Expression | SpreadElement | undefined} */
+		let array;
+		/** @type {FunctionExpression | ArrowFunctionExpression | CallExpression | Identifier | undefined} */
+		let fn;
+		/** @type {ObjectExpression | Identifier | undefined} */
+		let obj;
+		/** @type {string | undefined} */
+		let 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 = /** @type {Identifier} */ (expr.arguments[0]);
+				}
+				break;
+			case 2:
+				if (expr.arguments[0].type === "Literal") {
+					namedModule = /** @type {string} */ (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 = /** @type {Identifier} */ (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 = /** @type {Identifier} */ (expr.arguments[1]);
+					}
+				}
+				break;
+			case 3:
+				// define("…", […], f() {…})
+				namedModule =
+					/** @type {string} */
+					(
+						/** @type {Literal} */
+						(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 = /** @type {Identifier} */ (expr.arguments[2]);
+				}
+				break;
+			default:
+				return;
+		}
+		DynamicExports.bailout(parser.state);
+		/** @type {Identifier[] | null} */
+		let fnParams = null;
+		let fnParamsOffset = 0;
+		if (fn) {
+			if (isUnboundFunctionExpression(fn)) {
+				fnParams =
+					/** @type {Identifier[]} */
+					(fn.params);
+			} else if (isBoundFunctionExpression(fn)) {
+				const object =
+					/** @type {FunctionExpression} */
+					(/** @type {MemberExpression} */ (fn.callee).object);
+
+				fnParams =
+					/** @type {Identifier[]} */
+					(object.params);
+				fnParamsOffset = fn.arguments.length - 1;
+				if (fnParamsOffset < 0) {
+					fnParamsOffset = 0;
+				}
+			}
+		}
+		const fnRenames = new Map();
+		if (array) {
+			/** @type {Record<number, string>} */
+			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;
+				});
+			}
+		}
+		/** @type {boolean | undefined} */
+		let inTry;
+		if (fn && isUnboundFunctionExpression(fn)) {
+			inTry = parser.scope.inTry;
+			parser.inScope(/** @type {Identifier[]} */ (fnParams), () => {
+				for (const [name, varInfo] of fnRenames) {
+					parser.setVariable(name, varInfo);
+				}
+				parser.scope.inTry = /** @type {boolean} */ (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;
+
+			const object =
+				/** @type {FunctionExpression} */
+				(/** @type {MemberExpression} */ (fn.callee).object);
+
+			parser.inScope(
+				/** @type {Identifier[]} */
+				(object.params).filter(
+					i => !["require", "module", "exports"].includes(i.name)
+				),
+				() => {
+					for (const [name, varInfo] of fnRenames) {
+						parser.setVariable(name, varInfo);
+					}
+					parser.scope.inTry = /** @type {boolean} */ (inTry);
+
+					if (object.body.type === "BlockStatement") {
+						parser.detectMode(object.body.body);
+						const prev = parser.prevStatement;
+						parser.preWalkStatement(object.body);
+						parser.prevStatement = prev;
+						parser.walkStatement(object.body);
+					} else {
+						parser.walkExpression(
+							/** @type {TODO} */
+							(object.body)
+						);
+					}
+				}
+			);
+			if (fn.arguments) {
+				parser.walkExpressions(fn.arguments);
+			}
+		} else if (fn || obj) {
+			parser.walkExpression(
+				/** @type {FunctionExpression | ArrowFunctionExpression | CallExpression | ObjectExpression | Identifier} */
+				(fn || obj)
+			);
+		}
+
+		const dep = this.newDefineDependency(
+			/** @type {Range} */ (expr.range),
+			array ? /** @type {Range} */ (array.range) : null,
+			fn ? /** @type {Range} */ (fn.range) : null,
+			obj ? /** @type {Range} */ (obj.range) : null,
+			namedModule || null
+		);
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		if (namedModule) {
+			dep.localModule = addLocalModule(parser.state, namedModule);
+		}
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	}
+
+	/**
+	 * @param {Range} range range
+	 * @param {Range | null} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} objectRange object range
+	 * @param {string | null} namedModule true, when define is called with a name
+	 * @returns {AMDDefineDependency} AMDDefineDependency
+	 */
+	newDefineDependency(
+		range,
+		arrayRange,
+		functionRange,
+		objectRange,
+		namedModule
+	) {
+		return new AMDDefineDependency(
+			range,
+			arrayRange,
+			functionRange,
+			objectRange,
+			namedModule
+		);
+	}
+
+	/**
+	 * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
+	 * @param {Range} range range
+	 * @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
+	 */
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range range
+	 * @returns {AMDRequireItemDependency} AMDRequireItemDependency
+	 */
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+}
+
+module.exports = AMDDefineDependencyParserPlugin;

app_vue/node_modules/webpack/lib/dependencies/AMDPlugin.js

@@ -0,0 +1,239 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const {
+	approve,
+	evaluateToIdentifier,
+	evaluateToString,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+
+const AMDDefineDependency = require("./AMDDefineDependency");
+const AMDDefineDependencyParserPlugin = require("./AMDDefineDependencyParserPlugin");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDRequireDependenciesBlockParserPlugin = require("./AMDRequireDependenciesBlockParserPlugin");
+const AMDRequireDependency = require("./AMDRequireDependency");
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const {
+	AMDDefineRuntimeModule,
+	AMDOptionsRuntimeModule
+} = require("./AMDRuntimeModules");
+const ConstDependency = require("./ConstDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const UnsupportedDependency = require("./UnsupportedDependency");
+
+/** @typedef {import("../../declarations/WebpackOptions").Amd} Amd */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "AMDPlugin";
+
+/** @typedef {Record<string, TODO>} AmdOptions */
+
+class AMDPlugin {
+	/**
+	 * @param {AmdOptions} amdOptions the AMD options
+	 */
+	constructor(amdOptions) {
+		this.amdOptions = amdOptions;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const amdOptions = this.amdOptions;
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					AMDRequireDependency,
+					new AMDRequireDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					AMDRequireItemDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					AMDRequireItemDependency,
+					new AMDRequireItemDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					AMDRequireArrayDependency,
+					new AMDRequireArrayDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					AMDRequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					AMDRequireContextDependency,
+					new AMDRequireContextDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					AMDDefineDependency,
+					new AMDDefineDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					UnsupportedDependency,
+					new UnsupportedDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					LocalModuleDependency,
+					new LocalModuleDependency.Template()
+				);
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.amdDefine)
+					.tap(PLUGIN_NAME, (module, set) => {
+						set.add(RuntimeGlobals.require);
+					});
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.amdOptions)
+					.tap(PLUGIN_NAME, (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.amdDefine)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.amdOptions)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new AMDOptionsRuntimeModule(amdOptions)
+						);
+					});
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.amd !== undefined && !parserOptions.amd) return;
+
+					/**
+					 * @param {string} optionExpr option expression
+					 * @param {string} rootName root name
+					 * @param {() => TODO} getMembers callback
+					 */
+					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
+						parser.hooks.expression
+							.for(optionExpr)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, RuntimeGlobals.amdOptions, [
+									RuntimeGlobals.amdOptions
+								])
+							);
+						parser.hooks.evaluateIdentifier
+							.for(optionExpr)
+							.tap(
+								PLUGIN_NAME,
+								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
+							);
+						parser.hooks.evaluateTypeof
+							.for(optionExpr)
+							.tap(PLUGIN_NAME, evaluateToString("object"));
+						parser.hooks.typeof
+							.for(optionExpr)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, JSON.stringify("object"))
+							);
+					};
+
+					new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
+						parser
+					);
+					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
+
+					tapOptionsHooks("define.amd", "define", () => "amd");
+					tapOptionsHooks("require.amd", "require", () => ["amd"]);
+					tapOptionsHooks(
+						"__webpack_amd_options__",
+						"__webpack_amd_options__",
+						() => []
+					);
+
+					parser.hooks.expression.for("define").tap(PLUGIN_NAME, expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.amdDefine,
+							/** @type {Range} */ (expr.range),
+							[RuntimeGlobals.amdDefine]
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+						parser.state.module.addPresentationalDependency(dep);
+						return true;
+					});
+					parser.hooks.typeof
+						.for("define")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("define")
+						.tap(PLUGIN_NAME, evaluateToString("function"));
+					parser.hooks.canRename.for("define").tap(PLUGIN_NAME, approve);
+					parser.hooks.rename.for("define").tap(PLUGIN_NAME, expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.amdDefine,
+							/** @type {Range} */ (expr.range),
+							[RuntimeGlobals.amdDefine]
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+						parser.state.module.addPresentationalDependency(dep);
+						return false;
+					});
+					parser.hooks.typeof
+						.for("require")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("require")
+						.tap(PLUGIN_NAME, evaluateToString("function"));
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+module.exports = AMDPlugin;

app_vue/node_modules/webpack/lib/dependencies/AMDRequireArrayDependency.js

@@ -0,0 +1,124 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const DependencyTemplate = require("../DependencyTemplate");
+const makeSerializable = require("../util/makeSerializable");
+const LocalModuleDependency = require("./LocalModuleDependency");
+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 */
+/** @typedef {import("./AMDRequireItemDependency")} AMDRequireItemDependency */
+
+class AMDRequireArrayDependency extends NullDependency {
+	/**
+	 * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
+	 * @param {Range} range range
+	 */
+	constructor(depsArray, range) {
+		super();
+
+		this.depsArray = depsArray;
+		this.range = range;
+	}
+
+	get type() {
+		return "amd require array";
+	}
+
+	get category() {
+		return "amd";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.depsArray);
+		write(this.range);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.depsArray = read();
+		this.range = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	AMDRequireArrayDependency,
+	"webpack/lib/dependencies/AMDRequireArrayDependency"
+);
+
+AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @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, templateContext) {
+		const dep = /** @type {AMDRequireArrayDependency} */ (dependency);
+		const content = this.getContent(dep, templateContext);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+
+	/**
+	 * @param {AMDRequireArrayDependency} dep the dependency for which the template should be applied
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {string} content
+	 */
+	getContent(dep, templateContext) {
+		const requires = dep.depsArray.map(dependency =>
+			this.contentForDependency(dependency, templateContext)
+		);
+		return `[${requires.join(", ")}]`;
+	}
+
+	/**
+	 * @param {string | LocalModuleDependency | AMDRequireItemDependency} dep the dependency for which the template should be applied
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {string} content
+	 */
+	contentForDependency(
+		dep,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		if (typeof dep === "string") {
+			return dep;
+		}
+
+		if (dep instanceof LocalModuleDependency) {
+			return dep.localModule.variableName();
+		}
+
+		return runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			runtimeRequirements
+		});
+	}
+};
+
+module.exports = AMDRequireArrayDependency;

app_vue/node_modules/webpack/lib/dependencies/AMDRequireContextDependency.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+class AMDRequireContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options
+	 * @param {Range} range range
+	 * @param {Range} valueRange value range
+	 */
+	constructor(options, range, valueRange) {
+		super(options);
+
+		this.range = range;
+		this.valueRange = valueRange;
+	}
+
+	get type() {
+		return "amd require context";
+	}
+
+	get category() {
+		return "amd";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+		write(this.valueRange);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+		this.valueRange = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	AMDRequireContextDependency,
+	"webpack/lib/dependencies/AMDRequireContextDependency"
+);
+
+AMDRequireContextDependency.Template = require("./ContextDependencyTemplateAsRequireCall");
+
+module.exports = AMDRequireContextDependency;

app_vue/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlock.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 makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+
+class AMDRequireDependenciesBlock extends AsyncDependenciesBlock {
+	/**
+	 * @param {DependencyLocation} loc location info
+	 * @param {string=} request request
+	 */
+	constructor(loc, request) {
+		super(null, loc, request);
+	}
+}
+
+makeSerializable(
+	AMDRequireDependenciesBlock,
+	"webpack/lib/dependencies/AMDRequireDependenciesBlock"
+);
+
+module.exports = AMDRequireDependenciesBlock;

app_vue/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -0,0 +1,418 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
+const AMDRequireDependency = require("./AMDRequireDependency");
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const ConstDependency = require("./ConstDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const { getLocalModule } = require("./LocalModulesHelpers");
+const UnsupportedDependency = require("./UnsupportedDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class AMDRequireDependenciesBlockParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parserOptions
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Expression | SpreadElement} expression expression
+	 * @returns {boolean} need bind this
+	 */
+	processFunctionArgument(parser, expression) {
+		let bindThis = true;
+		const fnData = getFunctionExpression(expression);
+		if (fnData) {
+			parser.inScope(
+				fnData.fn.params.filter(
+					i =>
+						!["require", "module", "exports"].includes(
+							/** @type {Identifier} */ (i).name
+						)
+				),
+				() => {
+					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;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.call
+			.for("require")
+			.tap(
+				"AMDRequireDependenciesBlockParserPlugin",
+				this.processCallRequire.bind(this, parser)
+			);
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processArray(parser, expr, param) {
+		if (param.isArray()) {
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (param.items)) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isConstArray()) {
+			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
+			const deps = [];
+			for (const request of /** @type {EXPECTED_ANY[]} */ (param.array)) {
+				let dep;
+				let localModule;
+				if (request === "require") {
+					dep = RuntimeGlobals.require;
+				} else if (["exports", "module"].includes(request)) {
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			}
+			const dep = this.newRequireArrayDependency(
+				deps,
+				/** @type {Range} */ (param.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processItem(parser, expr, param) {
+		if (param.isConditional()) {
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isString()) {
+			let dep;
+			let localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency(
+					RuntimeGlobals.require,
+					/** @type {TODO} */
+					(param.string),
+					[RuntimeGlobals.require]
+				);
+			} else if (param.string === "module") {
+				dep = new ConstDependency(
+					/** @type {string} */
+					(
+						/** @type {BuildInfo} */
+						(parser.state.module.buildInfo).moduleArgument
+					),
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.module]
+				);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency(
+					/** @type {string} */
+					(
+						/** @type {BuildInfo} */
+						(parser.state.module.buildInfo).exportsArgument
+					),
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.exports]
+				);
+			} else if (
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string)
+				))
+			) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(
+					/** @type {string} */ (param.string),
+					param.range
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			/** @type {Range} */
+			(param.range),
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	}
+
+	/**
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {string | undefined} result
+	 */
+	processArrayForRequestString(param) {
+		if (param.isArray()) {
+			const result =
+				/** @type {BasicEvaluatedExpression[]} */
+				(param.items).map(item => this.processItemForRequestString(item));
+			if (result.every(Boolean)) return result.join(" ");
+		} else if (param.isConstArray()) {
+			return /** @type {string[]} */ (param.array).join(" ");
+		}
+	}
+
+	/**
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {string | undefined} result
+	 */
+	processItemForRequestString(param) {
+		if (param.isConditional()) {
+			const result =
+				/** @type {BasicEvaluatedExpression[]} */
+				(param.options).map(item => this.processItemForRequestString(item));
+			if (result.every(Boolean)) return result.join("|");
+		} else if (param.isString()) {
+			return param.string;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @returns {boolean | undefined} result
+	 */
+	processCallRequire(parser, expr) {
+		/** @type {BasicEvaluatedExpression | undefined} */
+		let param;
+		/** @type {AMDRequireDependenciesBlock | undefined | null} */
+		let depBlock;
+		/** @type {AMDRequireDependency | undefined} */
+		let dep;
+		/** @type {boolean | undefined} */
+		let result;
+
+		const old = parser.state.current;
+
+		if (expr.arguments.length >= 1) {
+			param = parser.evaluateExpression(
+				/** @type {Expression} */ (expr.arguments[0])
+			);
+			depBlock = this.newRequireDependenciesBlock(
+				/** @type {DependencyLocation} */ (expr.loc),
+				this.processArrayForRequestString(param)
+			);
+			dep = this.newRequireDependency(
+				/** @type {Range} */ (expr.range),
+				/** @type {Range} */ (param.range),
+				expr.arguments.length > 1
+					? /** @type {Range} */ (expr.arguments[1].range)
+					: null,
+				expr.arguments.length > 2
+					? /** @type {Range} */ (expr.arguments[2].range)
+					: null
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			depBlock.addDependency(dep);
+
+			parser.state.current = /** @type {TODO} */ (depBlock);
+		}
+
+		if (expr.arguments.length === 1) {
+			parser.inScope([], () => {
+				result = this.processArray(
+					parser,
+					expr,
+					/** @type {BasicEvaluatedExpression} */ (param)
+				);
+			});
+			parser.state.current = old;
+			if (!result) return;
+			parser.state.current.addBlock(
+				/** @type {AMDRequireDependenciesBlock} */ (depBlock)
+			);
+			return true;
+		}
+
+		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
+			try {
+				parser.inScope([], () => {
+					result = this.processArray(
+						parser,
+						expr,
+						/** @type {BasicEvaluatedExpression} */ (param)
+					);
+				});
+				if (!result) {
+					const dep = new UnsupportedDependency(
+						"unsupported",
+						/** @type {Range} */ (expr.range)
+					);
+					old.addPresentationalDependency(dep);
+					if (parser.state.module) {
+						parser.state.module.addError(
+							new UnsupportedFeatureWarning(
+								`Cannot statically analyse 'require(…, …)' in line ${
+									/** @type {SourceLocation} */ (expr.loc).start.line
+								}`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+					depBlock = null;
+					return true;
+				}
+				/** @type {AMDRequireDependency} */
+				(dep).functionBindThis = this.processFunctionArgument(
+					parser,
+					expr.arguments[1]
+				);
+				if (expr.arguments.length === 3) {
+					/** @type {AMDRequireDependency} */
+					(dep).errorCallbackBindThis = this.processFunctionArgument(
+						parser,
+						expr.arguments[2]
+					);
+				}
+			} finally {
+				parser.state.current = old;
+				if (depBlock) parser.state.current.addBlock(depBlock);
+			}
+			return true;
+		}
+	}
+
+	/**
+	 * @param {DependencyLocation} loc location
+	 * @param {string=} request request
+	 * @returns {AMDRequireDependenciesBlock} AMDRequireDependenciesBlock
+	 */
+	newRequireDependenciesBlock(loc, request) {
+		return new AMDRequireDependenciesBlock(loc, request);
+	}
+
+	/**
+	 * @param {Range} outerRange outer range
+	 * @param {Range} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} errorCallbackRange error callback range
+	 * @returns {AMDRequireDependency} dependency
+	 */
+	newRequireDependency(
+		outerRange,
+		arrayRange,
+		functionRange,
+		errorCallbackRange
+	) {
+		return new AMDRequireDependency(
+			outerRange,
+			arrayRange,
+			functionRange,
+			errorCallbackRange
+		);
+	}
+
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range range
+	 * @returns {AMDRequireItemDependency} AMDRequireItemDependency
+	 */
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+
+	/**
+	 * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
+	 * @param {Range} range range
+	 * @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
+	 */
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+}
+module.exports = AMDRequireDependenciesBlockParserPlugin;

app_vue/node_modules/webpack/lib/dependencies/AMDRequireDependency.js

@@ -0,0 +1,189 @@
+/*
+	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("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @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 */
+
+class AMDRequireDependency extends NullDependency {
+	/**
+	 * @param {Range} outerRange outer range
+	 * @param {Range} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} errorCallbackRange error callback range
+	 */
+	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
+		super();
+
+		this.outerRange = outerRange;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.errorCallbackRange = errorCallbackRange;
+		this.functionBindThis = false;
+		this.errorCallbackBindThis = false;
+	}
+
+	get category() {
+		return "amd";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.outerRange);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.errorCallbackRange);
+		write(this.functionBindThis);
+		write(this.errorCallbackBindThis);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.outerRange = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.errorCallbackRange = read();
+		this.functionBindThis = read();
+		this.errorCallbackBindThis = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	AMDRequireDependency,
+	"webpack/lib/dependencies/AMDRequireDependency"
+);
+
+AMDRequireDependency.Template = class AMDRequireDependencyTemplate 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,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {AMDRequireDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block: depBlock,
+			message: "AMD require",
+			runtimeRequirements
+		});
+
+		// has array range but no function range
+		if (dep.arrayRange && !dep.functionRange) {
+			const startBlock = `${promise}.then(function() {`;
+			const endBlock = `;})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.replace(dep.arrayRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
+
+		// has function range but no array range
+		if (dep.functionRange && !dep.arrayRange) {
+			const startBlock = `${promise}.then((`;
+			const endBlock = `).bind(exports, ${RuntimeGlobals.require}, exports, module))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.functionRange[0] - 1, startBlock);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
+
+		// has array range, function range, and errorCallbackRange
+		if (dep.arrayRange && dep.functionRange && dep.errorCallbackRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const errorRangeBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](`;
+			const endBlock = `${dep.errorCallbackBindThis ? ".bind(this)" : ""})`;
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(
+				dep.functionRange[1],
+				dep.errorCallbackRange[0] - 1,
+				errorRangeBlock
+			);
+
+			source.replace(
+				dep.errorCallbackRange[1],
+				dep.outerRange[1] - 1,
+				endBlock
+			);
+
+			return;
+		}
+
+		// has array range, function range, but no errorCallbackRange
+		if (dep.arrayRange && dep.functionRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const endBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+		}
+	}
+};
+
+module.exports = AMDRequireDependency;

app_vue/node_modules/webpack/lib/dependencies/AMDRequireItemDependency.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class AMDRequireItemDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range=} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+	}
+
+	get type() {
+		return "amd require";
+	}
+
+	get category() {
+		return "amd";
+	}
+}
+
+makeSerializable(
+	AMDRequireItemDependency,
+	"webpack/lib/dependencies/AMDRequireItemDependency"
+);
+
+AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = AMDRequireItemDependency;

app_vue/node_modules/webpack/lib/dependencies/AMDRuntimeModules.js

@@ -0,0 +1,50 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("./AMDPlugin").AmdOptions} AmdOptions */
+
+class AMDDefineRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("amd define");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdDefine} = function () {`,
+			Template.indent("throw new Error('define cannot be used indirect');"),
+			"};"
+		]);
+	}
+}
+
+class AMDOptionsRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {AmdOptions} options the AMD options
+	 */
+	constructor(options) {
+		super("amd options");
+		this.options = options;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdOptions} = ${JSON.stringify(this.options)};`
+		]);
+	}
+}
+
+module.exports.AMDDefineRuntimeModule = AMDDefineRuntimeModule;
+module.exports.AMDOptionsRuntimeModule = AMDOptionsRuntimeModule;

app_vue/node_modules/webpack/lib/dependencies/CachedConstDependency.js

@@ -0,0 +1,128 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+"use strict";
+
+const DependencyTemplate = require("../DependencyTemplate");
+const InitFragment = require("../InitFragment");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class CachedConstDependency extends NullDependency {
+	/**
+	 * @param {string} expression expression
+	 * @param {Range} range range
+	 * @param {string} identifier identifier
+	 */
+	constructor(expression, range, identifier) {
+		super();
+
+		this.expression = expression;
+		this.range = range;
+		this.identifier = identifier;
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * @returns {string} hash update
+	 */
+	_createHashUpdate() {
+		return `${this.identifier}${this.range}${this.expression}`;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this._createHashUpdate();
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.expression);
+		write(this.range);
+		write(this.identifier);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.expression = read();
+		this.range = read();
+		this.identifier = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CachedConstDependency,
+	"webpack/lib/dependencies/CachedConstDependency"
+);
+
+CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @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,
+		{ runtimeTemplate, dependencyTemplates, initFragments }
+	) {
+		const dep = /** @type {CachedConstDependency} */ (dependency);
+
+		initFragments.push(
+			new InitFragment(
+				`var ${dep.identifier} = ${dep.expression};\n`,
+				InitFragment.STAGE_CONSTANTS,
+				0,
+				`const ${dep.identifier}`
+			)
+		);
+
+		if (typeof dep.range === "number") {
+			source.insert(dep.range, dep.identifier);
+
+			return;
+		}
+
+		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
+	}
+};
+
+module.exports = CachedConstDependency;

app_vue/node_modules/webpack/lib/dependencies/CommonJsDependencyHelpers.js

@@ -0,0 +1,63 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {"exports" | "module.exports" | "this" | "Object.defineProperty(exports)" | "Object.defineProperty(module.exports)" | "Object.defineProperty(this)"} CommonJSDependencyBaseKeywords */
+
+/**
+ * @param {CommonJSDependencyBaseKeywords} depBase commonjs dependency base
+ * @param {Module} module module
+ * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+ * @returns {[string, string]} type and base
+ */
+module.exports.handleDependencyBase = (
+	depBase,
+	module,
+	runtimeRequirements
+) => {
+	let base;
+	let type;
+	switch (depBase) {
+		case "exports":
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			base = module.exportsArgument;
+			type = "expression";
+			break;
+		case "module.exports":
+			runtimeRequirements.add(RuntimeGlobals.module);
+			base = `${module.moduleArgument}.exports`;
+			type = "expression";
+			break;
+		case "this":
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+			base = "this";
+			type = "expression";
+			break;
+		case "Object.defineProperty(exports)":
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			base = module.exportsArgument;
+			type = "Object.defineProperty";
+			break;
+		case "Object.defineProperty(module.exports)":
+			runtimeRequirements.add(RuntimeGlobals.module);
+			base = `${module.moduleArgument}.exports`;
+			type = "Object.defineProperty";
+			break;
+		case "Object.defineProperty(this)":
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+			base = "this";
+			type = "Object.defineProperty";
+			break;
+		default:
+			throw new Error(`Unsupported base ${depBase}`);
+	}
+
+	return [type, base];
+};

app_vue/node_modules/webpack/lib/dependencies/CommonJsExportRequireDependency.js

@@ -0,0 +1,403 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const { UsageState } = require("../ExportsInfo");
+const Template = require("../Template");
+const { equals } = require("../util/ArrayHelpers");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const { handleDependencyBase } = require("./CommonJsDependencyHelpers");
+const ModuleDependency = require("./ModuleDependency");
+const processExportInfo = require("./processExportInfo");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+
+const idsSymbol = Symbol("CommonJsExportRequireDependency.ids");
+
+const EMPTY_OBJECT = {};
+
+class CommonJsExportRequireDependency extends ModuleDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range | null} valueRange value range
+	 * @param {CommonJSDependencyBaseKeywords} base base
+	 * @param {string[]} names names
+	 * @param {string} request request
+	 * @param {string[]} ids ids
+	 * @param {boolean} resultUsed true, when the result is used
+	 */
+	constructor(range, valueRange, base, names, request, ids, resultUsed) {
+		super(request);
+		this.range = range;
+		this.valueRange = valueRange;
+		this.base = base;
+		this.names = names;
+		this.ids = ids;
+		this.resultUsed = resultUsed;
+		this.asiSafe = undefined;
+	}
+
+	get type() {
+		return "cjs export require";
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported id
+	 */
+	getIds(moduleGraph) {
+		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		const ids = this.getIds(moduleGraph);
+		const getFullResult = () => {
+			if (ids.length === 0) {
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
+			}
+			return [
+				{
+					name: ids,
+					canMangle: false
+				}
+			];
+		};
+		if (this.resultUsed) return getFullResult();
+		/** @type {ExportsInfo | undefined} */
+		let exportsInfo = moduleGraph.getExportsInfo(
+			/** @type {Module} */ (moduleGraph.getParentModule(this))
+		);
+		for (const name of this.names) {
+			const exportInfo = /** @type {ExportInfo} */ (
+				exportsInfo.getReadOnlyExportInfo(name)
+			);
+			const used = exportInfo.getUsed(runtime);
+			if (used === UsageState.Unused) return Dependency.NO_EXPORTS_REFERENCED;
+			if (used !== UsageState.OnlyPropertiesUsed) return getFullResult();
+			exportsInfo = exportInfo.exportsInfo;
+			if (!exportsInfo) return getFullResult();
+		}
+		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+			return getFullResult();
+		}
+		/** @type {string[][]} */
+		const referencedExports = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			processExportInfo(
+				runtime,
+				referencedExports,
+				ids.concat(exportInfo.name),
+				exportInfo,
+				false
+			);
+		}
+		return referencedExports.map(name => ({
+			name,
+			canMangle: false
+		}));
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		if (this.names.length === 1) {
+			const ids = this.getIds(moduleGraph);
+			const name = this.names[0];
+			const from = moduleGraph.getConnection(this);
+			if (!from) return;
+			return {
+				exports: [
+					{
+						name,
+						from,
+						export: ids.length === 0 ? null : ids,
+						// we can't mangle names that are in an empty object
+						// because one could access the prototype property
+						// when export isn't set yet
+						canMangle: !(name in EMPTY_OBJECT) && false
+					}
+				],
+				dependencies: [from.module]
+			};
+		} else if (this.names.length > 0) {
+			const name = this.names[0];
+			return {
+				exports: [
+					{
+						name,
+						// we can't mangle names that are in an empty object
+						// because one could access the prototype property
+						// when export isn't set yet
+						canMangle: !(name in EMPTY_OBJECT) && false
+					}
+				],
+				dependencies: undefined
+			};
+		}
+		const from = moduleGraph.getConnection(this);
+		if (!from) return;
+		const reexportInfo = this.getStarReexports(
+			moduleGraph,
+			undefined,
+			from.module
+		);
+		const ids = this.getIds(moduleGraph);
+		if (reexportInfo) {
+			return {
+				exports: Array.from(
+					/** @type {Set<string>} */
+					(reexportInfo.exports),
+					name => ({
+						name,
+						from,
+						export: ids.concat(name),
+						canMangle: !(name in EMPTY_OBJECT) && false
+					})
+				),
+				// TODO handle deep reexports
+				dependencies: [from.module]
+			};
+		}
+		return {
+			exports: true,
+			from: ids.length === 0 ? from : undefined,
+			canMangle: false,
+			dependencies: [from.module]
+		};
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Module} importedModule the imported module (optional)
+	 * @returns {{exports?: Set<string>, checked?: Set<string>} | undefined} information
+	 */
+	getStarReexports(
+		moduleGraph,
+		runtime,
+		importedModule = /** @type {Module} */ (moduleGraph.getModule(this))
+	) {
+		/** @type {ExportsInfo | undefined} */
+		let importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+		const ids = this.getIds(moduleGraph);
+		if (ids.length > 0)
+			importedExportsInfo = importedExportsInfo.getNestedExportsInfo(ids);
+		/** @type {ExportsInfo | undefined} */
+		let exportsInfo = moduleGraph.getExportsInfo(
+			/** @type {Module} */ (moduleGraph.getParentModule(this))
+		);
+		if (this.names.length > 0)
+			exportsInfo = exportsInfo.getNestedExportsInfo(this.names);
+
+		const noExtraExports =
+			importedExportsInfo &&
+			importedExportsInfo.otherExportsInfo.provided === false;
+		const noExtraImports =
+			exportsInfo &&
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
+
+		if (!noExtraExports && !noExtraImports) {
+			return;
+		}
+
+		const isNamespaceImport =
+			importedModule.getExportsType(moduleGraph, false) === "namespace";
+
+		/** @type {Set<string>} */
+		const exports = new Set();
+		/** @type {Set<string>} */
+		const checked = new Set();
+
+		if (noExtraImports) {
+			for (const exportInfo of /** @type {ExportsInfo} */ (exportsInfo)
+				.orderedExports) {
+				const name = exportInfo.name;
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				if (name === "__esModule" && isNamespaceImport) {
+					exports.add(name);
+				} else if (importedExportsInfo) {
+					const importedExportInfo =
+						importedExportsInfo.getReadOnlyExportInfo(name);
+					if (importedExportInfo.provided === false) continue;
+					exports.add(name);
+					if (importedExportInfo.provided === true) continue;
+					checked.add(name);
+				} else {
+					exports.add(name);
+					checked.add(name);
+				}
+			}
+		} else if (noExtraExports) {
+			for (const importedExportInfo of /** @type {ExportsInfo} */ (
+				importedExportsInfo
+			).orderedExports) {
+				const name = importedExportInfo.name;
+				if (importedExportInfo.provided === false) continue;
+				if (exportsInfo) {
+					const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+					if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
+			}
+			if (isNamespaceImport) {
+				exports.add("__esModule");
+				checked.delete("__esModule");
+			}
+		}
+
+		return { exports, checked };
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.asiSafe);
+		write(this.range);
+		write(this.valueRange);
+		write(this.base);
+		write(this.names);
+		write(this.ids);
+		write(this.resultUsed);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.asiSafe = read();
+		this.range = read();
+		this.valueRange = read();
+		this.base = read();
+		this.names = read();
+		this.ids = read();
+		this.resultUsed = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CommonJsExportRequireDependency,
+	"webpack/lib/dependencies/CommonJsExportRequireDependency"
+);
+
+CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependencyTemplate extends (
+	ModuleDependency.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,
+		{
+			module,
+			runtimeTemplate,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtime
+		}
+	) {
+		const dep = /** @type {CommonJsExportRequireDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.names, runtime);
+
+		const [type, base] = handleDependencyBase(
+			dep.base,
+			module,
+			runtimeRequirements
+		);
+
+		const importedModule = moduleGraph.getModule(dep);
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+		if (importedModule) {
+			const ids = dep.getIds(moduleGraph);
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: `${Template.toNormalComment(propertyAccess(ids))} `;
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			}
+		}
+
+		switch (type) {
+			case "expression":
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					used
+						? `${base}${propertyAccess(used)} = ${requireExpr}`
+						: `/* unused reexport */ ${requireExpr}`
+				);
+				return;
+			case "Object.defineProperty":
+				throw new Error("TODO");
+			default:
+				throw new Error("Unexpected type");
+		}
+	}
+};
+
+module.exports = CommonJsExportRequireDependency;

app_vue/node_modules/webpack/lib/dependencies/CommonJsExportsDependency.js

@@ -0,0 +1,183 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const InitFragment = require("../InitFragment");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const { handleDependencyBase } = require("./CommonJsDependencyHelpers");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+
+const EMPTY_OBJECT = {};
+
+class CommonJsExportsDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range | null} valueRange value range
+	 * @param {CommonJSDependencyBaseKeywords} base base
+	 * @param {string[]} names names
+	 */
+	constructor(range, valueRange, base, names) {
+		super();
+		this.range = range;
+		this.valueRange = valueRange;
+		this.base = base;
+		this.names = names;
+	}
+
+	get type() {
+		return "cjs exports";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.names[0];
+		return {
+			exports: [
+				{
+					name,
+					// we can't mangle names that are in an empty object
+					// because one could access the prototype property
+					// when export isn't set yet
+					canMangle: !(name in EMPTY_OBJECT)
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.valueRange);
+		write(this.base);
+		write(this.names);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.valueRange = read();
+		this.base = read();
+		this.names = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CommonJsExportsDependency,
+	"webpack/lib/dependencies/CommonJsExportsDependency"
+);
+
+CommonJsExportsDependency.Template = class CommonJsExportsDependencyTemplate 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,
+		{ module, moduleGraph, initFragments, runtimeRequirements, runtime }
+	) {
+		const dep = /** @type {CommonJsExportsDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.names, runtime);
+
+		const [type, base] = handleDependencyBase(
+			dep.base,
+			module,
+			runtimeRequirements
+		);
+
+		switch (type) {
+			case "expression":
+				if (!used) {
+					initFragments.push(
+						new InitFragment(
+							"var __webpack_unused_export__;\n",
+							InitFragment.STAGE_CONSTANTS,
+							0,
+							"__webpack_unused_export__"
+						)
+					);
+					source.replace(
+						dep.range[0],
+						dep.range[1] - 1,
+						"__webpack_unused_export__"
+					);
+					return;
+				}
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					`${base}${propertyAccess(used)}`
+				);
+				return;
+			case "Object.defineProperty":
+				if (!used) {
+					initFragments.push(
+						new InitFragment(
+							"var __webpack_unused_export__;\n",
+							InitFragment.STAGE_CONSTANTS,
+							0,
+							"__webpack_unused_export__"
+						)
+					);
+					source.replace(
+						dep.range[0],
+						/** @type {Range} */ (dep.valueRange)[0] - 1,
+						"__webpack_unused_export__ = ("
+					);
+					source.replace(
+						/** @type {Range} */ (dep.valueRange)[1],
+						dep.range[1] - 1,
+						")"
+					);
+					return;
+				}
+				source.replace(
+					dep.range[0],
+					/** @type {Range} */ (dep.valueRange)[0] - 1,
+					`Object.defineProperty(${base}${propertyAccess(
+						used.slice(0, -1)
+					)}, ${JSON.stringify(used[used.length - 1])}, (`
+				);
+				source.replace(
+					/** @type {Range} */ (dep.valueRange)[1],
+					dep.range[1] - 1,
+					"))"
+				);
+		}
+	}
+};
+
+module.exports = CommonJsExportsDependency;

app_vue/node_modules/webpack/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -0,0 +1,411 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const formatLocation = require("../formatLocation");
+const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
+const propertyAccess = require("../util/propertyAccess");
+const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
+const CommonJsExportsDependency = require("./CommonJsExportsDependency");
+const CommonJsSelfReferenceDependency = require("./CommonJsSelfReferenceDependency");
+const DynamicExports = require("./DynamicExports");
+const HarmonyExports = require("./HarmonyExports");
+const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
+
+/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Super} Super */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").StatementPath} StatementPath */
+/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+
+/**
+ * This function takes a generic expression and detects whether it is an ObjectExpression.
+ * This is used in the context of parsing CommonJS exports to get the value of the property descriptor
+ * when the `exports` object is assigned to `Object.defineProperty`.
+ *
+ * In CommonJS modules, the `exports` object can be assigned to `Object.defineProperty` and therefore
+ * webpack has to detect this case and get the value key of the property descriptor. See the following example
+ * for more information: https://astexplorer.net/#/gist/83ce51a4e96e59d777df315a6d111da6/8058ead48a1bb53c097738225db0967ef7f70e57
+ *
+ * This would be an example of a CommonJS module that exports an object with a property descriptor:
+ * ```js
+ * Object.defineProperty(exports, "__esModule", { value: true });
+ * exports.foo = void 0;
+ * exports.foo = "bar";
+ * ```
+ * @param {Expression} expr expression
+ * @returns {Expression | undefined} returns the value of property descriptor
+ */
+const getValueOfPropertyDescription = expr => {
+	if (expr.type !== "ObjectExpression") return;
+	for (const property of expr.properties) {
+		if (property.type === "SpreadElement" || property.computed) continue;
+		const key = property.key;
+		if (key.type !== "Identifier" || key.name !== "value") continue;
+		return /** @type {Expression} */ (property.value);
+	}
+};
+
+/**
+ * The purpose of this function is to check whether an expression is a truthy literal or not. This is
+ * useful when parsing CommonJS exports, because CommonJS modules can export any value, including falsy
+ * values like `null` and `false`. However, exports should only be created if the exported value is truthy.
+ * @param {Expression} expr expression being checked
+ * @returns {boolean} true, when the expression is a truthy literal
+ */
+const isTruthyLiteral = expr => {
+	switch (expr.type) {
+		case "Literal":
+			return Boolean(expr.value);
+		case "UnaryExpression":
+			if (expr.operator === "!") return isFalsyLiteral(expr.argument);
+	}
+	return false;
+};
+
+/**
+ * The purpose of this function is to check whether an expression is a falsy literal or not. This is
+ * useful when parsing CommonJS exports, because CommonJS modules can export any value, including falsy
+ * values like `null` and `false`. However, exports should only be created if the exported value is truthy.
+ * @param {Expression} expr expression being checked
+ * @returns {boolean} true, when the expression is a falsy literal
+ */
+const isFalsyLiteral = expr => {
+	switch (expr.type) {
+		case "Literal":
+			return !expr.value;
+		case "UnaryExpression":
+			if (expr.operator === "!") return isTruthyLiteral(expr.argument);
+	}
+	return false;
+};
+
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {Expression} expr expression
+ * @returns {{ argument: BasicEvaluatedExpression, ids: string[] } | undefined} parsed call
+ */
+const parseRequireCall = (parser, expr) => {
+	const ids = [];
+	while (expr.type === "MemberExpression") {
+		if (expr.object.type === "Super") return;
+		if (!expr.property) return;
+		const prop = expr.property;
+		if (expr.computed) {
+			if (prop.type !== "Literal") return;
+			ids.push(`${prop.value}`);
+		} else {
+			if (prop.type !== "Identifier") return;
+			ids.push(prop.name);
+		}
+		expr = expr.object;
+	}
+	if (expr.type !== "CallExpression" || expr.arguments.length !== 1) return;
+	const callee = expr.callee;
+	if (
+		callee.type !== "Identifier" ||
+		parser.getVariableInfo(callee.name) !== "require"
+	) {
+		return;
+	}
+	const arg = expr.arguments[0];
+	if (arg.type === "SpreadElement") return;
+	const argValue = parser.evaluateExpression(arg);
+	return { argument: argValue, ids: ids.reverse() };
+};
+
+class CommonJsExportsParserPlugin {
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 */
+	constructor(moduleGraph) {
+		this.moduleGraph = moduleGraph;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const enableStructuredExports = () => {
+			DynamicExports.enable(parser.state);
+		};
+
+		/**
+		 * @param {boolean} topLevel true, when the export is on top level
+		 * @param {string[]} members members of the export
+		 * @param {Expression | undefined} valueExpr expression for the value
+		 * @returns {void}
+		 */
+		const checkNamespace = (topLevel, members, valueExpr) => {
+			if (!DynamicExports.isEnabled(parser.state)) return;
+			if (members.length > 0 && members[0] === "__esModule") {
+				if (valueExpr && isTruthyLiteral(valueExpr) && topLevel) {
+					DynamicExports.setFlagged(parser.state);
+				} else {
+					DynamicExports.setDynamic(parser.state);
+				}
+			}
+		};
+		/**
+		 * @param {string=} reason reason
+		 */
+		const bailout = reason => {
+			DynamicExports.bailout(parser.state);
+			if (reason) bailoutHint(reason);
+		};
+		/**
+		 * @param {string} reason reason
+		 */
+		const bailoutHint = reason => {
+			this.moduleGraph
+				.getOptimizationBailout(parser.state.module)
+				.push(`CommonJS bailout: ${reason}`);
+		};
+
+		// metadata //
+		parser.hooks.evaluateTypeof
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", evaluateToString("object"));
+		parser.hooks.evaluateTypeof
+			.for("exports")
+			.tap("CommonJsPlugin", evaluateToString("object"));
+
+		// exporting //
+
+		/**
+		 * @param {AssignmentExpression} expr expression
+		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
+		 * @param {string[]} members members of the export
+		 * @returns {boolean | undefined} true, when the expression was handled
+		 */
+		const handleAssignExport = (expr, base, members) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			// Handle reexporting
+			const requireCall = parseRequireCall(parser, expr.right);
+			if (
+				requireCall &&
+				requireCall.argument.isString() &&
+				(members.length === 0 || members[0] !== "__esModule")
+			) {
+				enableStructuredExports();
+				// It's possible to reexport __esModule, so we must convert to a dynamic module
+				if (members.length === 0) DynamicExports.setDynamic(parser.state);
+				const dep = new CommonJsExportRequireDependency(
+					/** @type {Range} */ (expr.range),
+					null,
+					base,
+					members,
+					/** @type {string} */ (requireCall.argument.string),
+					requireCall.ids,
+					!parser.isStatementLevelExpression(expr)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.module.addDependency(dep);
+				return true;
+			}
+			if (members.length === 0) return;
+			enableStructuredExports();
+			const remainingMembers = members;
+			checkNamespace(
+				/** @type {StatementPath} */
+				(parser.statementPath).length === 1 &&
+					parser.isStatementLevelExpression(expr),
+				remainingMembers,
+				expr.right
+			);
+			const dep = new CommonJsExportsDependency(
+				/** @type {Range} */ (expr.left.range),
+				null,
+				base,
+				remainingMembers
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addDependency(dep);
+			parser.walkExpression(expr.right);
+			return true;
+		};
+		parser.hooks.assignMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) =>
+				handleAssignExport(expr, "exports", members)
+			);
+		parser.hooks.assignMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAssignExport(expr, "this", members);
+			});
+		parser.hooks.assignMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAssignExport(expr, "module.exports", members.slice(1));
+			});
+		parser.hooks.call
+			.for("Object.defineProperty")
+			.tap("CommonJsExportsParserPlugin", expression => {
+				const expr = /** @type {CallExpression} */ (expression);
+				if (!parser.isStatementLevelExpression(expr)) return;
+				if (expr.arguments.length !== 3) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				if (expr.arguments[1].type === "SpreadElement") return;
+				if (expr.arguments[2].type === "SpreadElement") return;
+				const exportsArg = parser.evaluateExpression(expr.arguments[0]);
+				if (!exportsArg.isIdentifier()) return;
+				if (
+					exportsArg.identifier !== "exports" &&
+					exportsArg.identifier !== "module.exports" &&
+					(exportsArg.identifier !== "this" || !parser.scope.topLevelScope)
+				) {
+					return;
+				}
+				const propertyArg = parser.evaluateExpression(expr.arguments[1]);
+				const property = propertyArg.asString();
+				if (typeof property !== "string") return;
+				enableStructuredExports();
+				const descArg = expr.arguments[2];
+				checkNamespace(
+					/** @type {StatementPath} */
+					(parser.statementPath).length === 1,
+					[property],
+					getValueOfPropertyDescription(descArg)
+				);
+				const dep = new CommonJsExportsDependency(
+					/** @type {Range} */ (expr.range),
+					/** @type {Range} */ (expr.arguments[2].range),
+					`Object.defineProperty(${exportsArg.identifier})`,
+					[property]
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+
+				parser.walkExpression(expr.arguments[2]);
+				return true;
+			});
+
+		// Self reference //
+
+		/**
+		 * @param {Expression | Super} expr expression
+		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
+		 * @param {string[]} members members of the export
+		 * @param {CallExpression=} call call expression
+		 * @returns {boolean | void} true, when the expression was handled
+		 */
+		const handleAccessExport = (expr, base, members, call) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			if (members.length === 0) {
+				bailout(
+					`${base} is used directly at ${formatLocation(
+						/** @type {DependencyLocation} */ (expr.loc)
+					)}`
+				);
+			}
+			if (call && members.length === 1) {
+				bailoutHint(
+					`${base}${propertyAccess(
+						members
+					)}(...) prevents optimization as ${base} is passed as call context at ${formatLocation(
+						/** @type {DependencyLocation} */ (expr.loc)
+					)}`
+				);
+			}
+			const dep = new CommonJsSelfReferenceDependency(
+				/** @type {Range} */ (expr.range),
+				base,
+				members,
+				Boolean(call)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addDependency(dep);
+			if (call) {
+				parser.walkExpressions(call.arguments);
+			}
+			return true;
+		};
+		parser.hooks.callMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) =>
+				handleAccessExport(expr.callee, "exports", members, expr)
+			);
+		parser.hooks.expressionMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) =>
+				handleAccessExport(expr, "exports", members)
+			);
+		parser.hooks.expression
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", expr =>
+				handleAccessExport(expr, "exports", [])
+			);
+		parser.hooks.callMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAccessExport(
+					expr.callee,
+					"module.exports",
+					members.slice(1),
+					expr
+				);
+			});
+		parser.hooks.expressionMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAccessExport(expr, "module.exports", members.slice(1));
+			});
+		parser.hooks.expression
+			.for("module.exports")
+			.tap("CommonJsExportsParserPlugin", expr =>
+				handleAccessExport(expr, "module.exports", [])
+			);
+		parser.hooks.callMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr.callee, "this", members, expr);
+			});
+		parser.hooks.expressionMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr, "this", members);
+			});
+		parser.hooks.expression
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr, "this", []);
+			});
+
+		// Bailouts //
+		parser.hooks.expression.for("module").tap("CommonJsPlugin", expr => {
+			bailout();
+			const isHarmony = HarmonyExports.isEnabled(parser.state);
+			const dep = new ModuleDecoratorDependency(
+				isHarmony
+					? RuntimeGlobals.harmonyModuleDecorator
+					: RuntimeGlobals.nodeModuleDecorator,
+				!isHarmony
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addDependency(dep);
+			return true;
+		});
+	}
+}
+module.exports = CommonJsExportsParserPlugin;

app_vue/node_modules/webpack/lib/dependencies/CommonJsFullRequireDependency.js

@@ -0,0 +1,166 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Template = require("../Template");
+const { equals } = require("../util/ArrayHelpers");
+const { getTrimmedIdsAndRange } = require("../util/chainedImports");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CommonJsFullRequireDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 * @param {string[]} names accessed properties on module
+	 * @param {Range[]=} idRanges ranges for members of ids; the two arrays are right-aligned
+	 */
+	constructor(
+		request,
+		range,
+		names,
+		idRanges /* TODO webpack 6 make this non-optional. It must always be set to properly trim ids. */
+	) {
+		super(request);
+		this.range = range;
+		this.names = names;
+		this.idRanges = idRanges;
+		this.call = false;
+		this.asiSafe = undefined;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (this.call) {
+			const importedModule = moduleGraph.getModule(this);
+			if (
+				!importedModule ||
+				importedModule.getExportsType(moduleGraph, false) !== "namespace"
+			) {
+				return [this.names.slice(0, -1)];
+			}
+		}
+		return [this.names];
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.names);
+		write(this.idRanges);
+		write(this.call);
+		write(this.asiSafe);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.names = read();
+		this.idRanges = read();
+		this.call = read();
+		this.asiSafe = read();
+		super.deserialize(context);
+	}
+
+	get type() {
+		return "cjs full require";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemplate extends (
+	ModuleDependency.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,
+		{
+			module,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime,
+			initFragments
+		}
+	) {
+		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
+		if (!dep.range) return;
+		const importedModule = moduleGraph.getModule(dep);
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+
+		const {
+			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
+			trimmedIds
+		} = getTrimmedIdsAndRange(
+			dep.names,
+			dep.range,
+			dep.idRanges,
+			moduleGraph,
+			dep
+		);
+
+		if (importedModule) {
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(trimmedIds, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, trimmedIds)
+					? ""
+					: `${Template.toNormalComment(propertyAccess(trimmedIds))} `;
+				const access = `${comment}${propertyAccess(usedImported)}`;
+				requireExpr =
+					dep.asiSafe === true
+						? `(${requireExpr}${access})`
+						: `${requireExpr}${access}`;
+			}
+		}
+		source.replace(trimmedRangeStart, trimmedRangeEnd - 1, requireExpr);
+	}
+};
+
+makeSerializable(
+	CommonJsFullRequireDependency,
+	"webpack/lib/dependencies/CommonJsFullRequireDependency"
+);
+
+module.exports = CommonJsFullRequireDependency;

app_vue/node_modules/webpack/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -0,0 +1,814 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { fileURLToPath } = require("url");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const WebpackError = require("../WebpackError");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { VariableInfo } = require("../javascript/JavascriptParser");
+const {
+	evaluateToIdentifier,
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+const CommonJsFullRequireDependency = require("./CommonJsFullRequireDependency");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const ConstDependency = require("./ConstDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const { getLocalModule } = require("./LocalModulesHelpers");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").NewExpression} NewExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const createRequireSpecifierTag = Symbol("createRequire");
+const createdRequireIdentifierTag = Symbol("createRequire()");
+
+class CommonJsImportsParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parser options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const options = this.options;
+
+		const getContext = () => {
+			if (parser.currentTagData) {
+				const { context } = parser.currentTagData;
+				return context;
+			}
+		};
+
+		// #region metadata
+		/**
+		 * @param {string} expression expression
+		 * @param {() => string[]} getMembers get members
+		 */
+		const tapRequireExpression = (expression, getMembers) => {
+			parser.hooks.typeof
+				.for(expression)
+				.tap(
+					"CommonJsImportsParserPlugin",
+					toConstantDependency(parser, JSON.stringify("function"))
+				);
+			parser.hooks.evaluateTypeof
+				.for(expression)
+				.tap("CommonJsImportsParserPlugin", evaluateToString("function"));
+			parser.hooks.evaluateIdentifier
+				.for(expression)
+				.tap(
+					"CommonJsImportsParserPlugin",
+					evaluateToIdentifier(expression, "require", getMembers, true)
+				);
+		};
+		/**
+		 * @param {string | symbol} tag tag
+		 */
+		const tapRequireExpressionTag = tag => {
+			parser.hooks.typeof
+				.for(tag)
+				.tap(
+					"CommonJsImportsParserPlugin",
+					toConstantDependency(parser, JSON.stringify("function"))
+				);
+			parser.hooks.evaluateTypeof
+				.for(tag)
+				.tap("CommonJsImportsParserPlugin", evaluateToString("function"));
+		};
+		tapRequireExpression("require", () => []);
+		tapRequireExpression("require.resolve", () => ["resolve"]);
+		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
+		// #endregion
+
+		// Weird stuff //
+		parser.hooks.assign
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", expr => {
+				// to not leak to global "require", we need to define a local require here.
+				const dep = new ConstDependency("var require;", 0);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			});
+
+		// #region Unsupported
+		parser.hooks.expression
+			.for("require.main")
+			.tap(
+				"CommonJsImportsParserPlugin",
+				expressionIsUnsupported(
+					parser,
+					"require.main is not supported by webpack."
+				)
+			);
+		parser.hooks.call
+			.for("require.main.require")
+			.tap(
+				"CommonJsImportsParserPlugin",
+				expressionIsUnsupported(
+					parser,
+					"require.main.require is not supported by webpack."
+				)
+			);
+		parser.hooks.expression
+			.for("module.parent.require")
+			.tap(
+				"CommonJsImportsParserPlugin",
+				expressionIsUnsupported(
+					parser,
+					"module.parent.require is not supported by webpack."
+				)
+			);
+		parser.hooks.call
+			.for("module.parent.require")
+			.tap(
+				"CommonJsImportsParserPlugin",
+				expressionIsUnsupported(
+					parser,
+					"module.parent.require is not supported by webpack."
+				)
+			);
+		// #endregion
+
+		// #region Renaming
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when set undefined
+		 */
+		const defineUndefined = expr => {
+			// To avoid "not defined" error, replace the value with undefined
+			const dep = new ConstDependency(
+				"undefined",
+				/** @type {Range} */ (expr.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return false;
+		};
+		parser.hooks.canRename
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", () => true);
+		parser.hooks.rename
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", defineUndefined);
+		// #endregion
+
+		// #region Inspection
+		const requireCache = toConstantDependency(
+			parser,
+			RuntimeGlobals.moduleCache,
+			[
+				RuntimeGlobals.moduleCache,
+				RuntimeGlobals.moduleId,
+				RuntimeGlobals.moduleLoaded
+			]
+		);
+
+		parser.hooks.expression
+			.for("require.cache")
+			.tap("CommonJsImportsParserPlugin", requireCache);
+		// #endregion
+
+		// #region Require as expression
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when handled
+		 */
+		const requireAsExpressionHandler = expr => {
+			const dep = new CommonJsRequireContextDependency(
+				{
+					request: /** @type {string} */ (options.unknownContextRequest),
+					recursive: /** @type {boolean} */ (options.unknownContextRecursive),
+					regExp: /** @type {RegExp} */ (options.unknownContextRegExp),
+					mode: "sync"
+				},
+				/** @type {Range} */ (expr.range),
+				undefined,
+				parser.scope.inShorthand,
+				getContext()
+			);
+			dep.critical =
+				options.unknownContextCritical &&
+				"require function is used in a way in which dependencies cannot be statically extracted";
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		};
+		parser.hooks.expression
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", requireAsExpressionHandler);
+		// #endregion
+
+		// #region Require
+		/**
+		 * @param {CallExpression | NewExpression} expr expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @returns {boolean | void} true when handled
+		 */
+		const processRequireItem = (expr, param) => {
+			if (param.isString()) {
+				const dep = new CommonJsRequireDependency(
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (param.range),
+					getContext()
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		/**
+		 * @param {CallExpression | NewExpression} expr expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @returns {boolean | void} true when handled
+		 */
+		const processRequireContext = (expr, param) => {
+			const dep = ContextDependencyHelpers.create(
+				CommonJsRequireContextDependency,
+				/** @type {Range} */ (expr.range),
+				param,
+				expr,
+				options,
+				{
+					category: "commonjs"
+				},
+				parser,
+				undefined,
+				getContext()
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		};
+		/**
+		 * @param {boolean} callNew true, when require is called with new
+		 * @returns {(expr: CallExpression | NewExpression) => (boolean | void)} handler
+		 */
+		const createRequireHandler = callNew => expr => {
+			if (options.commonjsMagicComments) {
+				const { options: requireOptions, errors: commentErrors } =
+					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+				if (commentErrors) {
+					for (const e of commentErrors) {
+						const { comment } = e;
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								/** @type {DependencyLocation} */ (comment.loc)
+							)
+						);
+					}
+				}
+				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+					if (typeof requireOptions.webpackIgnore !== "boolean") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else if (requireOptions.webpackIgnore) {
+						// Do not instrument `require()` if `webpackIgnore` is `true`
+						return true;
+					}
+				}
+			}
+
+			if (expr.arguments.length !== 1) return;
+			let localModule;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (param.isConditional()) {
+				let isExpression = false;
+				for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+					param.options
+				)) {
+					const result = processRequireItem(expr, p);
+					if (result === undefined) {
+						isExpression = true;
+					}
+				}
+				if (!isExpression) {
+					const dep = new RequireHeaderDependency(
+						/** @type {Range} */ (expr.callee.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+					return true;
+				}
+			}
+			if (
+				param.isString() &&
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string)
+				))
+			) {
+				localModule.flagUsed();
+				const dep = new LocalModuleDependency(
+					localModule,
+					/** @type {Range} */ (expr.range),
+					callNew
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+			} else {
+				const result = processRequireItem(expr, param);
+				if (result === undefined) {
+					processRequireContext(expr, param);
+				} else {
+					const dep = new RequireHeaderDependency(
+						/** @type {Range} */ (expr.callee.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+				}
+			}
+			return true;
+		};
+		parser.hooks.call
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		parser.hooks.new
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
+		parser.hooks.call
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		parser.hooks.new
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
+		// #endregion
+
+		// #region Require with property access
+		/**
+		 * @param {Expression} expr expression
+		 * @param {string[]} calleeMembers callee members
+		 * @param {CallExpression} callExpr call expression
+		 * @param {string[]} members members
+		 * @param {Range[]} memberRanges member ranges
+		 * @returns {boolean | void} true when handled
+		 */
+		const chainHandler = (
+			expr,
+			calleeMembers,
+			callExpr,
+			members,
+			memberRanges
+		) => {
+			if (callExpr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(callExpr.arguments[0]);
+			if (
+				param.isString() &&
+				!getLocalModule(parser.state, /** @type {string} */ (param.string))
+			) {
+				const dep = new CommonJsFullRequireDependency(
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.range),
+					members,
+					/** @type {Range[]} */ memberRanges
+				);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
+				dep.optional = Boolean(parser.scope.inTry);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		/**
+		 * @param {CallExpression} expr expression
+		 * @param {string[]} calleeMembers callee members
+		 * @param {CallExpression} callExpr call expression
+		 * @param {string[]} members members
+		 * @param {Range[]} memberRanges member ranges
+		 * @returns {boolean | void} true when handled
+		 */
+		const callChainHandler = (
+			expr,
+			calleeMembers,
+			callExpr,
+			members,
+			memberRanges
+		) => {
+			if (callExpr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(callExpr.arguments[0]);
+			if (
+				param.isString() &&
+				!getLocalModule(parser.state, /** @type {string} */ (param.string))
+			) {
+				const dep = new CommonJsFullRequireDependency(
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.callee.range),
+					members,
+					/** @type {Range[]} */ memberRanges
+				);
+				dep.call = true;
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
+				dep.optional = Boolean(parser.scope.inTry);
+				dep.loc = /** @type {DependencyLocation} */ (expr.callee.loc);
+				parser.state.current.addDependency(dep);
+				parser.walkExpressions(expr.arguments);
+				return true;
+			}
+		};
+		parser.hooks.memberChainOfCallMemberChain
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", chainHandler);
+		parser.hooks.memberChainOfCallMemberChain
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", chainHandler);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", callChainHandler);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", callChainHandler);
+		// #endregion
+
+		// #region Require.resolve
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
+		const processResolve = (expr, weak) => {
+			if (!weak && options.commonjsMagicComments) {
+				const { options: requireOptions, errors: commentErrors } =
+					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+				if (commentErrors) {
+					for (const e of commentErrors) {
+						const { comment } = e;
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								/** @type {DependencyLocation} */ (comment.loc)
+							)
+						);
+					}
+				}
+				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+					if (typeof requireOptions.webpackIgnore !== "boolean") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else if (requireOptions.webpackIgnore) {
+						// Do not instrument `require()` if `webpackIgnore` is `true`
+						return true;
+					}
+				}
+			}
+
+			if (expr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (param.isConditional()) {
+				for (const option of /** @type {BasicEvaluatedExpression[]} */ (
+					param.options
+				)) {
+					const result = processResolveItem(expr, option, weak);
+					if (result === undefined) {
+						processResolveContext(expr, option, weak);
+					}
+				}
+				const dep = new RequireResolveHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+			const result = processResolveItem(expr, param, weak);
+			if (result === undefined) {
+				processResolveContext(expr, param, weak);
+			}
+			const dep = new RequireResolveHeaderDependency(
+				/** @type {Range} */ (expr.callee.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		};
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
+		const processResolveItem = (expr, param, weak) => {
+			if (param.isString()) {
+				const dep = new RequireResolveDependency(
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (param.range),
+					getContext()
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				dep.weak = weak;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
+		const processResolveContext = (expr, param, weak) => {
+			const dep = ContextDependencyHelpers.create(
+				RequireResolveContextDependency,
+				/** @type {Range} */ (param.range),
+				param,
+				expr,
+				options,
+				{
+					category: "commonjs",
+					mode: weak ? "weak" : "sync"
+				},
+				parser,
+				getContext()
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		};
+
+		parser.hooks.call
+			.for("require.resolve")
+			.tap("CommonJsImportsParserPlugin", expr => processResolve(expr, false));
+		parser.hooks.call
+			.for("require.resolveWeak")
+			.tap("CommonJsImportsParserPlugin", expr => processResolve(expr, true));
+		// #endregion
+
+		// #region Create require
+
+		if (!options.createRequire) return;
+
+		/** @type {ImportSource[]} */
+		let moduleName = [];
+		/** @type {string | undefined} */
+		let specifierName;
+
+		if (options.createRequire === true) {
+			moduleName = ["module", "node:module"];
+			specifierName = "createRequire";
+		} else {
+			let moduleName;
+			const match = /^(.*) from (.*)$/.exec(options.createRequire);
+			if (match) {
+				[, specifierName, moduleName] = match;
+			}
+			if (!specifierName || !moduleName) {
+				const err = new WebpackError(
+					`Parsing javascript parser option "createRequire" failed, got ${JSON.stringify(
+						options.createRequire
+					)}`
+				);
+				err.details =
+					'Expected string in format "createRequire from module", where "createRequire" is specifier name and "module" name of the module';
+				throw err;
+			}
+		}
+
+		tapRequireExpressionTag(createdRequireIdentifierTag);
+		tapRequireExpressionTag(createRequireSpecifierTag);
+		parser.hooks.evaluateCallExpression
+			.for(createRequireSpecifierTag)
+			.tap("CommonJsImportsParserPlugin", expr => {
+				const context = parseCreateRequireArguments(expr);
+				if (context === undefined) return;
+				const ident = parser.evaluatedVariable({
+					tag: createdRequireIdentifierTag,
+					data: { context },
+					next: undefined
+				});
+
+				return new BasicEvaluatedExpression()
+					.setIdentifier(ident, ident, () => [])
+					.setSideEffects(false)
+					.setRange(/** @type {Range} */ (expr.range));
+			});
+		parser.hooks.unhandledExpressionMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap("CommonJsImportsParserPlugin", (expr, members) =>
+				expressionIsUnsupported(
+					parser,
+					`createRequire().${members.join(".")} is not supported by webpack.`
+				)(expr)
+			);
+		parser.hooks.canRename
+			.for(createdRequireIdentifierTag)
+			.tap("CommonJsImportsParserPlugin", () => true);
+		parser.hooks.canRename
+			.for(createRequireSpecifierTag)
+			.tap("CommonJsImportsParserPlugin", () => true);
+		parser.hooks.rename
+			.for(createRequireSpecifierTag)
+			.tap("CommonJsImportsParserPlugin", defineUndefined);
+		parser.hooks.expression
+			.for(createdRequireIdentifierTag)
+			.tap("CommonJsImportsParserPlugin", requireAsExpressionHandler);
+		parser.hooks.call
+			.for(createdRequireIdentifierTag)
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @returns {string | void} context
+		 */
+		const parseCreateRequireArguments = expr => {
+			const args = expr.arguments;
+			if (args.length !== 1) {
+				const err = new WebpackError(
+					"module.createRequire supports only one argument."
+				);
+				err.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addWarning(err);
+				return;
+			}
+			const arg = args[0];
+			const evaluated = parser.evaluateExpression(arg);
+			if (!evaluated.isString()) {
+				const err = new WebpackError(
+					"module.createRequire failed parsing argument."
+				);
+				err.loc = /** @type {DependencyLocation} */ (arg.loc);
+				parser.state.module.addWarning(err);
+				return;
+			}
+			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
+				? fileURLToPath(/** @type {string} */ (evaluated.string))
+				: /** @type {string} */ (evaluated.string);
+			// argument always should be a filename
+			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
+		};
+
+		parser.hooks.import.tap(
+			{
+				name: "CommonJsImportsParserPlugin",
+				stage: -10
+			},
+			(statement, source) => {
+				if (
+					!moduleName.includes(source) ||
+					statement.specifiers.length !== 1 ||
+					statement.specifiers[0].type !== "ImportSpecifier" ||
+					statement.specifiers[0].imported.type !== "Identifier" ||
+					statement.specifiers[0].imported.name !== specifierName
+				)
+					return;
+				// clear for 'import { createRequire as x } from "module"'
+				// if any other specifier was used import module
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				return true;
+			}
+		);
+		parser.hooks.importSpecifier.tap(
+			{
+				name: "CommonJsImportsParserPlugin",
+				stage: -10
+			},
+			(statement, source, id, name) => {
+				if (!moduleName.includes(source) || id !== specifierName) return;
+				parser.tagVariable(name, createRequireSpecifierTag);
+				return true;
+			}
+		);
+		parser.hooks.preDeclarator.tap(
+			"CommonJsImportsParserPlugin",
+			declarator => {
+				if (
+					declarator.id.type !== "Identifier" ||
+					!declarator.init ||
+					declarator.init.type !== "CallExpression" ||
+					declarator.init.callee.type !== "Identifier"
+				)
+					return;
+				const variableInfo = parser.getVariableInfo(
+					declarator.init.callee.name
+				);
+				if (
+					variableInfo instanceof VariableInfo &&
+					variableInfo.tagInfo &&
+					variableInfo.tagInfo.tag === createRequireSpecifierTag
+				) {
+					const context = parseCreateRequireArguments(declarator.init);
+					if (context === undefined) return;
+					parser.tagVariable(declarator.id.name, createdRequireIdentifierTag, {
+						name: declarator.id.name,
+						context
+					});
+					return true;
+				}
+			}
+		);
+
+		parser.hooks.memberChainOfCallMemberChain
+			.for(createRequireSpecifierTag)
+			.tap(
+				"CommonJsImportsParserPlugin",
+				(expr, calleeMembers, callExpr, members) => {
+					if (
+						calleeMembers.length !== 0 ||
+						members.length !== 1 ||
+						members[0] !== "cache"
+					)
+						return;
+					// createRequire().cache
+					const context = parseCreateRequireArguments(callExpr);
+					if (context === undefined) return;
+					return requireCache(expr);
+				}
+			);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for(createRequireSpecifierTag)
+			.tap(
+				"CommonJsImportsParserPlugin",
+				(expr, calleeMembers, innerCallExpression, members) => {
+					if (
+						calleeMembers.length !== 0 ||
+						members.length !== 1 ||
+						members[0] !== "resolve"
+					)
+						return;
+					// createRequire().resolve()
+					return processResolve(expr, false);
+				}
+			);
+		parser.hooks.expressionMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap("CommonJsImportsParserPlugin", (expr, members) => {
+				// require.cache
+				if (members.length === 1 && members[0] === "cache") {
+					return requireCache(expr);
+				}
+			});
+		parser.hooks.callMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap("CommonJsImportsParserPlugin", (expr, members) => {
+				// require.resolve()
+				if (members.length === 1 && members[0] === "resolve") {
+					return processResolve(expr, false);
+				}
+			});
+		parser.hooks.call
+			.for(createRequireSpecifierTag)
+			.tap("CommonJsImportsParserPlugin", expr => {
+				const clearDep = new ConstDependency(
+					"/* createRequire() */ undefined",
+					/** @type {Range} */ (expr.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				return true;
+			});
+		// #endregion
+	}
+}
+module.exports = CommonJsImportsParserPlugin;

app_vue/node_modules/webpack/lib/dependencies/CommonJsPlugin.js

@@ -0,0 +1,305 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const SelfModuleFactory = require("../SelfModuleFactory");
+const Template = require("../Template");
+const CommonJsExportsDependency = require("./CommonJsExportsDependency");
+const CommonJsFullRequireDependency = require("./CommonJsFullRequireDependency");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const CommonJsSelfReferenceDependency = require("./CommonJsSelfReferenceDependency");
+const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+const RuntimeRequirementsDependency = require("./RuntimeRequirementsDependency");
+
+const CommonJsExportsParserPlugin = require("./CommonJsExportsParserPlugin");
+const CommonJsImportsParserPlugin = require("./CommonJsImportsParserPlugin");
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
+const {
+	evaluateToIdentifier,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "CommonJsPlugin";
+
+class CommonJsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					CommonJsRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsRequireDependency,
+					new CommonJsRequireDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					CommonJsFullRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsFullRequireDependency,
+					new CommonJsFullRequireDependency.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.dependencyTemplates.set(
+					RequireResolveHeaderDependency,
+					new RequireResolveHeaderDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					RequireHeaderDependency,
+					new RequireHeaderDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					CommonJsExportsDependency,
+					new CommonJsExportsDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					CommonJsExportRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsExportRequireDependency,
+					new CommonJsExportRequireDependency.Template()
+				);
+
+				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
+
+				compilation.dependencyFactories.set(
+					CommonJsSelfReferenceDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsSelfReferenceDependency,
+					new CommonJsSelfReferenceDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ModuleDecoratorDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleDecoratorDependency,
+					new ModuleDecoratorDependency.Template()
+				);
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap(PLUGIN_NAME, (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap(PLUGIN_NAME, (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new HarmonyModuleDecoratorRuntimeModule()
+						);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new NodeModuleDecoratorRuntimeModule()
+						);
+					});
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.commonjs !== undefined && !parserOptions.commonjs)
+						return;
+					parser.hooks.typeof
+						.for("module")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+
+					parser.hooks.expression
+						.for("require.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`,
+								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
+							)
+						);
+					parser.hooks.expression
+						.for(RuntimeGlobals.moduleLoaded)
+						.tap(PLUGIN_NAME, expr => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
+								RuntimeGlobals.moduleLoaded;
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleLoaded
+							]);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					parser.hooks.expression
+						.for(RuntimeGlobals.moduleId)
+						.tap(PLUGIN_NAME, expr => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
+								RuntimeGlobals.moduleId;
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleId
+							]);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					parser.hooks.evaluateIdentifier.for("module.hot").tap(
+						PLUGIN_NAME,
+						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
+					);
+
+					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
+					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
+						parser
+					);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("harmony module decorator");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
+		return Template.asString([
+			`${
+				RuntimeGlobals.harmonyModuleDecorator
+			} = ${runtimeTemplate.basicFunction("module", [
+				"module = Object.create(module);",
+				"if (!module.children) module.children = [];",
+				"Object.defineProperty(module, 'exports', {",
+				Template.indent([
+					"enumerable: true,",
+					`set: ${runtimeTemplate.basicFunction("", [
+						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
+					])}`
+				]),
+				"});",
+				"return module;"
+			])};`
+		]);
+	}
+}
+
+class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("node module decorator");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
+		return Template.asString([
+			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
+				"module",
+				[
+					"module.paths = [];",
+					"if (!module.children) module.children = [];",
+					"return module;"
+				]
+			)};`
+		]);
+	}
+}
+
+module.exports = CommonJsPlugin;

app_vue/node_modules/webpack/lib/dependencies/CommonJsRequireContextDependency.js

@@ -0,0 +1,73 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+class CommonJsRequireContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options for the context module
+	 * @param {Range} range location in source code
+	 * @param {Range | undefined} valueRange location of the require call
+	 * @param {boolean | string } inShorthand true or name
+	 * @param {string} context context
+	 */
+	constructor(options, range, valueRange, inShorthand, context) {
+		super(options, context);
+
+		this.range = range;
+		this.valueRange = valueRange;
+		// inShorthand must be serialized by subclasses that use it
+		this.inShorthand = inShorthand;
+	}
+
+	get type() {
+		return "cjs require context";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+		write(this.valueRange);
+		write(this.inShorthand);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+		this.valueRange = read();
+		this.inShorthand = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CommonJsRequireContextDependency,
+	"webpack/lib/dependencies/CommonJsRequireContextDependency"
+);
+
+CommonJsRequireContextDependency.Template =
+	ContextDependencyTemplateAsRequireCall;
+
+module.exports = CommonJsRequireContextDependency;

app_vue/node_modules/webpack/lib/dependencies/CommonJsRequireDependency.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class CommonJsRequireDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range location in source code
+	 * @param {string=} context request context
+	 */
+	constructor(request, range, context) {
+		super(request);
+		this.range = range;
+		this._context = context;
+	}
+
+	get type() {
+		return "cjs require";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+
+makeSerializable(
+	CommonJsRequireDependency,
+	"webpack/lib/dependencies/CommonJsRequireDependency"
+);
+
+module.exports = CommonJsRequireDependency;

app_vue/node_modules/webpack/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -0,0 +1,155 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const { equals } = require("../util/ArrayHelpers");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+
+class CommonJsSelfReferenceDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {CommonJSDependencyBaseKeywords} base base
+	 * @param {string[]} names names
+	 * @param {boolean} call is a call
+	 */
+	constructor(range, base, names, call) {
+		super();
+		this.range = range;
+		this.base = base;
+		this.names = names;
+		this.call = call;
+	}
+
+	get type() {
+		return "cjs self exports reference";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return "self";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [this.call ? this.names.slice(0, -1) : this.names];
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.base);
+		write(this.names);
+		write(this.call);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.base = read();
+		this.names = read();
+		this.call = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CommonJsSelfReferenceDependency,
+	"webpack/lib/dependencies/CommonJsSelfReferenceDependency"
+);
+
+CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate 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,
+		{ module, moduleGraph, runtime, runtimeRequirements }
+	) {
+		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
+		const used =
+			dep.names.length === 0
+				? dep.names
+				: moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+		if (!used) {
+			throw new Error(
+				"Self-reference dependency has unused export name: This should not happen"
+			);
+		}
+
+		let base;
+		switch (dep.base) {
+			case "exports":
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				base = module.exportsArgument;
+				break;
+			case "module.exports":
+				runtimeRequirements.add(RuntimeGlobals.module);
+				base = `${module.moduleArgument}.exports`;
+				break;
+			case "this":
+				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+				base = "this";
+				break;
+			default:
+				throw new Error(`Unsupported base ${dep.base}`);
+		}
+
+		if (base === dep.base && equals(used, dep.names)) {
+			// Nothing has to be changed
+			// We don't use a replacement for compat reasons
+			// for plugins that update `module._source` which they
+			// shouldn't do!
+			return;
+		}
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${base}${propertyAccess(used)}`
+		);
+	}
+};
+
+module.exports = CommonJsSelfReferenceDependency;

app_vue/node_modules/webpack/lib/dependencies/ConstDependency.js

@@ -0,0 +1,117 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class ConstDependency extends NullDependency {
+	/**
+	 * @param {string} expression the expression
+	 * @param {number | Range} range the source range
+	 * @param {(string[] | null)=} runtimeRequirements runtime requirements
+	 */
+	constructor(expression, range, runtimeRequirements) {
+		super();
+		this.expression = expression;
+		this.range = range;
+		this.runtimeRequirements = runtimeRequirements
+			? new Set(runtimeRequirements)
+			: null;
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = `${this.range}|${this.expression}`;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.expression);
+		write(this.range);
+		write(this.runtimeRequirements);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.expression = read();
+		this.range = read();
+		this.runtimeRequirements = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(ConstDependency, "webpack/lib/dependencies/ConstDependency");
+
+ConstDependency.Template = class ConstDependencyTemplate 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, templateContext) {
+		const dep = /** @type {ConstDependency} */ (dependency);
+		if (dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		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;

app_vue/node_modules/webpack/lib/dependencies/ContextDependency.js

@@ -0,0 +1,178 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const DependencyTemplate = require("../DependencyTemplate");
+const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
+
+/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+const getCriticalDependencyWarning = memoize(() =>
+	require("./CriticalDependencyWarning")
+);
+
+/** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
+
+/**
+ * @param {RegExp | null | undefined} r regexp
+ * @returns {string} stringified regexp
+ */
+const regExpToString = r => (r ? String(r) : "");
+
+class ContextDependency extends Dependency {
+	/**
+	 * @param {ContextDependencyOptions} options options for the context module
+	 * @param {string=} context request context
+	 */
+	constructor(options, context) {
+		super();
+
+		this.options = options;
+		this.userRequest = this.options && this.options.request;
+		/** @type {false | undefined | string} */
+		this.critical = false;
+		this.hadGlobalOrStickyRegExp = false;
+
+		if (
+			this.options &&
+			(this.options.regExp.global || this.options.regExp.sticky)
+		) {
+			this.options = { ...this.options, regExp: null };
+			this.hadGlobalOrStickyRegExp = true;
+		}
+
+		this.request = undefined;
+		this.range = undefined;
+		this.valueRange = undefined;
+		/** @type {boolean | string | undefined} */
+		this.inShorthand = undefined;
+		// TODO refactor this
+		this.replaces = undefined;
+		this._requestContext = context;
+	}
+
+	/**
+	 * @returns {string | undefined} a request context
+	 */
+	getContext() {
+		return this._requestContext;
+	}
+
+	get category() {
+		return "commonjs";
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return (
+			`context${this._requestContext || ""}|ctx request${
+				this.options.request
+			} ${this.options.recursive} ` +
+			`${regExpToString(this.options.regExp)} ${regExpToString(
+				this.options.include
+			)} ${regExpToString(this.options.exclude)} ` +
+			`${this.options.mode} ${this.options.chunkName} ` +
+			`${JSON.stringify(this.options.groupOptions)}` +
+			`${
+				this.options.referencedExports
+					? ` ${JSON.stringify(this.options.referencedExports)}`
+					: ""
+			}`
+		);
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		let warnings = super.getWarnings(moduleGraph);
+
+		if (this.critical) {
+			if (!warnings) warnings = [];
+			const CriticalDependencyWarning = getCriticalDependencyWarning();
+			warnings.push(new CriticalDependencyWarning(this.critical));
+		}
+
+		if (this.hadGlobalOrStickyRegExp) {
+			if (!warnings) warnings = [];
+			const CriticalDependencyWarning = getCriticalDependencyWarning();
+			warnings.push(
+				new CriticalDependencyWarning(
+					"Contexts can't use RegExps with the 'g' or 'y' flags."
+				)
+			);
+		}
+
+		return warnings;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.options);
+		write(this.userRequest);
+		write(this.critical);
+		write(this.hadGlobalOrStickyRegExp);
+		write(this.request);
+		write(this._requestContext);
+		write(this.range);
+		write(this.valueRange);
+		write(this.prepend);
+		write(this.replaces);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.options = read();
+		this.userRequest = read();
+		this.critical = read();
+		this.hadGlobalOrStickyRegExp = read();
+		this.request = read();
+		this._requestContext = read();
+		this.range = read();
+		this.valueRange = read();
+		this.prepend = read();
+		this.replaces = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ContextDependency,
+	"webpack/lib/dependencies/ContextDependency"
+);
+
+ContextDependency.Template = DependencyTemplate;
+
+module.exports = ContextDependency;

app_vue/node_modules/webpack/lib/dependencies/ContextDependencyHelpers.js

@@ -0,0 +1,269 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { parseResource } = require("../util/identifier");
+
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency")} ContextDependency */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+/**
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
+ */
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+
+/**
+ * @param {string} prefix prefix
+ * @returns {{prefix: string, context: string}} result
+ */
+const splitContextFromPrefix = prefix => {
+	const idx = prefix.lastIndexOf("/");
+	let context = ".";
+	if (idx >= 0) {
+		context = prefix.slice(0, idx);
+		prefix = `.${prefix.slice(idx)}`;
+	}
+	return {
+		context,
+		prefix
+	};
+};
+
+/** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
+/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: Range, ...args: any[]): ContextDependency }} ContextDependencyConstructor */
+
+/**
+ * @param {ContextDependencyConstructor} Dep the Dependency class
+ * @param {Range} range source range
+ * @param {BasicEvaluatedExpression} param context param
+ * @param {Expression} expr expr
+ * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
+ * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
+ * @param {JavascriptParser} parser the parser
+ * @param {...EXPECTED_ANY} depArgs depArgs
+ * @returns {ContextDependency} the created Dependency
+ */
+module.exports.create = (
+	Dep,
+	range,
+	param,
+	expr,
+	options,
+	contextOptions,
+	parser,
+	...depArgs
+) => {
+	if (param.isTemplateString()) {
+		const quasis = /** @type {BasicEvaluatedExpression[]} */ (param.quasis);
+		const prefixRaw = /** @type {string} */ (quasis[0].string);
+		const postfixRaw =
+			/** @type {string} */
+			(quasis.length > 1 ? quasis[quasis.length - 1].string : "");
+
+		const valueRange = /** @type {Range} */ (param.range);
+		const { context, prefix } = splitContextFromPrefix(prefixRaw);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
+
+		// When there are more than two quasis, the generated RegExp can be more precise
+		// We join the quasis with the expression regexp
+		const innerQuasis = quasis.slice(1, -1);
+		const innerRegExp =
+			/** @type {RegExp} */ (options.wrappedContextRegExp).source +
+			innerQuasis
+				.map(
+					q =>
+						quoteMeta(/** @type {string} */ (q.string)) +
+						/** @type {RegExp} */ (options.wrappedContextRegExp).source
+				)
+				.join("");
+
+		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
+		// context: "./context"
+		// prefix: "./pre"
+		// innerQuasis: [BEE("inner"), BEE("inner2")]
+		// (BEE = BasicEvaluatedExpression)
+		// postfix: "post"
+		// query: "?query"
+		// fragment: "#frag"
+		// regExp: /^\.\/pre.*inner.*inner2.*post$/
+		const regExp = new RegExp(
+			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
+		);
+		const dep = new Dep(
+			{
+				request: context + query + fragment,
+				recursive: /** @type {boolean} */ (options.wrappedContextRecursive),
+				regExp,
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			valueRange,
+			...depArgs
+		);
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+
+		/** @type {{ value: string, range: Range }[]} */
+		const replaces = [];
+		const parts = /** @type {BasicEvaluatedExpression[]} */ (param.parts);
+
+		for (const [i, part] of parts.entries()) {
+			if (i % 2 === 0) {
+				// Quasis or merged quasi
+				let range = /** @type {Range} */ (part.range);
+				let value = /** @type {string} */ (part.string);
+				if (param.templateStringKind === "cooked") {
+					value = JSON.stringify(value);
+					value = value.slice(1, -1);
+				}
+				if (i === 0) {
+					// prefix
+					value = prefix;
+					range = [
+						/** @type {Range} */ (param.range)[0],
+						/** @type {Range} */ (part.range)[1]
+					];
+					value =
+						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
+						value;
+				} else if (i === parts.length - 1) {
+					// postfix
+					value = postfix;
+					range = [
+						/** @type {Range} */ (part.range)[0],
+						/** @type {Range} */ (param.range)[1]
+					];
+					value = `${value}\``;
+				} else if (
+					part.expression &&
+					part.expression.type === "TemplateElement" &&
+					part.expression.value.raw === value
+				) {
+					// Shortcut when it's a single quasi and doesn't need to be replaced
+					continue;
+				}
+				replaces.push({
+					range,
+					value
+				});
+			} else {
+				// Expression
+				parser.walkExpression(
+					/** @type {Expression} */
+					(part.expression)
+				);
+			}
+		}
+
+		dep.replaces = replaces;
+		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()))
+	) {
+		const prefixRaw =
+			/** @type {string} */
+			(param.prefix && param.prefix.isString() ? param.prefix.string : "");
+		const postfixRaw =
+			/** @type {string} */
+			(param.postfix && param.postfix.isString() ? param.postfix.string : "");
+		const prefixRange =
+			param.prefix && param.prefix.isString() ? param.prefix.range : null;
+		const postfixRange =
+			param.postfix && param.postfix.isString() ? param.postfix.range : null;
+		const valueRange = /** @type {Range} */ (param.range);
+		const { context, prefix } = splitContextFromPrefix(prefixRaw);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
+		const regExp = new RegExp(
+			`^${quoteMeta(prefix)}${
+				/** @type {RegExp} */ (options.wrappedContextRegExp).source
+			}${quoteMeta(postfix)}$`
+		);
+		const dep = new Dep(
+			{
+				request: context + query + fragment,
+				recursive: /** @type {boolean} */ (options.wrappedContextRecursive),
+				regExp,
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			valueRange,
+			...depArgs
+		);
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		const replaces = [];
+		if (prefixRange) {
+			replaces.push({
+				range: prefixRange,
+				value: JSON.stringify(prefix)
+			});
+		}
+		if (postfixRange) {
+			replaces.push({
+				range: postfixRange,
+				value: JSON.stringify(postfix)
+			});
+		}
+		dep.replaces = replaces;
+		dep.critical =
+			options.wrappedContextCritical &&
+			"a part of the request of a dependency is an expression";
+
+		if (parser && param.wrappedInnerExpressions) {
+			for (const part of param.wrappedInnerExpressions) {
+				if (part.expression)
+					parser.walkExpression(
+						/** @type {Expression} */
+						(part.expression)
+					);
+			}
+		}
+
+		return dep;
+	}
+	const dep = new Dep(
+		{
+			request: /** @type {string} */ (options.exprContextRequest),
+			recursive: /** @type {boolean} */ (options.exprContextRecursive),
+			regExp: /** @type {RegExp} */ (options.exprContextRegExp),
+			mode: "sync",
+			...contextOptions
+		},
+		range,
+		/** @type {Range} */ (param.range),
+		...depArgs
+	);
+	dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+	dep.critical =
+		options.exprContextCritical &&
+		"the request of a dependency is an expression";
+
+	parser.walkExpression(/** @type {Expression} */ (param.expression));
+
+	return dep;
+};

app_vue/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsId.js

@@ -0,0 +1,62 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ContextDependency = require("./ContextDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class ContextDependencyTemplateAsId extends ContextDependency.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,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ContextDependency} */ (dependency);
+		const module = moduleGraph.getModule(dep);
+		const moduleExports = runtimeTemplate.moduleExports({
+			module,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+
+		if (module) {
+			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,
+					`${moduleExports}.resolve(`
+				);
+			} else {
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					`${moduleExports}.resolve`
+				);
+			}
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+		}
+	}
+}
+module.exports = ContextDependencyTemplateAsId;

app_vue/node_modules/webpack/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ContextDependency = require("./ContextDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class ContextDependencyTemplateAsRequireCall extends ContextDependency.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,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ContextDependency} */ (dependency);
+		let moduleExports = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			runtimeRequirements
+		});
+
+		if (dep.inShorthand) {
+			moduleExports = `${dep.inShorthand}: ${moduleExports}`;
+		}
+		if (moduleGraph.getModule(dep)) {
+			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,
+					`${moduleExports}(`
+				);
+			} else {
+				source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+			}
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+		}
+	}
+}
+module.exports = ContextDependencyTemplateAsRequireCall;

app_vue/node_modules/webpack/lib/dependencies/ContextElementDependency.js

@@ -0,0 +1,135 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("../ContextModule")} ContextModule */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ContextElementDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {string | undefined} userRequest user request
+	 * @param {string | undefined} typePrefix type prefix
+	 * @param {string} category category
+	 * @param {(string[][] | null)=} referencedExports referenced exports
+	 * @param {string=} context context
+	 * @param {ImportAttributes=} attributes import assertions
+	 */
+	constructor(
+		request,
+		userRequest,
+		typePrefix,
+		category,
+		referencedExports,
+		context,
+		attributes
+	) {
+		super(request);
+		this.referencedExports = referencedExports;
+		this._typePrefix = typePrefix;
+		this._category = category;
+		this._context = context || undefined;
+
+		if (userRequest) {
+			this.userRequest = userRequest;
+		}
+
+		this.assertions = attributes;
+	}
+
+	get type() {
+		if (this._typePrefix) {
+			return `${this._typePrefix} context element`;
+		}
+
+		return "context element";
+	}
+
+	get category() {
+		return this._category;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		const refs = [];
+		for (const referencedExport of this.referencedExports) {
+			if (
+				this._typePrefix === "import()" &&
+				referencedExport[0] === "default"
+			) {
+				const selfModule =
+					/** @type {ContextModule} */
+					(moduleGraph.getParentModule(this));
+				const importedModule =
+					/** @type {Module} */
+					(moduleGraph.getModule(this));
+				const exportsType = importedModule.getExportsType(
+					moduleGraph,
+					selfModule.options.namespaceObject === "strict"
+				);
+				if (
+					exportsType === "default-only" ||
+					exportsType === "default-with-named"
+				) {
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				}
+			}
+			refs.push({
+				name: referencedExport,
+				canMangle: false
+			});
+		}
+		return refs;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this._typePrefix);
+		write(this._category);
+		write(this.referencedExports);
+		write(this.assertions);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this._typePrefix = read();
+		this._category = read();
+		this.referencedExports = read();
+		this.assertions = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ContextElementDependency,
+	"webpack/lib/dependencies/ContextElementDependency"
+);
+
+module.exports = ContextElementDependency;

app_vue/node_modules/webpack/lib/dependencies/CreateScriptUrlDependency.js

@@ -0,0 +1,75 @@
+/*
+	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 */
+
+class CreateScriptUrlDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 */
+	constructor(range) {
+		super();
+		this.range = range;
+	}
+
+	get type() {
+		return "create script url";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		super.deserialize(context);
+	}
+}
+
+CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate 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 {CreateScriptUrlDependency} */ (dependency);
+
+		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+
+		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
+		source.insert(dep.range[1], ")");
+	}
+};
+
+makeSerializable(
+	CreateScriptUrlDependency,
+	"webpack/lib/dependencies/CreateScriptUrlDependency"
+);
+
+module.exports = CreateScriptUrlDependency;

app_vue/node_modules/webpack/lib/dependencies/CriticalDependencyWarning.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("../WebpackError");
+const makeSerializable = require("../util/makeSerializable");
+
+class CriticalDependencyWarning extends WebpackError {
+	/**
+	 * @param {string} message message
+	 */
+	constructor(message) {
+		super();
+
+		this.name = "CriticalDependencyWarning";
+		this.message = `Critical dependency: ${message}`;
+	}
+}
+
+makeSerializable(
+	CriticalDependencyWarning,
+	"webpack/lib/dependencies/CriticalDependencyWarning"
+);
+
+module.exports = CriticalDependencyWarning;

app_vue/node_modules/webpack/lib/dependencies/CssIcssExportDependency.js

@@ -0,0 +1,159 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const { cssExportConvention } = require("../util/conventions");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/** @typedef {import("../CssModule")} CssModule */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../css/CssGenerator")} CssGenerator */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class CssIcssExportDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 */
+	constructor(name, value) {
+		super();
+		this.name = name;
+		this.value = value;
+		this._hashUpdate = undefined;
+	}
+
+	get type() {
+		return "css :export";
+	}
+
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		if (this._conventionNames) {
+			return this._conventionNames;
+		}
+		this._conventionNames = cssExportConvention(name, convention);
+		return this._conventionNames;
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
+		const generator = /** @type {CssGenerator} */ (module.generator);
+		const names = this.getExportsConventionNames(
+			this.name,
+			/** @type {CssGeneratorExportsConvention} */
+			(generator.convention)
+		);
+		return {
+			exports: names.map(name => ({
+				name,
+				canMangle: true
+			})),
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, { chunkGraph }) {
+		if (this._hashUpdate === undefined) {
+			const module =
+				/** @type {CssModule} */
+				(chunkGraph.moduleGraph.getParentModule(this));
+			const generator = /** @type {CssGenerator} */ (module.generator);
+			const names = this.getExportsConventionNames(
+				this.name,
+				/** @type {CssGeneratorExportsConvention} */
+				(generator.convention)
+			);
+			this._hashUpdate = JSON.stringify(names);
+		}
+		hash.update("exportsConvention");
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		super.deserialize(context);
+	}
+}
+
+CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate 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, { cssData, module: m, runtime, moduleGraph }) {
+		const dep = /** @type {CssIcssExportDependency} */ (dependency);
+		const module = /** @type {CssModule} */ (m);
+		const generator = /** @type {CssGenerator} */ (module.generator);
+		const names = dep.getExportsConventionNames(
+			dep.name,
+			/** @type {CssGeneratorExportsConvention} */
+			(generator.convention)
+		);
+		const usedNames =
+			/** @type {string[]} */
+			(
+				names
+					.map(name =>
+						moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
+					)
+					.filter(Boolean)
+			);
+
+		for (const used of usedNames.concat(names)) {
+			cssData.exports.set(used, dep.value);
+		}
+	}
+};
+
+makeSerializable(
+	CssIcssExportDependency,
+	"webpack/lib/dependencies/CssIcssExportDependency"
+);
+
+module.exports = CssIcssExportDependency;

app_vue/node_modules/webpack/lib/dependencies/CssIcssImportDependency.js

@@ -0,0 +1,122 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
+const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class CssIcssImportDependency extends ModuleDependency {
+	/**
+	 * Example of dependency:
+	 *
+	 *:import('./style.css') { IMPORTED_NAME: v-primary }
+	 * @param {string} request request request path which needs resolving
+	 * @param {string} exportName export name
+	 * @param {Range} range the range of dependency
+	 */
+	constructor(request, exportName, range) {
+		super(request);
+		this.exportName = exportName;
+		this.range = range;
+	}
+
+	get type() {
+		return "css :import";
+	}
+
+	get category() {
+		return "css-import";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.exportName);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.exportName = read();
+		super.deserialize(context);
+	}
+}
+
+CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends (
+	ModuleDependency.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, templateContext) {
+		const dep = /** @type {CssIcssImportDependency} */ (dependency);
+		const { range } = dep;
+		const module =
+			/** @type {Module} */
+			(templateContext.moduleGraph.getModule(dep));
+		let value;
+
+		for (const item of module.dependencies) {
+			if (
+				item instanceof CssLocalIdentifierDependency &&
+				dep.exportName === item.name
+			) {
+				value = CssLocalIdentifierDependency.Template.getIdentifier(
+					item,
+					dep.exportName,
+					{
+						...templateContext,
+						module
+					}
+				);
+				break;
+			} else if (
+				item instanceof CssIcssExportDependency &&
+				dep.exportName === item.name
+			) {
+				value = item.value;
+				break;
+			}
+		}
+
+		if (!value) {
+			throw new Error(
+				`Imported '${dep.exportName}' name from '${dep.request}' not found`
+			);
+		}
+
+		source.replace(range[0], range[1], value);
+	}
+};
+
+makeSerializable(
+	CssIcssImportDependency,
+	"webpack/lib/dependencies/CssIcssImportDependency"
+);
+
+module.exports = CssIcssImportDependency;

app_vue/node_modules/webpack/lib/dependencies/CssIcssSymbolDependency.js

@@ -0,0 +1,132 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CssIcssSymbolDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 * @param {Range} range range
+	 */
+	constructor(name, value, range) {
+		super();
+		this.name = name;
+		this.value = value;
+		this.range = range;
+		this._hashUpdate = undefined;
+	}
+
+	get type() {
+		return "css @value identifier";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.range}${this.name}${this.value}`;
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: [
+				{
+					name: this.name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		write(this.range);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		this.range = read();
+		super.deserialize(context);
+	}
+}
+
+CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate 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, { cssData }) {
+		const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
+
+		source.replace(dep.range[0], dep.range[1] - 1, dep.value);
+
+		cssData.exports.set(dep.name, dep.value);
+	}
+};
+
+makeSerializable(
+	CssIcssSymbolDependency,
+	"webpack/lib/dependencies/CssIcssSymbolDependency"
+);
+
+module.exports = CssIcssSymbolDependency;

app_vue/node_modules/webpack/lib/dependencies/CssImportDependency.js

@@ -0,0 +1,117 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CssImportDependency extends ModuleDependency {
+	/**
+	 * Example of dependency:
+	 * \@import url("landscape.css") layer(forms) screen and (orientation: landscape) screen and (orientation: landscape);
+	 * @param {string} request request
+	 * @param {Range} range range of the argument
+	 * @param {string | undefined} layer layer
+	 * @param {string | undefined} supports list of supports conditions
+	 * @param {string | undefined} media list of media conditions
+	 */
+	constructor(request, range, layer, supports, media) {
+		super(request);
+		this.range = range;
+		this.layer = layer;
+		this.supports = supports;
+		this.media = media;
+	}
+
+	get type() {
+		return "css @import";
+	}
+
+	get category() {
+		return "css-import";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = `context${this._context || ""}|module${this.request}`;
+
+		if (this.layer) {
+			str += `|layer${this.layer}`;
+		}
+
+		if (this.supports) {
+			str += `|supports${this.supports}`;
+		}
+
+		if (this.media) {
+			str += `|media${this.media}`;
+		}
+
+		return str;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.layer);
+		write(this.supports);
+		write(this.media);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.layer = read();
+		this.supports = read();
+		this.media = read();
+		super.deserialize(context);
+	}
+}
+
+CssImportDependency.Template = class CssImportDependencyTemplate extends (
+	ModuleDependency.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, templateContext) {
+		const dep = /** @type {CssImportDependency} */ (dependency);
+
+		source.replace(dep.range[0], dep.range[1] - 1, "");
+	}
+};
+
+makeSerializable(
+	CssImportDependency,
+	"webpack/lib/dependencies/CssImportDependency"
+);
+
+module.exports = CssImportDependency;

app_vue/node_modules/webpack/lib/dependencies/CssLocalIdentifierDependency.js

@@ -0,0 +1,253 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const { cssExportConvention } = require("../util/conventions");
+const createHash = require("../util/createHash");
+const { makePathsRelative } = require("../util/identifier");
+const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorLocalIdentName} CssGeneratorLocalIdentName */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CssModule")} CssModule */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../css/CssGenerator")} CssGenerator */
+/** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+const getCssParser = memoize(() => require("../css/CssParser"));
+
+/**
+ * @param {string} local css local
+ * @param {CssModule} module module
+ * @param {ChunkGraph} chunkGraph chunk graph
+ * @param {RuntimeTemplate} runtimeTemplate runtime template
+ * @returns {string} local ident
+ */
+const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
+	const generator = /** @type {CssGenerator} */ (module.generator);
+	const localIdentName =
+		/** @type {CssGeneratorLocalIdentName} */
+		(generator.localIdentName);
+	const relativeResourcePath = makePathsRelative(
+		/** @type {string} */
+		(module.context),
+		module.matchResource || module.resource,
+		runtimeTemplate.compilation.compiler.root
+	);
+	const { hashFunction, hashDigest, hashDigestLength, hashSalt, uniqueName } =
+		runtimeTemplate.outputOptions;
+	const hash = createHash(/** @type {HashFunction} */ (hashFunction));
+
+	if (hashSalt) {
+		hash.update(hashSalt);
+	}
+
+	hash.update(relativeResourcePath);
+
+	if (!/\[local\]/.test(localIdentName)) {
+		hash.update(local);
+	}
+
+	const localIdentHash =
+		/** @type {string} */
+		(hash.digest(hashDigest)).slice(0, hashDigestLength);
+
+	return runtimeTemplate.compilation
+		.getPath(localIdentName, {
+			filename: relativeResourcePath,
+			hash: localIdentHash,
+			contentHash: localIdentHash,
+			chunkGraph,
+			module
+		})
+		.replace(/\[local\]/g, local)
+		.replace(/\[uniqueName\]/g, /** @type {string} */ (uniqueName))
+		.replace(/^((-?[0-9])|--)/, "_$1");
+};
+
+class CssLocalIdentifierDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {Range} range range
+	 * @param {string=} prefix prefix
+	 */
+	constructor(name, range, prefix = "") {
+		super();
+		this.name = name;
+		this.range = range;
+		this.prefix = prefix;
+		this._conventionNames = undefined;
+		this._hashUpdate = undefined;
+	}
+
+	get type() {
+		return "css local identifier";
+	}
+
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		if (this._conventionNames) {
+			return this._conventionNames;
+		}
+		this._conventionNames = cssExportConvention(this.name, convention);
+		return this._conventionNames;
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
+		const generator = /** @type {CssGenerator} */ (module.generator);
+		const names = this.getExportsConventionNames(
+			this.name,
+			/** @type {CssGeneratorExportsConvention} */ (generator.convention)
+		);
+		return {
+			exports: names.map(name => ({
+				name,
+				canMangle: true
+			})),
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, { chunkGraph }) {
+		if (this._hashUpdate === undefined) {
+			const module =
+				/** @type {CssModule} */
+				(chunkGraph.moduleGraph.getParentModule(this));
+			const generator = /** @type {CssGenerator} */ (module.generator);
+			const names = this.getExportsConventionNames(
+				this.name,
+				/** @type {CssGeneratorExportsConvention} */
+				(generator.convention)
+			);
+			this._hashUpdate = `exportsConvention|${JSON.stringify(names)}|localIdentName|${JSON.stringify(generator.localIdentName)}`;
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.range);
+		write(this.prefix);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.range = read();
+		this.prefix = read();
+		super.deserialize(context);
+	}
+}
+
+CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {string} local local name
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {string} identifier
+	 */
+	static getIdentifier(
+		dependency,
+		local,
+		{ module: m, chunkGraph, runtimeTemplate }
+	) {
+		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
+		const module = /** @type {CssModule} */ (m);
+
+		return (
+			dep.prefix +
+			getCssParser().escapeIdentifier(
+				getLocalIdent(local, module, chunkGraph, runtimeTemplate)
+			)
+		);
+	}
+
+	/**
+	 * @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, templateContext) {
+		const { module: m, moduleGraph, runtime, cssData } = templateContext;
+		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
+		const module = /** @type {CssModule} */ (m);
+		const generator = /** @type {CssGenerator} */ (module.generator);
+		const names = dep.getExportsConventionNames(
+			dep.name,
+			/** @type {CssGeneratorExportsConvention} */
+			(generator.convention)
+		);
+		const usedNames =
+			/** @type {(string)[]} */
+			(
+				names
+					.map(name =>
+						moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
+					)
+					.filter(Boolean)
+			);
+		const local = usedNames.length === 0 ? names[0] : usedNames[0];
+		const identifier = CssLocalIdentifierDependencyTemplate.getIdentifier(
+			dep,
+			local,
+			templateContext
+		);
+
+		source.replace(dep.range[0], dep.range[1] - 1, identifier);
+
+		for (const used of usedNames.concat(names)) {
+			cssData.exports.set(used, getCssParser().unescapeIdentifier(identifier));
+		}
+	}
+};
+
+makeSerializable(
+	CssLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssLocalIdentifierDependency"
+);
+
+module.exports = CssLocalIdentifierDependency;

app_vue/node_modules/webpack/lib/dependencies/CssSelfLocalIdentifierDependency.js

@@ -0,0 +1,111 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
+	/**
+	 * @param {string} name name
+	 * @param {Range} range range
+	 * @param {string=} prefix prefix
+	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
+	 */
+	constructor(name, range, prefix = "", declaredSet = undefined) {
+		super(name, range, prefix);
+		this.declaredSet = declaredSet;
+	}
+
+	get type() {
+		return "css self local identifier";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return "self";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
+		return super.getExports(moduleGraph);
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (this.declaredSet && !this.declaredSet.has(this.name))
+			return Dependency.NO_EXPORTS_REFERENCED;
+		return [[this.name]];
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.declaredSet);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.declaredSet = read();
+		super.deserialize(context);
+	}
+}
+
+CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
+	CssLocalIdentifierDependency.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, templateContext) {
+		const dep = /** @type {CssSelfLocalIdentifierDependency} */ (dependency);
+		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
+		super.apply(dependency, source, templateContext);
+	}
+};
+
+makeSerializable(
+	CssSelfLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
+);
+
+module.exports = CssSelfLocalIdentifierDependency;

app_vue/node_modules/webpack/lib/dependencies/CssUrlDependency.js

@@ -0,0 +1,195 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const RawDataUrlModule = require("../asset/RawDataUrlModule");
+const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const getIgnoredRawDataUrlModule = memoize(
+	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
+);
+
+class CssUrlDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {Range} range range of the argument
+	 * @param {"string" | "url" | "src"} urlType dependency type e.g. url() or string
+	 */
+	constructor(request, range, urlType) {
+		super(request);
+		this.range = range;
+		this.urlType = urlType;
+	}
+
+	get type() {
+		return "css url()";
+	}
+
+	get category() {
+		return "url";
+	}
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} ignored module
+	 */
+	createIgnoredModule(context) {
+		return getIgnoredRawDataUrlModule();
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.urlType);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.urlType = read();
+		super.deserialize(context);
+	}
+}
+
+/**
+ * @param {string} str string
+ * @returns {string} string in quotes if needed
+ */
+const cssEscapeString = str => {
+	let countWhiteOrBracket = 0;
+	let countQuotation = 0;
+	let countApostrophe = 0;
+	for (let i = 0; i < str.length; i++) {
+		const cc = str.charCodeAt(i);
+		switch (cc) {
+			case 9: // tab
+			case 10: // nl
+			case 32: // space
+			case 40: // (
+			case 41: // )
+				countWhiteOrBracket++;
+				break;
+			case 34:
+				countQuotation++;
+				break;
+			case 39:
+				countApostrophe++;
+				break;
+		}
+	}
+	if (countWhiteOrBracket < 2) {
+		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
+	} else if (countQuotation <= countApostrophe) {
+		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
+	}
+	return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
+};
+
+CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
+	ModuleDependency.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,
+		{ moduleGraph, runtimeTemplate, codeGenerationResults }
+	) {
+		const dep = /** @type {CssUrlDependency} */ (dependency);
+		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+
+		/** @type {string | undefined} */
+		let newValue;
+
+		switch (dep.urlType) {
+			case "string":
+				newValue = cssEscapeString(
+					this.assetUrl({
+						module,
+						codeGenerationResults
+					})
+				);
+				break;
+			case "url":
+				newValue = `url(${cssEscapeString(
+					this.assetUrl({
+						module,
+						codeGenerationResults
+					})
+				)})`;
+				break;
+			case "src":
+				newValue = `src(${cssEscapeString(
+					this.assetUrl({
+						module,
+						codeGenerationResults
+					})
+				)})`;
+				break;
+		}
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			/** @type {string} */ (newValue)
+		);
+	}
+
+	/**
+	 * @param {object} options options object
+	 * @param {Module} options.module the module
+	 * @param {RuntimeSpec=} options.runtime runtime
+	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
+	 * @returns {string} the url of the asset
+	 */
+	assetUrl({ runtime, module, codeGenerationResults }) {
+		if (!module) {
+			return "data:,";
+		}
+		const codeGen = codeGenerationResults.get(module, runtime);
+		const data =
+			/** @type {NonNullable<CodeGenerationResult["data"]>} */
+			(codeGen.data);
+		if (!data) return "data:,";
+		const url = data.get("url");
+		if (!url || !url["css-url"]) return "data:,";
+		return url["css-url"];
+	}
+};
+
+makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
+
+CssUrlDependency.PUBLIC_PATH_AUTO = "__WEBPACK_CSS_PUBLIC_PATH_AUTO__";
+
+module.exports = CssUrlDependency;

app_vue/node_modules/webpack/lib/dependencies/DelegatedSourceDependency.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+class DelegatedSourceDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 */
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "delegated source";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+makeSerializable(
+	DelegatedSourceDependency,
+	"webpack/lib/dependencies/DelegatedSourceDependency"
+);
+
+module.exports = DelegatedSourceDependency;

app_vue/node_modules/webpack/lib/dependencies/DllEntryDependency.js

@@ -0,0 +1,61 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./EntryDependency")} EntryDependency */
+
+class DllEntryDependency extends Dependency {
+	/**
+	 * @param {EntryDependency[]} dependencies dependencies
+	 * @param {string} name name
+	 */
+	constructor(dependencies, name) {
+		super();
+
+		this.dependencies = dependencies;
+		this.name = name;
+	}
+
+	get type() {
+		return "dll entry";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.dependencies);
+		write(this.name);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.dependencies = read();
+		this.name = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	DllEntryDependency,
+	"webpack/lib/dependencies/DllEntryDependency"
+);
+
+module.exports = DllEntryDependency;

app_vue/node_modules/webpack/lib/dependencies/DynamicExports.js

@@ -0,0 +1,73 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Parser").ParserState} ParserState */
+
+/** @type {WeakMap<ParserState, boolean>} */
+const parserStateExportsState = new WeakMap();
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.bailout = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	parserStateExportsState.set(parserState, false);
+	if (value === true) {
+		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		buildMeta.exportsType = undefined;
+		buildMeta.defaultObject = false;
+	}
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.enable = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value === false) return;
+	parserStateExportsState.set(parserState, true);
+	if (value !== true) {
+		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject = "redirect";
+	}
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.setFlagged = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value !== true) return;
+	const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+	if (buildMeta.exportsType === "dynamic") return;
+	buildMeta.exportsType = "flagged";
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.setDynamic = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value !== true) return;
+	/** @type {BuildMeta} */
+	(parserState.module.buildMeta).exportsType = "dynamic";
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+module.exports.isEnabled = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	return value === true;
+};

app_vue/node_modules/webpack/lib/dependencies/EntryDependency.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+class EntryDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request path for entry
+	 */
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "entry";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+makeSerializable(EntryDependency, "webpack/lib/dependencies/EntryDependency");
+
+module.exports = EntryDependency;

app_vue/node_modules/webpack/lib/dependencies/ExportsInfoDependency.js

@@ -0,0 +1,163 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { UsageState } = require("../ExportsInfo");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @template T
+ * @typedef {import("../util/SortableSet")<T>} SortableSet
+ */
+
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the module
+ * @param {string[] | null} _exportName name of the export if any
+ * @param {string | null} property name of the requested property
+ * @param {RuntimeSpec} runtime for which runtime
+ * @returns {undefined | null | number | boolean | string[] | SortableSet<string>} value of the property
+ */
+const getProperty = (moduleGraph, module, _exportName, property, runtime) => {
+	if (!_exportName) {
+		switch (property) {
+			case "usedExports": {
+				const usedExports = moduleGraph
+					.getExportsInfo(module)
+					.getUsedExports(runtime);
+				if (
+					typeof usedExports === "boolean" ||
+					usedExports === undefined ||
+					usedExports === null
+				) {
+					return usedExports;
+				}
+				return Array.from(usedExports).sort();
+			}
+		}
+	}
+	const exportName = /** @type {string[]} */ (_exportName);
+	switch (property) {
+		case "canMangle": {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportInfo = exportsInfo.getReadOnlyExportInfoRecursive(exportName);
+			if (exportInfo) return exportInfo.canMangle;
+			return exportsInfo.otherExportsInfo.canMangle;
+		}
+		case "used":
+			return (
+				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
+				UsageState.Unused
+			);
+		case "useInfo": {
+			const state = moduleGraph
+				.getExportsInfo(module)
+				.getUsed(exportName, runtime);
+			switch (state) {
+				case UsageState.Used:
+				case UsageState.OnlyPropertiesUsed:
+					return true;
+				case UsageState.Unused:
+					return false;
+				case UsageState.NoInfo:
+					return;
+				case UsageState.Unknown:
+					return null;
+				default:
+					throw new Error(`Unexpected UsageState ${state}`);
+			}
+		}
+		case "provideInfo":
+			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
+	}
+};
+
+class ExportsInfoDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {string[] | null} exportName export name
+	 * @param {string | null} property property
+	 */
+	constructor(range, exportName, property) {
+		super();
+		this.range = range;
+		this.exportName = exportName;
+		this.property = property;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.exportName);
+		write(this.property);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ExportsInfoDependency} ExportsInfoDependency
+	 */
+	static deserialize(context) {
+		const obj = new ExportsInfoDependency(
+			context.read(),
+			context.read(),
+			context.read()
+		);
+		obj.deserialize(context);
+		return obj;
+	}
+}
+
+makeSerializable(
+	ExportsInfoDependency,
+	"webpack/lib/dependencies/ExportsInfoDependency"
+);
+
+ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate 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, { module, moduleGraph, runtime }) {
+		const dep = /** @type {ExportsInfoDependency} */ (dependency);
+
+		const value = getProperty(
+			moduleGraph,
+			module,
+			dep.exportName,
+			dep.property,
+			runtime
+		);
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			value === undefined ? "undefined" : JSON.stringify(value)
+		);
+	}
+};
+
+module.exports = ExportsInfoDependency;

app_vue/node_modules/webpack/lib/dependencies/ExternalModuleDependency.js

@@ -0,0 +1,109 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const CachedConstDependency = require("./CachedConstDependency");
+const ExternalModuleInitFragment = require("./ExternalModuleInitFragment");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class ExternalModuleDependency extends CachedConstDependency {
+	/**
+	 * @param {string} module module
+	 * @param {{ name: string, value: string }[]} importSpecifiers import specifiers
+	 * @param {string | undefined} defaultImport default import
+	 * @param {string} expression expression
+	 * @param {Range} range range
+	 * @param {string} identifier identifier
+	 */
+	constructor(
+		module,
+		importSpecifiers,
+		defaultImport,
+		expression,
+		range,
+		identifier
+	) {
+		super(expression, range, identifier);
+
+		this.importedModule = module;
+		this.specifiers = importSpecifiers;
+		this.default = defaultImport;
+	}
+
+	/**
+	 * @returns {string} hash update
+	 */
+	_createHashUpdate() {
+		return `${this.importedModule}${JSON.stringify(this.specifiers)}${
+			this.default || "null"
+		}${super._createHashUpdate()}`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+		const { write } = context;
+		write(this.importedModule);
+		write(this.specifiers);
+		write(this.default);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+		const { read } = context;
+		this.importedModule = read();
+		this.specifiers = read();
+		this.default = read();
+	}
+}
+
+makeSerializable(
+	ExternalModuleDependency,
+	"webpack/lib/dependencies/ExternalModuleDependency"
+);
+
+ExternalModuleDependency.Template = class ExternalModuleDependencyTemplate extends (
+	CachedConstDependency.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, templateContext) {
+		super.apply(dependency, source, templateContext);
+		const dep = /** @type {ExternalModuleDependency} */ (dependency);
+		const { chunkInitFragments, runtimeTemplate } = templateContext;
+
+		chunkInitFragments.push(
+			new ExternalModuleInitFragment(
+				`${runtimeTemplate.supportNodePrefixForCoreModules() ? "node:" : ""}${
+					dep.importedModule
+				}`,
+				dep.specifiers,
+				dep.default
+			)
+		);
+	}
+};
+
+module.exports = ExternalModuleDependency;

app_vue/node_modules/webpack/lib/dependencies/ExternalModuleInitFragment.js

@@ -0,0 +1,133 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const InitFragment = require("../InitFragment");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {Map<string, Set<string>>} ImportSpecifiers */
+
+/**
+ * @extends {InitFragment<GenerateContext>}
+ */
+class ExternalModuleInitFragment extends InitFragment {
+	/**
+	 * @param {string} importedModule imported module
+	 * @param {Array<{ name: string, value?: string }> | ImportSpecifiers} specifiers import specifiers
+	 * @param {string=} defaultImport default import
+	 */
+	constructor(importedModule, specifiers, defaultImport) {
+		super(
+			undefined,
+			InitFragment.STAGE_CONSTANTS,
+			0,
+			`external module imports|${importedModule}|${defaultImport || "null"}`
+		);
+		this.importedModule = importedModule;
+		if (Array.isArray(specifiers)) {
+			/** @type {ImportSpecifiers} */
+			this.specifiers = new Map();
+			for (const { name, value } of specifiers) {
+				let specifiers = this.specifiers.get(name);
+				if (!specifiers) {
+					specifiers = new Set();
+					this.specifiers.set(name, specifiers);
+				}
+				specifiers.add(value || name);
+			}
+		} else {
+			this.specifiers = specifiers;
+		}
+		this.defaultImport = defaultImport;
+	}
+
+	/**
+	 * @param {ExternalModuleInitFragment} other other
+	 * @returns {ExternalModuleInitFragment} ExternalModuleInitFragment
+	 */
+	merge(other) {
+		const newSpecifiersMap = new Map(this.specifiers);
+		for (const [name, specifiers] of other.specifiers) {
+			if (newSpecifiersMap.has(name)) {
+				const currentSpecifiers =
+					/** @type {Set<string>} */
+					(newSpecifiersMap.get(name));
+				for (const spec of specifiers) currentSpecifiers.add(spec);
+			} else {
+				newSpecifiersMap.set(name, specifiers);
+			}
+		}
+		return new ExternalModuleInitFragment(
+			this.importedModule,
+			newSpecifiersMap,
+			this.defaultImport
+		);
+	}
+
+	/**
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
+	 */
+	getContent({ runtimeRequirements }) {
+		const namedImports = [];
+
+		for (const [name, specifiers] of this.specifiers) {
+			for (const spec of specifiers) {
+				if (spec === name) {
+					namedImports.push(name);
+				} else {
+					namedImports.push(`${name} as ${spec}`);
+				}
+			}
+		}
+
+		let importsString =
+			namedImports.length > 0 ? `{${namedImports.join(",")}}` : "";
+
+		if (this.defaultImport) {
+			importsString = `${this.defaultImport}${
+				importsString ? `, ${importsString}` : ""
+			}`;
+		}
+
+		return `import ${importsString} from ${JSON.stringify(
+			this.importedModule
+		)};`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+		const { write } = context;
+		write(this.importedModule);
+		write(this.specifiers);
+		write(this.defaultImport);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+		const { read } = context;
+		this.importedModule = read();
+		this.specifiers = read();
+		this.defaultImport = read();
+	}
+}
+
+makeSerializable(
+	ExternalModuleInitFragment,
+	"webpack/lib/dependencies/ExternalModuleInitFragment"
+);
+
+module.exports = ExternalModuleInitFragment;

app_vue/node_modules/webpack/lib/dependencies/HarmonyAcceptDependency.js

@@ -0,0 +1,143 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+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 */
+/** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+
+class HarmonyAcceptDependency extends NullDependency {
+	/**
+	 * @param {Range} range expression range
+	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
+	 * @param {boolean} hasCallback true, if the range wraps an existing callback
+	 */
+	constructor(range, dependencies, hasCallback) {
+		super();
+		this.range = range;
+		this.dependencies = dependencies;
+		this.hasCallback = hasCallback;
+	}
+
+	get type() {
+		return "accepted harmony modules";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.dependencies);
+		write(this.hasCallback);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.dependencies = read();
+		this.hasCallback = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyAcceptDependency,
+	"webpack/lib/dependencies/HarmonyAcceptDependency"
+);
+
+HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate 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, templateContext) {
+		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
+		const {
+			module,
+			runtime,
+			runtimeRequirements,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph
+		} = templateContext;
+		const content = dep.dependencies
+			.map(dependency => {
+				const referencedModule = moduleGraph.getModule(dependency);
+				return {
+					dependency,
+					runtimeCondition: referencedModule
+						? HarmonyImportDependency.Template.getImportEmittedRuntime(
+								module,
+								referencedModule
+							)
+						: false
+				};
+			})
+			.filter(({ runtimeCondition }) => runtimeCondition !== false)
+			.map(({ dependency, runtimeCondition }) => {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				const s = dependency.getImportStatement(true, templateContext);
+				const code = s[0] + s[1];
+				if (condition !== "true") {
+					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
+				}
+				return code;
+			})
+			.join("");
+
+		if (dep.hasCallback) {
+			if (runtimeTemplate.supportsArrowFunction()) {
+				source.insert(
+					dep.range[0],
+					`__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`
+				);
+				source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
+			} else {
+				source.insert(
+					dep.range[0],
+					`function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`
+				);
+				source.insert(
+					dep.range[1],
+					")(__WEBPACK_OUTDATED_DEPENDENCIES__); }.bind(this)"
+				);
+			}
+			return;
+		}
+
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		source.insert(
+			dep.range[1] - 0.5,
+			`, ${arrow ? "() =>" : "function()"} { ${content} }`
+		);
+	}
+};
+
+module.exports = HarmonyAcceptDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class HarmonyAcceptImportDependency extends HarmonyImportDependency {
+	/**
+	 * @param {string} request the request string
+	 */
+	constructor(request) {
+		super(request, Number.NaN);
+		this.weak = true;
+	}
+
+	get type() {
+		return "harmony accept";
+	}
+}
+
+makeSerializable(
+	HarmonyAcceptImportDependency,
+	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
+);
+
+HarmonyAcceptImportDependency.Template =
+	/** @type {typeof HarmonyImportDependency.Template} */ (
+		NullDependency.Template
+	);
+
+module.exports = HarmonyAcceptImportDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -0,0 +1,92 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { UsageState } = require("../ExportsInfo");
+const InitFragment = require("../InitFragment");
+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("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+
+class HarmonyCompatibilityDependency extends NullDependency {
+	get type() {
+		return "harmony export header";
+	}
+}
+
+makeSerializable(
+	HarmonyCompatibilityDependency,
+	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
+);
+
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate 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,
+		{
+			module,
+			runtimeTemplate,
+			moduleGraph,
+			initFragments,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
+		}
+	) {
+		if (concatenationScope) return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		if (
+			exportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
+			UsageState.Unused
+		) {
+			const content = runtimeTemplate.defineEsModuleFlagStatement({
+				exportsArgument: module.exportsArgument,
+				runtimeRequirements
+			});
+			initFragments.push(
+				new InitFragment(
+					content,
+					InitFragment.STAGE_HARMONY_EXPORTS,
+					0,
+					"harmony compatibility"
+				)
+			);
+		}
+		if (moduleGraph.isAsync(module)) {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+			initFragments.push(
+				new InitFragment(
+					runtimeTemplate.supportsArrowFunction()
+						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+					InitFragment.STAGE_ASYNC_BOUNDARY,
+					0,
+					undefined,
+					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
+						/** @type {BuildMeta} */ (module.buildMeta).async ? ", 1" : ""
+					});`
+				)
+			);
+		}
+	}
+};
+
+module.exports = HarmonyCompatibilityDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -0,0 +1,117 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const EnvironmentNotSupportAsyncWarning = require("../EnvironmentNotSupportAsyncWarning");
+const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
+const DynamicExports = require("./DynamicExports");
+const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
+const HarmonyExports = require("./HarmonyExports");
+
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./HarmonyModulesPlugin").HarmonyModulesPluginOptions} HarmonyModulesPluginOptions */
+
+const PLUGIN_NAME = "HarmonyDetectionParserPlugin";
+
+module.exports = class HarmonyDetectionParserPlugin {
+	/**
+	 * @param {HarmonyModulesPluginOptions} options options
+	 */
+	constructor(options) {
+		const { topLevelAwait = false } = options || {};
+		this.topLevelAwait = topLevelAwait;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.program.tap(PLUGIN_NAME, ast => {
+			const isStrictHarmony =
+				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
+			const isHarmony =
+				isStrictHarmony ||
+				ast.body.some(
+					statement =>
+						statement.type === "ImportDeclaration" ||
+						statement.type === "ExportDefaultDeclaration" ||
+						statement.type === "ExportNamedDeclaration" ||
+						statement.type === "ExportAllDeclaration"
+				);
+			if (isHarmony) {
+				const module = parser.state.module;
+				const compatDep = new HarmonyCompatibilityDependency();
+				compatDep.loc = {
+					start: {
+						line: -1,
+						column: 0
+					},
+					end: {
+						line: -1,
+						column: 0
+					},
+					index: -3
+				};
+				module.addPresentationalDependency(compatDep);
+				DynamicExports.bailout(parser.state);
+				HarmonyExports.enable(parser.state, isStrictHarmony);
+				parser.scope.isStrict = true;
+			}
+		});
+
+		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
+			const module = parser.state.module;
+			if (!this.topLevelAwait) {
+				throw new Error(
+					"The top-level-await experiment is not enabled (set experiments.topLevelAwait: true to enable it)"
+				);
+			}
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				throw new Error(
+					"Top-level-await is only supported in EcmaScript Modules"
+				);
+			}
+			/** @type {BuildMeta} */
+			(module.buildMeta).async = true;
+			EnvironmentNotSupportAsyncWarning.check(
+				module,
+				parser.state.compilation.runtimeTemplate,
+				"topLevelAwait"
+			);
+		});
+
+		/**
+		 * @returns {boolean | undefined} true if in harmony
+		 */
+		const skipInHarmony = () => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				return true;
+			}
+		};
+
+		/**
+		 * @returns {null | undefined} null if in harmony
+		 */
+		const nullInHarmony = () => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				return null;
+			}
+		};
+
+		const nonHarmonyIdentifiers = ["define", "exports"];
+		for (const identifier of nonHarmonyIdentifiers) {
+			parser.hooks.evaluateTypeof
+				.for(identifier)
+				.tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.typeof.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.evaluate.for(identifier).tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.expression.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.call.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+		}
+	}
+};

app_vue/node_modules/webpack/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -0,0 +1,152 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/**
+ * Dependency for static evaluating import specifier. e.g.
+ * @example
+ * import a from "a";
+ * "x" in a;
+ * a.x !== undefined; // if x value statically analyzable
+ */
+class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder source order
+	 * @param {string[]} ids ids
+	 * @param {string} name name
+	 * @param {Range} range location in source code
+	 * @param {ImportAttributes} attributes import assertions
+	 * @param {string} operator operator
+	 */
+	constructor(request, sourceOrder, ids, name, range, attributes, operator) {
+		super(request, sourceOrder, ids, name, range, false, attributes, []);
+		this.operator = operator;
+	}
+
+	get type() {
+		return `evaluated X ${this.operator} harmony import specifier`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+		const { write } = context;
+		write(this.operator);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+		const { read } = context;
+		this.operator = read();
+	}
+}
+
+makeSerializable(
+	HarmonyEvaluatedImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency"
+);
+
+HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImportSpecifierDependencyTemplate extends (
+	HarmonyImportSpecifierDependency.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, templateContext) {
+		const dep =
+			/** @type {HarmonyEvaluatedImportSpecifierDependency} */
+			(dependency);
+		const { module, moduleGraph, runtime } = templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const exportsInfo = moduleGraph.getExportsInfo(
+			/** @type {ModuleGraphConnection} */ (connection).module
+		);
+		const ids = dep.getIds(moduleGraph);
+
+		let value;
+
+		const exportsType =
+			/** @type {ModuleGraphConnection} */
+			(connection).module.getExportsType(
+				moduleGraph,
+				/** @type {BuildMeta} */
+				(module.buildMeta).strictHarmonyModule
+			);
+		switch (exportsType) {
+			case "default-with-named": {
+				if (ids[0] === "default") {
+					value =
+						ids.length === 1 || exportsInfo.isExportProvided(ids.slice(1));
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "namespace": {
+				value =
+					ids[0] === "__esModule"
+						? ids.length === 1 || undefined
+						: exportsInfo.isExportProvided(ids);
+				break;
+			}
+			case "dynamic": {
+				if (ids[0] !== "default") {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			// default-only could lead to runtime error, when default value is primitive
+		}
+
+		if (typeof value === "boolean") {
+			source.replace(dep.range[0], dep.range[1] - 1, ` ${value}`);
+		} else {
+			const usedName = exportsInfo.getUsedName(ids, runtime);
+
+			const code = this._getCodeForIds(
+				dep,
+				source,
+				templateContext,
+				ids.slice(0, -1)
+			);
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				`${
+					usedName ? JSON.stringify(usedName[usedName.length - 1]) : '""'
+				} in ${code}`
+			);
+		}
+	}
+};
+
+module.exports = HarmonyEvaluatedImportSpecifierDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -0,0 +1,228 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { getImportAttributes } = require("../javascript/JavascriptParser");
+const InnerGraph = require("../optimize/InnerGraph");
+const ConstDependency = require("./ConstDependency");
+const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
+const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
+const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
+const {
+	harmonySpecifierTag
+} = require("./HarmonyImportDependencyParserPlugin");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ClassDeclaration} ClassDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
+
+module.exports = class HarmonyExportDependencyParserPlugin {
+	/**
+	 * @param {import("../../declarations/WebpackOptions").JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		this.exportPresenceMode =
+			options.reexportExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
+				: options.exportsPresence !== undefined
+					? ExportPresenceModes.fromUserOption(options.exportsPresence)
+					: options.strictExportPresence
+						? ExportPresenceModes.ERROR
+						: ExportPresenceModes.AUTO;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const { exportPresenceMode } = this;
+		parser.hooks.export.tap(
+			"HarmonyExportDependencyParserPlugin",
+			statement => {
+				const dep = new HarmonyExportHeaderDependency(
+					/** @type {Range | false} */ (
+						statement.declaration && statement.declaration.range
+					),
+					/** @type {Range} */ (statement.range)
+				);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
+				dep.loc.index = -1;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		);
+		parser.hooks.exportImport.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency(
+					"",
+					/** @type {Range} */ (statement.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				clearDep.loc.index = -1;
+				parser.state.module.addPresentationalDependency(clearDep);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					/** @type {string} */ (source),
+					parser.state.lastHarmonyImportOrder,
+					getImportAttributes(statement)
+				);
+				sideEffectDep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
+				sideEffectDep.loc.index = -1;
+				parser.state.current.addDependency(sideEffectDep);
+				return true;
+			}
+		);
+		parser.hooks.exportExpression.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, node) => {
+				const isFunctionDeclaration = node.type === "FunctionDeclaration";
+				const exprRange = /** @type {Range} */ (node.range);
+				const statementRange = /** @type {Range} */ (statement.range);
+				const comments = parser.getComments([statementRange[0], exprRange[0]]);
+				const dep = new HarmonyExportExpressionDependency(
+					exprRange,
+					statementRange,
+					comments
+						.map(c => {
+							switch (c.type) {
+								case "Block":
+									return `/*${c.value}*/`;
+								case "Line":
+									return `//${c.value}\n`;
+							}
+							return "";
+						})
+						.join(""),
+					node.type.endsWith("Declaration") &&
+					/** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
+						? /** @type {FunctionDeclaration | ClassDeclaration} */
+							(node).id.name
+						: isFunctionDeclaration
+							? {
+									range: [
+										exprRange[0],
+										node.params.length > 0
+											? /** @type {Range} */ (node.params[0].range)[0]
+											: /** @type {Range} */ (node.body.range)[0]
+									],
+									prefix: `${node.async ? "async " : ""}function${
+										node.generator ? "*" : ""
+									} `,
+									suffix: `(${node.params.length > 0 ? "" : ") "}`
+								}
+							: undefined
+				);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
+				dep.loc.index = -1;
+				parser.state.current.addDependency(dep);
+				InnerGraph.addVariableUsage(
+					parser,
+					node.type.endsWith("Declaration") &&
+						/** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
+						? /** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
+								.name
+						: "*default*",
+					"default"
+				);
+				return true;
+			}
+		);
+		parser.hooks.exportSpecifier.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, id, name, idx) => {
+				const settings = parser.getTagData(id, harmonySpecifierTag);
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				harmonyNamedExports.add(name);
+				InnerGraph.addVariableUsage(parser, id, name);
+				const dep = settings
+					? new HarmonyExportImportedSpecifierDependency(
+							settings.source,
+							settings.sourceOrder,
+							settings.ids,
+							name,
+							harmonyNamedExports,
+							null,
+							exportPresenceMode,
+							null,
+							settings.attributes
+						)
+					: new HarmonyExportSpecifierDependency(id, name);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
+				dep.loc.index = idx;
+				const isAsiSafe = !parser.isAsiPosition(
+					/** @type {Range} */
+					(statement.range)[0]
+				);
+				if (!isAsiSafe) {
+					parser.setAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				}
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		);
+		parser.hooks.exportImportSpecifier.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, source, id, name, idx) => {
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				let harmonyStarExports = null;
+				if (name) {
+					harmonyNamedExports.add(name);
+				} else {
+					harmonyStarExports = parser.state.harmonyStarExports =
+						parser.state.harmonyStarExports || new HarmonyStarExportsList();
+				}
+				const attributes = getImportAttributes(statement);
+				const dep = new HarmonyExportImportedSpecifierDependency(
+					/** @type {string} */ (source),
+					parser.state.lastHarmonyImportOrder,
+					id ? [id] : [],
+					name,
+					harmonyNamedExports,
+					harmonyStarExports && harmonyStarExports.slice(),
+					exportPresenceMode,
+					harmonyStarExports,
+					attributes
+				);
+				if (harmonyStarExports) {
+					harmonyStarExports.push(dep);
+				}
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
+				dep.loc.index = idx;
+				const isAsiSafe = !parser.isAsiPosition(
+					/** @type {Range} */
+					(statement.range)[0]
+				);
+				if (!isAsiSafe) {
+					parser.setAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				}
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		);
+	}
+};

app_vue/node_modules/webpack/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -0,0 +1,207 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ConcatenationScope = require("../ConcatenationScope");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class HarmonyExportExpressionDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range} rangeStatement range statement
+	 * @param {string} prefix prefix
+	 * @param {string | { range: Range, prefix: string, suffix: string }=} declarationId declaration id
+	 */
+	constructor(range, rangeStatement, prefix, declarationId) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
+		this.prefix = prefix;
+		this.declarationId = declarationId;
+	}
+
+	get type() {
+		return "harmony export expression";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: ["default"],
+			priority: 1,
+			terminalBinding: true,
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		// The expression/declaration is already covered by SideEffectsFlagPlugin
+		return false;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.rangeStatement);
+		write(this.prefix);
+		write(this.declarationId);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.rangeStatement = read();
+		this.prefix = read();
+		this.declarationId = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyExportExpressionDependency,
+	"webpack/lib/dependencies/HarmonyExportExpressionDependency"
+);
+
+HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate 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,
+		{
+			module,
+			moduleGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			initFragments,
+			runtime,
+			concatenationScope
+		}
+	) {
+		const dep = /** @type {HarmonyExportExpressionDependency} */ (dependency);
+		const { declarationId } = dep;
+		const exportsName = module.exportsArgument;
+		if (declarationId) {
+			let name;
+			if (typeof declarationId === "string") {
+				name = declarationId;
+			} else {
+				name = ConcatenationScope.DEFAULT_EXPORT;
+				source.replace(
+					declarationId.range[0],
+					declarationId.range[1] - 1,
+					`${declarationId.prefix}${name}${declarationId.suffix}`
+				);
+			}
+
+			if (concatenationScope) {
+				concatenationScope.registerExport("default", name);
+			} else {
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName("default", runtime);
+				if (used) {
+					const map = new Map();
+					map.set(used, `/* export default binding */ ${name}`);
+					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+				}
+			}
+
+			source.replace(
+				dep.rangeStatement[0],
+				dep.range[0] - 1,
+				`/* harmony default export */ ${dep.prefix}`
+			);
+		} else {
+			/** @type {string} */
+			let content;
+			const name = ConcatenationScope.DEFAULT_EXPORT;
+			if (runtimeTemplate.supportsConst()) {
+				content = `/* harmony default export */ const ${name} = `;
+				if (concatenationScope) {
+					concatenationScope.registerExport("default", name);
+				} else {
+					const used = moduleGraph
+						.getExportsInfo(module)
+						.getUsedName("default", runtime);
+					if (used) {
+						runtimeRequirements.add(RuntimeGlobals.exports);
+						const map = new Map();
+						map.set(used, name);
+						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+					} else {
+						content = `/* unused harmony default export */ var ${name} = `;
+					}
+				}
+			} else if (concatenationScope) {
+				content = `/* harmony default export */ var ${name} = `;
+				concatenationScope.registerExport("default", name);
+			} else {
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName("default", runtime);
+				if (used) {
+					runtimeRequirements.add(RuntimeGlobals.exports);
+					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
+					content = `/* harmony default export */ ${exportsName}${propertyAccess(
+						typeof used === "string" ? [used] : used
+					)} = `;
+				} else {
+					content = `/* unused harmony default export */ var ${name} = `;
+				}
+			}
+
+			if (dep.range) {
+				source.replace(
+					dep.rangeStatement[0],
+					dep.range[0] - 1,
+					`${content}(${dep.prefix}`
+				);
+				source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
+				return;
+			}
+
+			source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
+		}
+	}
+};
+
+module.exports = HarmonyExportExpressionDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyExportHeaderDependency.js

@@ -0,0 +1,78 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+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 */
+
+class HarmonyExportHeaderDependency extends NullDependency {
+	/**
+	 * @param {Range | false} range range
+	 * @param {Range} rangeStatement range statement
+	 */
+	constructor(range, rangeStatement) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
+	}
+
+	get type() {
+		return "harmony export header";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.rangeStatement);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.rangeStatement = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyExportHeaderDependency,
+	"webpack/lib/dependencies/HarmonyExportHeaderDependency"
+);
+
+HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate 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, templateContext) {
+		const dep = /** @type {HarmonyExportHeaderDependency} */ (dependency);
+		const content = "";
+		const replaceUntil = dep.range
+			? dep.range[0] - 1
+			: dep.rangeStatement[1] - 1;
+		source.replace(dep.rangeStatement[0], replaceUntil, content);
+	}
+};
+
+module.exports = HarmonyExportHeaderDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyExportInitFragment.js

@@ -0,0 +1,177 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const InitFragment = require("../InitFragment");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const { first } = require("../util/SetHelpers");
+const { propertyName } = require("../util/propertyName");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+
+/**
+ * @param {Iterable<string>} iterable iterable strings
+ * @returns {string} result
+ */
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
+	}
+	return str;
+};
+
+const EMPTY_MAP = new Map();
+const EMPTY_SET = new Set();
+
+/**
+ * @extends {InitFragment<GenerateContext>} Context
+ */
+class HarmonyExportInitFragment extends InitFragment {
+	/**
+	 * @param {string} exportsArgument the exports identifier
+	 * @param {Map<string, string>} exportMap mapping from used name to exposed variable name
+	 * @param {Set<string>} unusedExports list of unused export names
+	 */
+	constructor(
+		exportsArgument,
+		exportMap = EMPTY_MAP,
+		unusedExports = EMPTY_SET
+	) {
+		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
+		this.exportsArgument = exportsArgument;
+		this.exportMap = exportMap;
+		this.unusedExports = unusedExports;
+	}
+
+	/**
+	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
+	 * @returns {HarmonyExportInitFragment} merged fragment
+	 */
+	mergeAll(fragments) {
+		let exportMap;
+		let exportMapOwned = false;
+		let unusedExports;
+		let unusedExportsOwned = false;
+
+		for (const fragment of fragments) {
+			if (fragment.exportMap.size !== 0) {
+				if (exportMap === undefined) {
+					exportMap = fragment.exportMap;
+					exportMapOwned = false;
+				} else {
+					if (!exportMapOwned) {
+						exportMap = new Map(exportMap);
+						exportMapOwned = true;
+					}
+					for (const [key, value] of fragment.exportMap) {
+						if (!exportMap.has(key)) exportMap.set(key, value);
+					}
+				}
+			}
+			if (fragment.unusedExports.size !== 0) {
+				if (unusedExports === undefined) {
+					unusedExports = fragment.unusedExports;
+					unusedExportsOwned = false;
+				} else {
+					if (!unusedExportsOwned) {
+						unusedExports = new Set(unusedExports);
+						unusedExportsOwned = true;
+					}
+					for (const value of fragment.unusedExports) {
+						unusedExports.add(value);
+					}
+				}
+			}
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
+	/**
+	 * @param {HarmonyExportInitFragment} other other
+	 * @returns {HarmonyExportInitFragment} merged result
+	 */
+	merge(other) {
+		let exportMap;
+		if (this.exportMap.size === 0) {
+			exportMap = other.exportMap;
+		} else if (other.exportMap.size === 0) {
+			exportMap = this.exportMap;
+		} else {
+			exportMap = new Map(other.exportMap);
+			for (const [key, value] of this.exportMap) {
+				if (!exportMap.has(key)) exportMap.set(key, value);
+			}
+		}
+		let unusedExports;
+		if (this.unusedExports.size === 0) {
+			unusedExports = other.unusedExports;
+		} else if (other.unusedExports.size === 0) {
+			unusedExports = this.unusedExports;
+		} else {
+			unusedExports = new Set(other.unusedExports);
+			for (const value of this.unusedExports) {
+				unusedExports.add(value);
+			}
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
+	/**
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
+	 */
+	getContent({ runtimeTemplate, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+
+		const unusedPart =
+			this.unusedExports.size > 1
+				? `/* unused harmony exports ${joinIterableWithComma(
+						this.unusedExports
+					)} */\n`
+				: this.unusedExports.size > 0
+					? `/* unused harmony export ${first(this.unusedExports)} */\n`
+					: "";
+		const definitions = [];
+		const orderedExportMap = Array.from(this.exportMap).sort(([a], [b]) =>
+			a < b ? -1 : 1
+		);
+		for (const [key, value] of orderedExportMap) {
+			definitions.push(
+				`\n/* harmony export */   ${propertyName(
+					key
+				)}: ${runtimeTemplate.returningFunction(value)}`
+			);
+		}
+		const definePart =
+			this.exportMap.size > 0
+				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+					}, {${definitions.join(",")}\n/* harmony export */ });\n`
+				: "";
+		return `${definePart}${unusedPart}`;
+	}
+}
+
+module.exports = HarmonyExportInitFragment;

app_vue/node_modules/webpack/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -0,0 +1,123 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class HarmonyExportSpecifierDependency extends NullDependency {
+	/**
+	 * @param {string} id the id
+	 * @param {string} name the name
+	 */
+	constructor(id, name) {
+		super();
+		this.id = id;
+		this.name = name;
+	}
+
+	get type() {
+		return "harmony export specifier";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: [this.name],
+			priority: 1,
+			terminalBinding: true,
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.id);
+		write(this.name);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.id = read();
+		this.name = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyExportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyExportSpecifierDependency"
+);
+
+HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate 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,
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
+	) {
+		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
+		if (concatenationScope) {
+			concatenationScope.registerExport(dep.name, dep.id);
+			return;
+		}
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.name, runtime);
+		if (!used) {
+			const set = new Set();
+			set.add(dep.name || "namespace");
+			initFragments.push(
+				new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
+			);
+			return;
+		}
+
+		const map = new Map();
+		map.set(used, `/* binding */ ${dep.id}`);
+		initFragments.push(
+			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
+		);
+	}
+};
+
+module.exports = HarmonyExportSpecifierDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyExports.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Parser").ParserState} ParserState */
+
+/** @type {WeakMap<ParserState, boolean>} */
+const parserStateExportsState = new WeakMap();
+
+/**
+ * @param {ParserState} parserState parser state
+ * @param {boolean} isStrictHarmony strict harmony mode should be enabled
+ * @returns {void}
+ */
+module.exports.enable = (parserState, isStrictHarmony) => {
+	const value = parserStateExportsState.get(parserState);
+	if (value === false) return;
+	parserStateExportsState.set(parserState, true);
+	if (value !== true) {
+		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		buildMeta.exportsType = "namespace";
+		const buildInfo = /** @type {BuildInfo} */ (parserState.module.buildInfo);
+		buildInfo.strict = true;
+		buildInfo.exportsArgument = RuntimeGlobals.exports;
+		if (isStrictHarmony) {
+			buildMeta.strictHarmonyModule = true;
+			buildInfo.moduleArgument = "__webpack_module__";
+		}
+	}
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+module.exports.isEnabled = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	return value === true;
+};

app_vue/node_modules/webpack/lib/dependencies/HarmonyImportDependency.js

@@ -0,0 +1,384 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ConditionalInitFragment = require("../ConditionalInitFragment");
+const Dependency = require("../Dependency");
+const HarmonyLinkingError = require("../HarmonyLinkingError");
+const InitFragment = require("../InitFragment");
+const Template = require("../Template");
+const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const { filterRuntime, mergeRuntime } = require("../util/runtime");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/** @typedef {0 | 1 | 2 | 3 | false} ExportPresenceMode */
+
+const ExportPresenceModes = {
+	NONE: /** @type {ExportPresenceMode} */ (0),
+	WARN: /** @type {ExportPresenceMode} */ (1),
+	AUTO: /** @type {ExportPresenceMode} */ (2),
+	ERROR: /** @type {ExportPresenceMode} */ (3),
+	/**
+	 * @param {string | false} str param
+	 * @returns {ExportPresenceMode} result
+	 */
+	fromUserOption(str) {
+		switch (str) {
+			case "error":
+				return ExportPresenceModes.ERROR;
+			case "warn":
+				return ExportPresenceModes.WARN;
+			case "auto":
+				return ExportPresenceModes.AUTO;
+			case false:
+				return ExportPresenceModes.NONE;
+			default:
+				throw new Error(`Invalid export presence value ${str}`);
+		}
+	}
+};
+
+class HarmonyImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 * @param {number} sourceOrder source order
+	 * @param {ImportAttributes=} attributes import attributes
+	 */
+	constructor(request, sourceOrder, attributes) {
+		super(request);
+		this.sourceOrder = sourceOrder;
+		this.assertions = attributes;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string} name of the variable for the import
+	 */
+	getImportVar(moduleGraph) {
+		const module = /** @type {Module} */ (moduleGraph.getParentModule(this));
+		const meta = moduleGraph.getMeta(module);
+		let importVarMap = meta.importVarMap;
+		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
+		let importVar = importVarMap.get(
+			/** @type {Module} */ (moduleGraph.getModule(this))
+		);
+		if (importVar) return importVar;
+		importVar = `${Template.toIdentifier(
+			`${this.userRequest}`
+		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
+		importVarMap.set(
+			/** @type {Module} */ (moduleGraph.getModule(this)),
+			importVar
+		);
+		return importVar;
+	}
+
+	/**
+	 * @param {boolean} update create new variables or update existing one
+	 * @param {DependencyTemplateContext} templateContext the template context
+	 * @returns {[string, string]} the import statement and the compat statement
+	 */
+	getImportStatement(
+		update,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		return runtimeTemplate.importStatement({
+			update,
+			module: /** @type {Module} */ (moduleGraph.getModule(this)),
+			chunkGraph,
+			importVar: this.getImportVar(moduleGraph),
+			request: this.request,
+			originModule: module,
+			runtimeRequirements
+		});
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {string[]} ids imported ids
+	 * @param {string} additionalMessage extra info included in the error message
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	getLinkingErrors(moduleGraph, ids, additionalMessage) {
+		const importedModule = moduleGraph.getModule(this);
+		// ignore errors for missing or failed modules
+		if (!importedModule || importedModule.getNumberOfErrors() > 0) {
+			return;
+		}
+
+		const parentModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(this));
+		const exportsType = importedModule.getExportsType(
+			moduleGraph,
+			/** @type {BuildMeta} */ (parentModule.buildMeta).strictHarmonyModule
+		);
+		if (exportsType === "namespace" || exportsType === "default-with-named") {
+			if (ids.length === 0) {
+				return;
+			}
+
+			if (
+				(exportsType !== "default-with-named" || ids[0] !== "default") &&
+				moduleGraph.isExportProvided(importedModule, ids) === false
+			) {
+				// We are sure that it's not provided
+
+				// Try to provide detailed info in the error message
+				let pos = 0;
+				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+				while (pos < ids.length && exportsInfo) {
+					const id = ids[pos++];
+					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+					if (exportInfo.provided === false) {
+						// We are sure that it's not provided
+						const providedExports = exportsInfo.getProvidedExports();
+						const moreInfo = !Array.isArray(providedExports)
+							? " (possible exports unknown)"
+							: providedExports.length === 0
+								? " (module has no exports)"
+								: ` (possible exports: ${providedExports.join(", ")})`;
+						return [
+							new HarmonyLinkingError(
+								`export ${ids
+									.slice(0, pos)
+									.map(id => `'${id}'`)
+									.join(".")} ${additionalMessage} was not found in '${
+									this.userRequest
+								}'${moreInfo}`
+							)
+						];
+					}
+					exportsInfo =
+						/** @type {ExportsInfo} */
+						(exportInfo.getNestedExportsInfo());
+				}
+
+				// General error message
+				return [
+					new HarmonyLinkingError(
+						`export ${ids
+							.map(id => `'${id}'`)
+							.join(".")} ${additionalMessage} was not found in '${
+							this.userRequest
+						}'`
+					)
+				];
+			}
+		}
+		switch (exportsType) {
+			case "default-only":
+				// It's has only a default export
+				if (ids.length > 0 && ids[0] !== "default") {
+					// In strict harmony modules we only support the default export
+					return [
+						new HarmonyLinkingError(
+							`Can't import the named export ${ids
+								.map(id => `'${id}'`)
+								.join(
+									"."
+								)} ${additionalMessage} from default-exporting module (only default export is available)`
+						)
+					];
+				}
+				break;
+			case "default-with-named":
+				// It has a default export and named properties redirect
+				// In some cases we still want to warn here
+				if (
+					ids.length > 0 &&
+					ids[0] !== "default" &&
+					/** @type {BuildMeta} */
+					(importedModule.buildMeta).defaultObject === "redirect-warn"
+				) {
+					// For these modules only the default export is supported
+					return [
+						new HarmonyLinkingError(
+							`Should not import the named export ${ids
+								.map(id => `'${id}'`)
+								.join(
+									"."
+								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
+						)
+					];
+				}
+				break;
+		}
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.sourceOrder);
+		write(this.assertions);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.sourceOrder = read();
+		this.assertions = read();
+		super.deserialize(context);
+	}
+}
+
+module.exports = HarmonyImportDependency;
+
+/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
+const importEmittedMap = new WeakMap();
+
+HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends (
+	ModuleDependency.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, templateContext) {
+		const dep = /** @type {HarmonyImportDependency} */ (dependency);
+		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
+
+		const connection = moduleGraph.getConnection(dep);
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const referencedModule = connection && connection.module;
+
+		if (
+			connection &&
+			connection.weak &&
+			referencedModule &&
+			chunkGraph.getModuleId(referencedModule) === null
+		) {
+			// in weak references, module might not be in any chunk
+			// but that's ok, we don't need that logic in this case
+			return;
+		}
+
+		const moduleKey = referencedModule
+			? referencedModule.identifier()
+			: dep.request;
+		const key = `harmony import ${moduleKey}`;
+
+		const runtimeCondition = dep.weak
+			? false
+			: connection
+				? filterRuntime(runtime, r => connection.isTargetActive(r))
+				: true;
+
+		if (module && referencedModule) {
+			let emittedModules = importEmittedMap.get(module);
+			if (emittedModules === undefined) {
+				emittedModules = new WeakMap();
+				importEmittedMap.set(module, emittedModules);
+			}
+			let mergedRuntimeCondition = runtimeCondition;
+			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+					mergedRuntimeCondition = oldRuntimeCondition;
+				} else {
+					mergedRuntimeCondition = mergeRuntime(
+						oldRuntimeCondition,
+						mergedRuntimeCondition
+					);
+				}
+			}
+			emittedModules.set(referencedModule, mergedRuntimeCondition);
+		}
+
+		const importStatement = dep.getImportStatement(false, templateContext);
+		if (
+			referencedModule &&
+			templateContext.moduleGraph.isAsync(referencedModule)
+		) {
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[0],
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key,
+					runtimeCondition
+				)
+			);
+			templateContext.initFragments.push(
+				new AwaitDependenciesInitFragment(
+					new Set([dep.getImportVar(templateContext.moduleGraph)])
+				)
+			);
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[1],
+					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					`${key} compat`,
+					runtimeCondition
+				)
+			);
+		} else {
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[0] + importStatement[1],
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key,
+					runtimeCondition
+				)
+			);
+		}
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {Module} referencedModule the referenced module
+	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
+	 */
+	static getImportEmittedRuntime(module, referencedModule) {
+		const emittedModules = importEmittedMap.get(module);
+		if (emittedModules === undefined) return false;
+		return emittedModules.get(referencedModule) || false;
+	}
+};
+
+module.exports.ExportPresenceModes = ExportPresenceModes;

app_vue/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -0,0 +1,375 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
+const { getImportAttributes } = require("../javascript/JavascriptParser");
+const InnerGraph = require("../optimize/InnerGraph");
+const ConstDependency = require("./ConstDependency");
+const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
+const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
+const HarmonyExports = require("./HarmonyExports");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("../javascript/JavascriptParser").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").TagData} TagData */
+/** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
+/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
+/** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
+
+const harmonySpecifierTag = Symbol("harmony import");
+
+/**
+ * @typedef {object} HarmonySettings
+ * @property {string[]} ids
+ * @property {string} source
+ * @property {number} sourceOrder
+ * @property {string} name
+ * @property {boolean} await
+ * @property {ImportAttributes=} attributes
+ */
+
+module.exports = class HarmonyImportDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		this.exportPresenceMode =
+			options.importExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
+				: options.exportsPresence !== undefined
+					? ExportPresenceModes.fromUserOption(options.exportsPresence)
+					: options.strictExportPresence
+						? ExportPresenceModes.ERROR
+						: ExportPresenceModes.AUTO;
+		this.strictThisContextOnImports = options.strictThisContextOnImports;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const { exportPresenceMode } = this;
+
+		/**
+		 * @param {string[]} members members
+		 * @param {boolean[]} membersOptionals members Optionals
+		 * @returns {string[]} a non optional part
+		 */
+		function getNonOptionalPart(members, membersOptionals) {
+			let i = 0;
+			while (i < members.length && membersOptionals[i] === false) i++;
+			return i !== members.length ? members.slice(0, i) : members;
+		}
+
+		/**
+		 * @param {TODO} node member expression
+		 * @param {number} count count
+		 * @returns {Expression} member expression
+		 */
+		function getNonOptionalMemberChain(node, count) {
+			while (count--) node = node.object;
+			return node;
+		}
+
+		parser.hooks.isPure
+			.for("Identifier")
+			.tap("HarmonyImportDependencyParserPlugin", expression => {
+				const expr = /** @type {Identifier} */ (expression);
+				if (
+					parser.isVariableDefined(expr.name) ||
+					parser.getTagData(expr.name, harmonySpecifierTag)
+				) {
+					return true;
+				}
+			});
+		parser.hooks.import.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				const attributes = getImportAttributes(statement);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					/** @type {string} */ (source),
+					parser.state.lastHarmonyImportOrder,
+					attributes
+				);
+				sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				parser.state.module.addDependency(sideEffectDep);
+				return true;
+			}
+		);
+		parser.hooks.importSpecifier.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source, id, name) => {
+				const ids = id === null ? [] : [id];
+				parser.tagVariable(name, harmonySpecifierTag, {
+					name,
+					source,
+					ids,
+					sourceOrder: parser.state.lastHarmonyImportOrder,
+					attributes: getImportAttributes(statement)
+				});
+				return true;
+			}
+		);
+		parser.hooks.binaryExpression.tap(
+			"HarmonyImportDependencyParserPlugin",
+			expression => {
+				if (expression.operator !== "in") return;
+
+				const leftPartEvaluated = parser.evaluateExpression(expression.left);
+				if (leftPartEvaluated.couldHaveSideEffects()) return;
+				const leftPart = leftPartEvaluated.asString();
+				if (!leftPart) return;
+
+				const rightPart = parser.evaluateExpression(expression.right);
+				if (!rightPart.isIdentifier()) return;
+
+				const rootInfo = rightPart.rootInfo;
+				if (
+					typeof rootInfo === "string" ||
+					!rootInfo ||
+					!rootInfo.tagInfo ||
+					rootInfo.tagInfo.tag !== harmonySpecifierTag
+				)
+					return;
+				const settings = /** @type {TagData} */ (rootInfo.tagInfo.data);
+				const members =
+					/** @type {(() => string[])} */
+					(rightPart.getMembers)();
+				const dep = new HarmonyEvaluatedImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					settings.ids.concat(members).concat([leftPart]),
+					settings.name,
+					/** @type {Range} */ (expression.range),
+					settings.attributes,
+					"in"
+				);
+				dep.directImport = members.length === 0;
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expression.range)[0]
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expression.loc);
+				parser.state.module.addDependency(dep);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			}
+		);
+		parser.hooks.expression
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					settings.ids,
+					settings.name,
+					/** @type {Range} */
+					(expr.range),
+					exportPresenceMode,
+					settings.attributes,
+					[]
+				);
+				dep.referencedPropertiesInDestructuring =
+					parser.destructuringAssignmentPropertiesFor(expr);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.call = parser.scope.inTaggedTemplateTag;
+				parser.state.module.addDependency(dep);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		parser.hooks.expressionMemberChain
+			.for(harmonySpecifierTag)
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals, memberRanges) => {
+					const settings =
+						/** @type {HarmonySettings} */
+						(parser.currentTagData);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					/** @type {Range[]} */
+					const ranges = memberRanges.slice(
+						0,
+						memberRanges.length - (members.length - nonOptionalMembers.length)
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									expression,
+									members.length - nonOptionalMembers.length
+								)
+							: expression;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						/** @type {Range} */
+						(expr.range),
+						exportPresenceMode,
+						settings.attributes,
+						ranges
+					);
+					dep.referencedPropertiesInDestructuring =
+						parser.destructuringAssignmentPropertiesFor(expr);
+					dep.asiSafe = !parser.isAsiPosition(
+						/** @type {Range} */
+						(expr.range)[0]
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
+		parser.hooks.callMemberChain
+			.for(harmonySpecifierTag)
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals, memberRanges) => {
+					const { arguments: args, callee } = expression;
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					/** @type {Range[]} */
+					const ranges = memberRanges.slice(
+						0,
+						memberRanges.length - (members.length - nonOptionalMembers.length)
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									callee,
+									members.length - nonOptionalMembers.length
+								)
+							: callee;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						/** @type {Range} */ (expr.range),
+						exportPresenceMode,
+						settings.attributes,
+						ranges
+					);
+					dep.directImport = members.length === 0;
+					dep.call = true;
+					dep.asiSafe = !parser.isAsiPosition(
+						/** @type {Range} */ (expr.range)[0]
+					);
+					// only in case when we strictly follow the spec we need a special case here
+					dep.namespaceObjectAsContext =
+						members.length > 0 &&
+						/** @type {boolean} */ (this.strictThisContextOnImports);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+					if (args) parser.walkExpressions(args);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
+		const { hotAcceptCallback, hotAcceptWithoutCallback } =
+			HotModuleReplacementPlugin.getParserHooks(parser);
+		hotAcceptCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				if (!HarmonyExports.isEnabled(parser.state)) {
+					// This is not a harmony module, skip it
+					return;
+				}
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(request);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						/** @type {Range} */
+						(expr.range),
+						dependencies,
+						true
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+		hotAcceptWithoutCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				if (!HarmonyExports.isEnabled(parser.state)) {
+					// This is not a harmony module, skip it
+					return;
+				}
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(request);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						/** @type {Range} */
+						(expr.range),
+						dependencies,
+						false
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+	}
+};
+
+module.exports.harmonySpecifierTag = harmonySpecifierTag;

app_vue/node_modules/webpack/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -0,0 +1,86 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder source order
+	 * @param {ImportAttributes=} attributes import attributes
+	 */
+	constructor(request, sourceOrder, attributes) {
+		super(request, sourceOrder, attributes);
+	}
+
+	get type() {
+		return "harmony side effect evaluation";
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return connection => {
+			const refModule = connection.resolvedModule;
+			if (!refModule) return true;
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		const refModule = moduleGraph.getModule(this);
+		if (!refModule) return true;
+		return refModule.getSideEffectsConnectionState(moduleGraph);
+	}
+}
+
+makeSerializable(
+	HarmonyImportSideEffectDependency,
+	"webpack/lib/dependencies/HarmonyImportSideEffectDependency"
+);
+
+HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends (
+	HarmonyImportDependency.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, templateContext) {
+		const { moduleGraph, concatenationScope } = templateContext;
+		if (concatenationScope) {
+			const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
+			if (concatenationScope.isModuleInScope(module)) {
+				return;
+			}
+		}
+		super.apply(dependency, source, templateContext);
+	}
+};
+
+module.exports = HarmonyImportSideEffectDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -0,0 +1,468 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const Template = require("../Template");
+const {
+	getDependencyUsedByExportsCondition
+} = require("../optimize/InnerGraph");
+const { getTrimmedIdsAndRange } = require("../util/chainedImports");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
+
+const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
+
+const { ExportPresenceModes } = HarmonyImportDependency;
+
+class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
+	/**
+	 * @param {string} request request
+	 * @param {number} sourceOrder source order
+	 * @param {string[]} ids ids
+	 * @param {string} name name
+	 * @param {Range} range range
+	 * @param {ExportPresenceMode} exportPresenceMode export presence mode
+	 * @param {ImportAttributes | undefined} attributes import attributes
+	 * @param {Range[] | undefined} idRanges ranges for members of ids; the two arrays are right-aligned
+	 */
+	constructor(
+		request,
+		sourceOrder,
+		ids,
+		name,
+		range,
+		exportPresenceMode,
+		attributes,
+		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
+	) {
+		super(request, sourceOrder, attributes);
+		this.ids = ids;
+		this.name = name;
+		this.range = range;
+		this.idRanges = idRanges;
+		this.exportPresenceMode = exportPresenceMode;
+		this.namespaceObjectAsContext = false;
+		this.call = undefined;
+		this.directImport = undefined;
+		this.shorthand = undefined;
+		this.asiSafe = undefined;
+		/** @type {Set<string> | boolean | undefined} */
+		this.usedByExports = undefined;
+		/** @type {Set<DestructuringAssignmentProperty> | undefined} */
+		this.referencedPropertiesInDestructuring = undefined;
+	}
+
+	// TODO webpack 6 remove
+	get id() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
+
+	// TODO webpack 6 remove
+	getId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
+
+	// TODO webpack 6 remove
+	setId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
+
+	get type() {
+		return "harmony import specifier";
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported ids
+	 */
+	getIds(moduleGraph) {
+		const meta = moduleGraph.getMetaIfExisting(this);
+		if (meta === undefined) return this.ids;
+		const ids = meta[idsSymbol];
+		return ids !== undefined ? ids : this.ids;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		let ids = this.getIds(moduleGraph);
+		if (ids.length === 0) return this._getReferencedExportsInDestructuring();
+		let namespaceObjectAsContext = this.namespaceObjectAsContext;
+		if (ids[0] === "default") {
+			const selfModule =
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this));
+			const importedModule =
+				/** @type {Module} */
+				(moduleGraph.getModule(this));
+			switch (
+				importedModule.getExportsType(
+					moduleGraph,
+					/** @type {BuildMeta} */
+					(selfModule.buildMeta).strictHarmonyModule
+				)
+			) {
+				case "default-only":
+				case "default-with-named":
+					if (ids.length === 1)
+						return this._getReferencedExportsInDestructuring();
+					ids = ids.slice(1);
+					namespaceObjectAsContext = true;
+					break;
+				case "dynamic":
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+			}
+		}
+
+		if (
+			this.call &&
+			!this.directImport &&
+			(namespaceObjectAsContext || ids.length > 1)
+		) {
+			if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
+			ids = ids.slice(0, -1);
+		}
+
+		return this._getReferencedExportsInDestructuring(ids);
+	}
+
+	/**
+	 * @param {string[]=} ids ids
+	 * @returns {string[][]} referenced exports
+	 */
+	_getReferencedExportsInDestructuring(ids) {
+		if (this.referencedPropertiesInDestructuring) {
+			/** @type {string[][]} */
+			const refs = [];
+			for (const { id } of this.referencedPropertiesInDestructuring) {
+				refs.push(ids ? ids.concat([id]) : [id]);
+			}
+			return refs;
+		}
+		return ids ? [ids] : Dependency.EXPORTS_OBJECT_REFERENCED;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		const buildMeta =
+			/** @type {BuildMeta} */
+			(
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this)).buildMeta
+			);
+		return buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
+	}
+
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} errors
+	 */
+	getErrors(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		return this.getLinkingErrors(
+			moduleGraph,
+			ids,
+			`(imported as '${this.name}')`
+		);
+	}
+
+	/**
+	 * implement this method to allow the occurrence order plugin to count correctly
+	 * @returns {number} count how often the id is used in this dependency
+	 */
+	getNumberOfIdOccurrences() {
+		return 0;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.ids);
+		write(this.name);
+		write(this.range);
+		write(this.idRanges);
+		write(this.exportPresenceMode);
+		write(this.namespaceObjectAsContext);
+		write(this.call);
+		write(this.directImport);
+		write(this.shorthand);
+		write(this.asiSafe);
+		write(this.usedByExports);
+		write(this.referencedPropertiesInDestructuring);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.ids = read();
+		this.name = read();
+		this.range = read();
+		this.idRanges = read();
+		this.exportPresenceMode = read();
+		this.namespaceObjectAsContext = read();
+		this.call = read();
+		this.directImport = read();
+		this.shorthand = read();
+		this.asiSafe = read();
+		this.usedByExports = read();
+		this.referencedPropertiesInDestructuring = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
+);
+
+HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
+	HarmonyImportDependency.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, templateContext) {
+		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
+		const { moduleGraph, runtime } = templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const ids = dep.getIds(moduleGraph);
+		const {
+			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
+			trimmedIds
+		} = getTrimmedIdsAndRange(ids, dep.range, dep.idRanges, moduleGraph, dep);
+
+		const exportExpr = this._getCodeForIds(
+			dep,
+			source,
+			templateContext,
+			trimmedIds
+		);
+		if (dep.shorthand) {
+			source.insert(trimmedRangeEnd, `: ${exportExpr}`);
+		} else {
+			source.replace(trimmedRangeStart, trimmedRangeEnd - 1, exportExpr);
+		}
+
+		if (dep.referencedPropertiesInDestructuring) {
+			let prefixedIds = ids;
+
+			if (ids[0] === "default") {
+				const selfModule =
+					/** @type {Module} */
+					(moduleGraph.getParentModule(dep));
+				const importedModule =
+					/** @type {Module} */
+					(moduleGraph.getModule(dep));
+				const exportsType = importedModule.getExportsType(
+					moduleGraph,
+					/** @type {BuildMeta} */
+					(selfModule.buildMeta).strictHarmonyModule
+				);
+				if (
+					(exportsType === "default-only" ||
+						exportsType === "default-with-named") &&
+					ids.length >= 1
+				) {
+					prefixedIds = ids.slice(1);
+				}
+			}
+
+			for (const {
+				id,
+				shorthand,
+				range
+			} of dep.referencedPropertiesInDestructuring) {
+				const concatedIds = prefixedIds.concat([id]);
+				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName(concatedIds, runtime);
+				if (!used) return;
+				const newName = used[used.length - 1];
+				const name = concatedIds[concatedIds.length - 1];
+				if (newName === name) continue;
+
+				const comment = `${Template.toNormalComment(name)} `;
+				const key = comment + JSON.stringify(newName);
+				source.replace(
+					/** @type {Range} */
+					(range)[0],
+					/** @type {Range} */
+					(range)[1] - 1,
+					shorthand ? `${key}: ${name}` : `${key}`
+				);
+			}
+		}
+	}
+
+	/**
+	 * @param {HarmonyImportSpecifierDependency} dep dependency
+	 * @param {ReplaceSource} source source
+	 * @param {DependencyTemplateContext} templateContext context
+	 * @param {string[]} ids ids
+	 * @returns {string} generated code
+	 */
+	_getCodeForIds(dep, source, templateContext, ids) {
+		const { moduleGraph, module, runtime, concatenationScope } =
+			templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		let exportExpr;
+		if (
+			connection &&
+			concatenationScope &&
+			concatenationScope.isModuleInScope(connection.module)
+		) {
+			if (ids.length === 0) {
+				exportExpr = concatenationScope.createModuleReference(
+					connection.module,
+					{
+						asiSafe: dep.asiSafe
+					}
+				);
+			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
+				exportExpr =
+					concatenationScope.createModuleReference(connection.module, {
+						asiSafe: dep.asiSafe
+					}) + propertyAccess(ids);
+			} else {
+				exportExpr = concatenationScope.createModuleReference(
+					connection.module,
+					{
+						ids,
+						call: dep.call,
+						directImport: dep.directImport,
+						asiSafe: dep.asiSafe
+					}
+				);
+			}
+		} else {
+			super.apply(dep, source, templateContext);
+
+			const { runtimeTemplate, initFragments, runtimeRequirements } =
+				templateContext;
+
+			exportExpr = runtimeTemplate.exportFromImport({
+				moduleGraph,
+				module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+				request: dep.request,
+				exportName: ids,
+				originModule: module,
+				asiSafe: dep.shorthand ? true : dep.asiSafe,
+				isCall: dep.call,
+				callContext: !dep.directImport,
+				defaultInterop: true,
+				importVar: dep.getImportVar(moduleGraph),
+				initFragments,
+				runtime,
+				runtimeRequirements
+			});
+		}
+		return exportExpr;
+	}
+};
+
+module.exports = HarmonyImportSpecifierDependency;

app_vue/node_modules/webpack/lib/dependencies/HarmonyModulesPlugin.js

@@ -0,0 +1,149 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
+const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
+const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
+const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
+const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
+const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
+const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
+const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
+const HarmonyTopLevelThisParserPlugin = require("./HarmonyTopLevelThisParserPlugin");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "HarmonyModulesPlugin";
+
+/** @typedef {{ topLevelAwait?: boolean }} HarmonyModulesPluginOptions */
+
+class HarmonyModulesPlugin {
+	/**
+	 * @param {HarmonyModulesPluginOptions} options options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					HarmonyCompatibilityDependency,
+					new HarmonyCompatibilityDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyImportSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportSideEffectDependency,
+					new HarmonyImportSideEffectDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportSpecifierDependency,
+					new HarmonyImportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyEvaluatedImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyEvaluatedImportSpecifierDependency,
+					new HarmonyEvaluatedImportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					HarmonyExportHeaderDependency,
+					new HarmonyExportHeaderDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					HarmonyExportExpressionDependency,
+					new HarmonyExportExpressionDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					HarmonyExportSpecifierDependency,
+					new HarmonyExportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyExportImportedSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyExportImportedSpecifierDependency,
+					new HarmonyExportImportedSpecifierDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					HarmonyAcceptDependency,
+					new HarmonyAcceptDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyAcceptImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyAcceptImportDependency,
+					new HarmonyAcceptImportDependency.Template()
+				);
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					// TODO webpack 6: rename harmony to esm or module
+					if (parserOptions.harmony !== undefined && !parserOptions.harmony)
+						return;
+
+					new HarmonyDetectionParserPlugin(this.options).apply(parser);
+					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyTopLevelThisParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+module.exports = HarmonyModulesPlugin;

app_vue/node_modules/webpack/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+"use strict";
+
+const ConstDependency = require("./ConstDependency");
+const HarmonyExports = require("./HarmonyExports");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
+
+class HarmonyTopLevelThisParserPlugin {
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.expression.for("this").tap(PLUGIN_NAME, node => {
+			if (!parser.scope.topLevelScope) return;
+			if (HarmonyExports.isEnabled(parser.state)) {
+				const dep = new ConstDependency(
+					"undefined",
+					/** @type {Range} */ (node.range),
+					null
+				);
+				dep.loc = /** @type {DependencyLocation} */ (node.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		});
+	}
+}
+
+module.exports = HarmonyTopLevelThisParserPlugin;

app_vue/node_modules/webpack/lib/dependencies/ImportContextDependency.js

@@ -0,0 +1,68 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+class ImportContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options
+	 * @param {Range} range range
+	 * @param {Range} valueRange value range
+	 */
+	constructor(options, range, valueRange) {
+		super(options);
+
+		this.range = range;
+		this.valueRange = valueRange;
+	}
+
+	get type() {
+		return `import() context ${this.options.mode}`;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.valueRange);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.valueRange = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ImportContextDependency,
+	"webpack/lib/dependencies/ImportContextDependency"
+);
+
+ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportContextDependency;

app_vue/node_modules/webpack/lib/dependencies/ImportDependency.js

@@ -0,0 +1,139 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {Range} range expression range
+	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {ImportAttributes=} attributes import attributes
+	 */
+	constructor(request, range, referencedExports, attributes) {
+		super(request);
+		this.range = range;
+		this.referencedExports = referencedExports;
+		this.assertions = attributes;
+	}
+
+	get type() {
+		return "import()";
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		const refs = [];
+		for (const referencedExport of this.referencedExports) {
+			if (referencedExport[0] === "default") {
+				const selfModule =
+					/** @type {Module} */
+					(moduleGraph.getParentModule(this));
+				const importedModule =
+					/** @type {Module} */
+					(moduleGraph.getModule(this));
+				const exportsType = importedModule.getExportsType(
+					moduleGraph,
+					/** @type {BuildMeta} */
+					(selfModule.buildMeta).strictHarmonyModule
+				);
+				if (
+					exportsType === "default-only" ||
+					exportsType === "default-with-named"
+				) {
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				}
+			}
+			refs.push({
+				name: referencedExport,
+				canMangle: false
+			});
+		}
+		return refs;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.range);
+		context.write(this.referencedExports);
+		context.write(this.assertions);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.range = context.read();
+		this.referencedExports = context.read();
+		this.assertions = context.read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(ImportDependency, "webpack/lib/dependencies/ImportDependency");
+
+ImportDependency.Template = class ImportDependencyTemplate extends (
+	ModuleDependency.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,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			block,
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+			request: dep.request,
+			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
+			message: "import()",
+			runtimeRequirements
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+};
+
+module.exports = ImportDependency;

app_vue/node_modules/webpack/lib/dependencies/ImportEagerDependency.js

@@ -0,0 +1,74 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ImportDependency = require("./ImportDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ImportEagerDependency extends ImportDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {Range} range expression range
+	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {ImportAttributes=} attributes import attributes
+	 */
+	constructor(request, range, referencedExports, attributes) {
+		super(request, range, referencedExports, attributes);
+	}
+
+	get type() {
+		return "import() eager";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+makeSerializable(
+	ImportEagerDependency,
+	"webpack/lib/dependencies/ImportEagerDependency"
+);
+
+ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
+	ImportDependency.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,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportEagerDependency} */ (dependency);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+			request: dep.request,
+			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
+			message: "import() eager",
+			runtimeRequirements
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+};
+
+module.exports = ImportEagerDependency;

app_vue/node_modules/webpack/lib/dependencies/ImportMetaContextDependency.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+class ImportMetaContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options
+	 * @param {Range} range range
+	 */
+	constructor(options, range) {
+		super(options);
+
+		this.range = range;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	get type() {
+		return `import.meta.webpackContext ${this.options.mode}`;
+	}
+}
+
+makeSerializable(
+	ImportMetaContextDependency,
+	"webpack/lib/dependencies/ImportMetaContextDependency"
+);
+
+ImportMetaContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = ImportMetaContextDependency;

app_vue/node_modules/webpack/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -0,0 +1,307 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const WebpackError = require("../WebpackError");
+const {
+	evaluateToIdentifier
+} = require("../javascript/JavascriptParserHelpers");
+const ImportMetaContextDependency = require("./ImportMetaContextDependency");
+
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../ContextModule").ContextModuleOptions} ContextModuleOptions */
+/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {Pick<ContextModuleOptions, 'mode'|'recursive'|'regExp'|'include'|'exclude'|'chunkName'>&{groupOptions: RawChunkGroupOptions, exports?: ContextModuleOptions["referencedExports"]}} ImportMetaContextOptions */
+
+/**
+ * @param {Property} prop property
+ * @param {string} expect except message
+ * @returns {WebpackError} error
+ */
+function createPropertyParseError(prop, expect) {
+	return createError(
+		`Parsing import.meta.webpackContext options failed. Unknown value for property ${JSON.stringify(
+			/** @type {Identifier} */
+			(prop.key).name
+		)}, expected type ${expect}.`,
+		/** @type {DependencyLocation} */
+		(prop.value.loc)
+	);
+}
+
+/**
+ * @param {string} msg message
+ * @param {DependencyLocation} loc location
+ * @returns {WebpackError} error
+ */
+function createError(msg, loc) {
+	const error = new WebpackError(msg);
+	error.name = "ImportMetaContextError";
+	error.loc = loc;
+	return error;
+}
+
+const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
+
+module.exports = class ImportMetaContextDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.evaluateIdentifier
+			.for("import.meta.webpackContext")
+			.tap(PLUGIN_NAME, expr =>
+				evaluateToIdentifier(
+					"import.meta.webpackContext",
+					"import.meta",
+					() => ["webpackContext"],
+					true
+				)(expr)
+			);
+		parser.hooks.call
+			.for("import.meta.webpackContext")
+			.tap(PLUGIN_NAME, expr => {
+				if (expr.arguments.length < 1 || expr.arguments.length > 2) return;
+				const [directoryNode, optionsNode] = expr.arguments;
+				if (optionsNode && optionsNode.type !== "ObjectExpression") return;
+				const requestExpr = parser.evaluateExpression(
+					/** @type {Expression} */ (directoryNode)
+				);
+				if (!requestExpr.isString()) return;
+				const request = /** @type {string} */ (requestExpr.string);
+				const errors = [];
+				let regExp = /^\.\/.*$/;
+				let recursive = true;
+				/** @type {ContextModuleOptions["mode"]} */
+				let mode = "sync";
+				/** @type {ContextModuleOptions["include"]} */
+				let include;
+				/** @type {ContextModuleOptions["exclude"]} */
+				let exclude;
+				/** @type {RawChunkGroupOptions} */
+				const groupOptions = {};
+				/** @type {ContextModuleOptions["chunkName"]} */
+				let chunkName;
+				/** @type {ContextModuleOptions["referencedExports"]} */
+				let exports;
+				if (optionsNode) {
+					for (const prop of /** @type {ObjectExpression} */ (optionsNode)
+						.properties) {
+						if (prop.type !== "Property" || prop.key.type !== "Identifier") {
+							errors.push(
+								createError(
+									"Parsing import.meta.webpackContext options failed.",
+									/** @type {DependencyLocation} */
+									(optionsNode.loc)
+								)
+							);
+							break;
+						}
+						switch (prop.key.name) {
+							case "regExp": {
+								const regExpExpr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (!regExpExpr.isRegExp()) {
+									errors.push(createPropertyParseError(prop, "RegExp"));
+								} else {
+									regExp = /** @type {RegExp} */ (regExpExpr.regExp);
+								}
+								break;
+							}
+							case "include": {
+								const regExpExpr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (!regExpExpr.isRegExp()) {
+									errors.push(createPropertyParseError(prop, "RegExp"));
+								} else {
+									include = regExpExpr.regExp;
+								}
+								break;
+							}
+							case "exclude": {
+								const regExpExpr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (!regExpExpr.isRegExp()) {
+									errors.push(createPropertyParseError(prop, "RegExp"));
+								} else {
+									exclude = regExpExpr.regExp;
+								}
+								break;
+							}
+							case "mode": {
+								const modeExpr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (!modeExpr.isString()) {
+									errors.push(createPropertyParseError(prop, "string"));
+								} else {
+									mode = /** @type {ContextModuleOptions["mode"]} */ (
+										modeExpr.string
+									);
+								}
+								break;
+							}
+							case "chunkName": {
+								const expr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (!expr.isString()) {
+									errors.push(createPropertyParseError(prop, "string"));
+								} else {
+									chunkName = expr.string;
+								}
+								break;
+							}
+							case "exports": {
+								const expr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (expr.isString()) {
+									exports = [[/** @type {string} */ (expr.string)]];
+								} else if (expr.isArray()) {
+									const items =
+										/** @type {BasicEvaluatedExpression[]} */
+										(expr.items);
+									if (
+										items.every(i => {
+											if (!i.isArray()) return false;
+											const innerItems =
+												/** @type {BasicEvaluatedExpression[]} */ (i.items);
+											return innerItems.every(i => i.isString());
+										})
+									) {
+										exports = [];
+										for (const i1 of items) {
+											/** @type {string[]} */
+											const export_ = [];
+											for (const i2 of /** @type {BasicEvaluatedExpression[]} */ (
+												i1.items
+											)) {
+												export_.push(/** @type {string} */ (i2.string));
+											}
+											exports.push(export_);
+										}
+									} else {
+										errors.push(
+											createPropertyParseError(prop, "string|string[][]")
+										);
+									}
+								} else {
+									errors.push(
+										createPropertyParseError(prop, "string|string[][]")
+									);
+								}
+								break;
+							}
+							case "prefetch": {
+								const expr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (expr.isBoolean()) {
+									groupOptions.prefetchOrder = 0;
+								} else if (expr.isNumber()) {
+									groupOptions.prefetchOrder = expr.number;
+								} else {
+									errors.push(createPropertyParseError(prop, "boolean|number"));
+								}
+								break;
+							}
+							case "preload": {
+								const expr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (expr.isBoolean()) {
+									groupOptions.preloadOrder = 0;
+								} else if (expr.isNumber()) {
+									groupOptions.preloadOrder = expr.number;
+								} else {
+									errors.push(createPropertyParseError(prop, "boolean|number"));
+								}
+								break;
+							}
+							case "fetchPriority": {
+								const expr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (
+									expr.isString() &&
+									["high", "low", "auto"].includes(
+										/** @type {string} */ (expr.string)
+									)
+								) {
+									groupOptions.fetchPriority =
+										/** @type {RawChunkGroupOptions["fetchPriority"]} */ (
+											expr.string
+										);
+								} else {
+									errors.push(
+										createPropertyParseError(prop, '"high"|"low"|"auto"')
+									);
+								}
+								break;
+							}
+							case "recursive": {
+								const recursiveExpr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (!recursiveExpr.isBoolean()) {
+									errors.push(createPropertyParseError(prop, "boolean"));
+								} else {
+									recursive = /** @type {boolean} */ (recursiveExpr.bool);
+								}
+								break;
+							}
+							default:
+								errors.push(
+									createError(
+										`Parsing import.meta.webpackContext options failed. Unknown property ${JSON.stringify(
+											prop.key.name
+										)}.`,
+										/** @type {DependencyLocation} */ (optionsNode.loc)
+									)
+								);
+						}
+					}
+				}
+				if (errors.length) {
+					for (const error of errors) parser.state.current.addError(error);
+					return;
+				}
+
+				const dep = new ImportMetaContextDependency(
+					{
+						request,
+						include,
+						exclude,
+						recursive,
+						regExp,
+						groupOptions,
+						chunkName,
+						referencedExports: exports,
+						mode,
+						category: "esm"
+					},
+					/** @type {Range} */ (expr.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
+				return true;
+			});
+	}
+};

app_vue/node_modules/webpack/lib/dependencies/ImportMetaContextPlugin.js

@@ -0,0 +1,72 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const ContextElementDependency = require("./ContextElementDependency");
+const ImportMetaContextDependency = require("./ImportMetaContextDependency");
+const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDependencyParserPlugin");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "ImportMetaContextPlugin";
+
+class ImportMetaContextPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ImportMetaContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaContextDependency,
+					new ImportMetaContextDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ContextElementDependency,
+					normalModuleFactory
+				);
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.importMetaContext !== undefined &&
+						!parserOptions.importMetaContext
+					)
+						return;
+
+					new ImportMetaContextDependencyParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+module.exports = ImportMetaContextPlugin;

app_vue/node_modules/webpack/lib/dependencies/ImportMetaHotAcceptDependency.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ImportMetaHotAcceptDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "import.meta.webpackHot.accept";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+makeSerializable(
+	ImportMetaHotAcceptDependency,
+	"webpack/lib/dependencies/ImportMetaHotAcceptDependency"
+);
+
+ImportMetaHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ImportMetaHotAcceptDependency;

app_vue/node_modules/webpack/lib/dependencies/ImportMetaHotDeclineDependency.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ImportMetaHotDeclineDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "import.meta.webpackHot.decline";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+makeSerializable(
+	ImportMetaHotDeclineDependency,
+	"webpack/lib/dependencies/ImportMetaHotDeclineDependency"
+);
+
+ImportMetaHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ImportMetaHotDeclineDependency;

app_vue/node_modules/webpack/lib/dependencies/ImportMetaPlugin.js

@@ -0,0 +1,253 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const { pathToFileURL } = require("url");
+const ModuleDependencyWarning = require("../ModuleDependencyWarning");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const Template = require("../Template");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const {
+	evaluateToIdentifier,
+	toConstantDependency,
+	evaluateToString,
+	evaluateToNumber
+} = require("../javascript/JavascriptParserHelpers");
+const memoize = require("../util/memoize");
+const propertyAccess = require("../util/propertyAccess");
+const ConstDependency = require("./ConstDependency");
+
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const getCriticalDependencyWarning = memoize(() =>
+	require("./CriticalDependencyWarning")
+);
+
+const PLUGIN_NAME = "ImportMetaPlugin";
+
+class ImportMetaPlugin {
+	/**
+	 * @param {Compiler} compiler compiler
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {NormalModule} module module
+				 * @returns {string} file url
+				 */
+				const getUrl = module => pathToFileURL(module.resource).toString();
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const parserHandler = (parser, { importMeta }) => {
+					if (importMeta === false) {
+						const { importMetaName } = compilation.outputOptions;
+						if (importMetaName === "import.meta") return;
+
+						parser.hooks.expression
+							.for("import.meta")
+							.tap(PLUGIN_NAME, metaProperty => {
+								const dep = new ConstDependency(
+									/** @type {string} */ (importMetaName),
+									/** @type {Range} */ (metaProperty.range)
+								);
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+						return;
+					}
+
+					// import.meta direct
+					const webpackVersion = Number.parseInt(
+						require("../../package.json").version,
+						10
+					);
+					const importMetaUrl = () =>
+						JSON.stringify(getUrl(parser.state.module));
+					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+					/**
+					 * @param {string[]} members members
+					 * @returns {string} error message
+					 */
+					const importMetaUnknownProperty = members =>
+						`${Template.toNormalComment(
+							`unsupported import.meta.${members.join(".")}`
+						)} undefined${propertyAccess(members, 1)}`;
+					parser.hooks.typeof
+						.for("import.meta")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.expression
+						.for("import.meta")
+						.tap(PLUGIN_NAME, metaProperty => {
+							const referencedPropertiesInDestructuring =
+								parser.destructuringAssignmentPropertiesFor(metaProperty);
+							if (!referencedPropertiesInDestructuring) {
+								const CriticalDependencyWarning =
+									getCriticalDependencyWarning();
+								parser.state.module.addWarning(
+									new ModuleDependencyWarning(
+										parser.state.module,
+										new CriticalDependencyWarning(
+											"Accessing import.meta directly is unsupported (only property access or destructuring is supported)"
+										),
+										/** @type {DependencyLocation} */ (metaProperty.loc)
+									)
+								);
+								const dep = new ConstDependency(
+									`${
+										parser.isAsiPosition(
+											/** @type {Range} */ (metaProperty.range)[0]
+										)
+											? ";"
+											: ""
+									}({})`,
+									/** @type {Range} */ (metaProperty.range)
+								);
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
+
+							let str = "";
+							for (const { id: prop } of referencedPropertiesInDestructuring) {
+								switch (prop) {
+									case "url":
+										str += `url: ${importMetaUrl()},`;
+										break;
+									case "webpack":
+										str += `webpack: ${importMetaWebpackVersion()},`;
+										break;
+									default:
+										str += `[${JSON.stringify(
+											prop
+										)}]: ${importMetaUnknownProperty([prop])},`;
+										break;
+								}
+							}
+							const dep = new ConstDependency(
+								`({${str}})`,
+								/** @type {Range} */ (metaProperty.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta")
+						.tap(PLUGIN_NAME, evaluateToString("object"));
+					parser.hooks.evaluateIdentifier.for("import.meta").tap(
+						PLUGIN_NAME,
+						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
+					);
+
+					// import.meta.url
+					parser.hooks.typeof
+						.for("import.meta.url")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("string"))
+						);
+					parser.hooks.expression
+						.for("import.meta.url")
+						.tap(PLUGIN_NAME, expr => {
+							const dep = new ConstDependency(
+								importMetaUrl(),
+								/** @type {Range} */ (expr.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta.url")
+						.tap(PLUGIN_NAME, evaluateToString("string"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.url")
+						.tap(PLUGIN_NAME, expr =>
+							new BasicEvaluatedExpression()
+								.setString(getUrl(parser.state.module))
+								.setRange(/** @type {Range} */ (expr.range))
+						);
+
+					// import.meta.webpack
+					parser.hooks.typeof
+						.for("import.meta.webpack")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("number"))
+						);
+					parser.hooks.expression
+						.for("import.meta.webpack")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, importMetaWebpackVersion())
+						);
+					parser.hooks.evaluateTypeof
+						.for("import.meta.webpack")
+						.tap(PLUGIN_NAME, evaluateToString("number"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.webpack")
+						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
+
+					// Unknown properties
+					parser.hooks.unhandledExpressionMemberChain
+						.for("import.meta")
+						.tap(PLUGIN_NAME, (expr, members) => {
+							const dep = new ConstDependency(
+								importMetaUnknownProperty(members),
+								/** @type {Range} */ (expr.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluate
+						.for("MemberExpression")
+						.tap(PLUGIN_NAME, expression => {
+							const expr = /** @type {MemberExpression} */ (expression);
+							if (
+								expr.object.type === "MetaProperty" &&
+								expr.object.meta.name === "import" &&
+								expr.object.property.name === "meta" &&
+								expr.property.type ===
+									(expr.computed ? "Literal" : "Identifier")
+							) {
+								return new BasicEvaluatedExpression()
+									.setUndefined()
+									.setRange(/** @type {Range} */ (expr.range));
+							}
+						});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserHandler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserHandler);
+			}
+		);
+	}
+}
+
+module.exports = ImportMetaPlugin;

app_vue/node_modules/webpack/lib/dependencies/ImportParserPlugin.js

@@ -0,0 +1,339 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const { getImportAttributes } = require("../javascript/JavascriptParser");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const ImportContextDependency = require("./ImportContextDependency");
+const ImportDependency = require("./ImportDependency");
+const ImportEagerDependency = require("./ImportEagerDependency");
+const ImportWeakDependency = require("./ImportWeakDependency");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ImportParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		/**
+		 * @template T
+		 * @param {Iterable<T>} enumerable enumerable
+		 * @returns {T[][]} array of array
+		 */
+		const exportsFromEnumerable = enumerable =>
+			Array.from(enumerable, e => [e]);
+		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
+			const param = parser.evaluateExpression(expr.source);
+
+			let chunkName = null;
+			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
+			let include = null;
+			let exclude = null;
+			/** @type {string[][] | null} */
+			let exports = null;
+			/** @type {RawChunkGroupOptions} */
+			const groupOptions = {};
+
+			const {
+				dynamicImportPreload,
+				dynamicImportPrefetch,
+				dynamicImportFetchPriority
+			} = this.options;
+			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
+				groupOptions.preloadOrder =
+					dynamicImportPreload === true ? 0 : dynamicImportPreload;
+			if (
+				dynamicImportPrefetch !== undefined &&
+				dynamicImportPrefetch !== false
+			)
+				groupOptions.prefetchOrder =
+					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+			if (
+				dynamicImportFetchPriority !== undefined &&
+				dynamicImportFetchPriority !== false
+			)
+				groupOptions.fetchPriority = dynamicImportFetchPriority;
+
+			const { options: importOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+
+			if (importOptions) {
+				if (importOptions.webpackIgnore !== undefined) {
+					if (typeof importOptions.webpackIgnore !== "boolean") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else if (importOptions.webpackIgnore) {
+						// Do not instrument `import()` if `webpackIgnore` is `true`
+						return false;
+					}
+				}
+				if (importOptions.webpackChunkName !== undefined) {
+					if (typeof importOptions.webpackChunkName !== "string") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						chunkName = importOptions.webpackChunkName;
+					}
+				}
+				if (importOptions.webpackMode !== undefined) {
+					if (typeof importOptions.webpackMode !== "string") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						mode = /** @type {ContextMode} */ (importOptions.webpackMode);
+					}
+				}
+				if (importOptions.webpackPrefetch !== undefined) {
+					if (importOptions.webpackPrefetch === true) {
+						groupOptions.prefetchOrder = 0;
+					} else if (typeof importOptions.webpackPrefetch === "number") {
+						groupOptions.prefetchOrder = importOptions.webpackPrefetch;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+				}
+				if (importOptions.webpackPreload !== undefined) {
+					if (importOptions.webpackPreload === true) {
+						groupOptions.preloadOrder = 0;
+					} else if (typeof importOptions.webpackPreload === "number") {
+						groupOptions.preloadOrder = importOptions.webpackPreload;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+				}
+				if (importOptions.webpackFetchPriority !== undefined) {
+					if (
+						typeof importOptions.webpackFetchPriority === "string" &&
+						["high", "low", "auto"].includes(importOptions.webpackFetchPriority)
+					) {
+						groupOptions.fetchPriority =
+							/** @type {"low" | "high" | "auto"} */
+							(importOptions.webpackFetchPriority);
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+				}
+				if (importOptions.webpackInclude !== undefined) {
+					if (
+						!importOptions.webpackInclude ||
+						!(importOptions.webpackInclude instanceof RegExp)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						include = importOptions.webpackInclude;
+					}
+				}
+				if (importOptions.webpackExclude !== undefined) {
+					if (
+						!importOptions.webpackExclude ||
+						!(importOptions.webpackExclude instanceof RegExp)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						exclude = importOptions.webpackExclude;
+					}
+				}
+				if (importOptions.webpackExports !== undefined) {
+					if (
+						!(
+							typeof importOptions.webpackExports === "string" ||
+							(Array.isArray(importOptions.webpackExports) &&
+								/** @type {string[]} */ (importOptions.webpackExports).every(
+									item => typeof item === "string"
+								))
+						)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else if (typeof importOptions.webpackExports === "string") {
+						exports = [[importOptions.webpackExports]];
+					} else {
+						exports = exportsFromEnumerable(importOptions.webpackExports);
+					}
+				}
+			}
+
+			if (
+				mode !== "lazy" &&
+				mode !== "lazy-once" &&
+				mode !== "eager" &&
+				mode !== "weak"
+			) {
+				parser.state.module.addWarning(
+					new UnsupportedFeatureWarning(
+						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+						/** @type {DependencyLocation} */ (expr.loc)
+					)
+				);
+				mode = "lazy";
+			}
+
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(expr);
+			if (referencedPropertiesInDestructuring) {
+				if (exports) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							"`webpackExports` could not be used with destructuring assignment.",
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				}
+				exports = exportsFromEnumerable(
+					[...referencedPropertiesInDestructuring].map(({ id }) => id)
+				);
+			}
+
+			if (param.isString()) {
+				const attributes = getImportAttributes(expr);
+
+				if (mode === "eager") {
+					const dep = new ImportEagerDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports,
+						attributes
+					);
+					parser.state.current.addDependency(dep);
+				} else if (mode === "weak") {
+					const dep = new ImportWeakDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports,
+						attributes
+					);
+					parser.state.current.addDependency(dep);
+				} else {
+					const depBlock = new AsyncDependenciesBlock(
+						{
+							...groupOptions,
+							name: chunkName
+						},
+						/** @type {DependencyLocation} */ (expr.loc),
+						param.string
+					);
+					const dep = new ImportDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports,
+						attributes
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					depBlock.addDependency(dep);
+					parser.state.current.addBlock(depBlock);
+				}
+				return true;
+			}
+			if (mode === "weak") {
+				mode = "async-weak";
+			}
+			const dep = ContextDependencyHelpers.create(
+				ImportContextDependency,
+				/** @type {Range} */ (expr.range),
+				param,
+				expr,
+				this.options,
+				{
+					chunkName,
+					groupOptions,
+					include,
+					exclude,
+					mode,
+					namespaceObject: /** @type {BuildMeta} */ (
+						parser.state.module.buildMeta
+					).strictHarmonyModule
+						? "strict"
+						: true,
+					typePrefix: "import()",
+					category: "esm",
+					referencedExports: exports,
+					attributes: getImportAttributes(expr)
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		});
+	}
+}
+
+module.exports = ImportParserPlugin;

app_vue/node_modules/webpack/lib/dependencies/ImportPlugin.js

@@ -0,0 +1,96 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const ImportContextDependency = require("./ImportContextDependency");
+const ImportDependency = require("./ImportDependency");
+const ImportEagerDependency = require("./ImportEagerDependency");
+const ImportParserPlugin = require("./ImportParserPlugin");
+const ImportWeakDependency = require("./ImportWeakDependency");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "ImportPlugin";
+
+class ImportPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportDependency,
+					new ImportDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ImportEagerDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportEagerDependency,
+					new ImportEagerDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ImportWeakDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportWeakDependency,
+					new ImportWeakDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ImportContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportContextDependency,
+					new ImportContextDependency.Template()
+				);
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.import !== undefined && !parserOptions.import)
+						return;
+
+					new ImportParserPlugin(parserOptions).apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+module.exports = ImportPlugin;

app_vue/node_modules/webpack/lib/dependencies/ImportWeakDependency.js

@@ -0,0 +1,72 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ImportDependency = require("./ImportDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ImportWeakDependency extends ImportDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {Range} range expression range
+	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {ImportAttributes=} attributes import attributes
+	 */
+	constructor(request, range, referencedExports, attributes) {
+		super(request, range, referencedExports, attributes);
+		this.weak = true;
+	}
+
+	get type() {
+		return "import() weak";
+	}
+}
+
+makeSerializable(
+	ImportWeakDependency,
+	"webpack/lib/dependencies/ImportWeakDependency"
+);
+
+ImportWeakDependency.Template = class ImportDependencyTemplate extends (
+	ImportDependency.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,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportWeakDependency} */ (dependency);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+			request: dep.request,
+			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
+			message: "import() weak",
+			weak: true,
+			runtimeRequirements
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+};
+
+module.exports = ImportWeakDependency;

app_vue/node_modules/webpack/lib/dependencies/JsonExportsDependency.js

@@ -0,0 +1,133 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../json/JsonData")} JsonData */
+/** @typedef {import("../json/JsonData").JsonValue} JsonValue */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+/**
+ * @callback GetExportsFromDataFn
+ * @param {JsonValue} data raw json data
+ * @param {number=} curDepth current depth
+ * @returns {ExportSpec[] | null} export spec or nothing
+ */
+
+/**
+ * @param {number} exportsDepth exportsDepth
+ * @returns {GetExportsFromDataFn} value
+ */
+const getExportsWithDepth = exportsDepth =>
+	/** @type {GetExportsFromDataFn} */
+	function getExportsFromData(data, curDepth = 1) {
+		if (curDepth > exportsDepth) {
+			return null;
+		}
+
+		if (data && typeof data === "object") {
+			if (Array.isArray(data)) {
+				return data.length < 100
+					? data.map((item, idx) => ({
+							name: `${idx}`,
+							canMangle: true,
+							exports: getExportsFromData(item, curDepth + 1) || undefined
+						}))
+					: null;
+			}
+
+			/** @type {ExportSpec[]} */
+			const exports = [];
+
+			for (const key of Object.keys(data)) {
+				exports.push({
+					name: key,
+					canMangle: true,
+					exports: getExportsFromData(data[key], curDepth + 1) || undefined
+				});
+			}
+
+			return exports;
+		}
+
+		return null;
+	};
+
+class JsonExportsDependency extends NullDependency {
+	/**
+	 * @param {JsonData} data json data
+	 * @param {number} exportsDepth the depth of json exports to analyze
+	 */
+	constructor(data, exportsDepth) {
+		super();
+		this.data = data;
+		this.exportsDepth = exportsDepth;
+	}
+
+	get type() {
+		return "json exports";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: getExportsWithDepth(this.exportsDepth)(
+				this.data && /** @type {JsonValue} */ (this.data.get())
+			),
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		this.data.updateHash(hash);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.data);
+		write(this.exportsDepth);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.data = read();
+		this.exportsDepth = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	JsonExportsDependency,
+	"webpack/lib/dependencies/JsonExportsDependency"
+);
+
+module.exports = JsonExportsDependency;

app_vue/node_modules/webpack/lib/dependencies/LoaderDependency.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class LoaderDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 */
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "loader";
+	}
+
+	get category() {
+		return "loader";
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
+}
+
+module.exports = LoaderDependency;

app_vue/node_modules/webpack/lib/dependencies/LoaderImportDependency.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class LoaderImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 */
+	constructor(request) {
+		super(request);
+		this.weak = true;
+	}
+
+	get type() {
+		return "loader import";
+	}
+
+	get category() {
+		return "loaderImport";
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
+}
+
+module.exports = LoaderImportDependency;

app_vue/node_modules/webpack/lib/dependencies/LoaderPlugin.js

@@ -0,0 +1,284 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const LazySet = require("../util/LazySet");
+const LoaderDependency = require("./LoaderDependency");
+const LoaderImportDependency = require("./LoaderImportDependency");
+
+/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
+/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleExports} ExecuteModuleExports */
+/** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+
+/**
+ * @callback ImportModuleCallback
+ * @param {(Error | null)=} err error object
+ * @param {ExecuteModuleExports=} exports exports of the evaluated module
+ */
+
+/**
+ * @typedef {object} ImportModuleOptions
+ * @property {string=} layer the target layer
+ * @property {string=} publicPath the target public path
+ * @property {string=} baseUri target base uri
+ */
+
+const PLUGIN_NAME = "LoaderPlugin";
+
+class LoaderPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					LoaderDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					LoaderImportDependency,
+					normalModuleFactory
+				);
+			}
+		);
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				PLUGIN_NAME,
+				loaderContext => {
+					loaderContext.loadModule = (request, callback) => {
+						const dep = new LoaderDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+						const oldFactorizeQueueContext =
+							compilation.factorizeQueue.getContext();
+						compilation.factorizeQueue.setContext("load-module");
+						const oldAddModuleQueueContext =
+							compilation.addModuleQueue.getContext();
+						compilation.addModuleQueue.setContext("load-module");
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
+								context: loaderContext.context,
+								recursive: false
+							},
+							err => {
+								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
+								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								if (referencedModule.getNumberOfErrors() > 0) {
+									return callback(
+										new Error("The loaded module contains errors")
+									);
+								}
+								const moduleSource = referencedModule.originalSource();
+								if (!moduleSource) {
+									return callback(
+										new Error(
+											"The module created for a LoaderDependency must have an original source"
+										)
+									);
+								}
+								let map;
+								let source;
+								if (moduleSource.sourceAndMap) {
+									const sourceAndMap = moduleSource.sourceAndMap();
+									map = sourceAndMap.map;
+									source = sourceAndMap.source;
+								} else {
+									map = moduleSource.map();
+									source = moduleSource.source();
+								}
+								const fileDependencies = new LazySet();
+								const contextDependencies = new LazySet();
+								const missingDependencies = new LazySet();
+								const buildDependencies = new LazySet();
+								referencedModule.addCacheDependencies(
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								);
+
+								for (const d of fileDependencies) {
+									loaderContext.addDependency(d);
+								}
+								for (const d of contextDependencies) {
+									loaderContext.addContextDependency(d);
+								}
+								for (const d of missingDependencies) {
+									loaderContext.addMissingDependency(d);
+								}
+								for (const d of buildDependencies) {
+									loaderContext.addBuildDependency(d);
+								}
+								return callback(null, source, map, referencedModule);
+							}
+						);
+					};
+
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback} callback callback returning the exports
+					 * @returns {void}
+					 */
+					const importModule = (request, options, callback) => {
+						const dep = new LoaderImportDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+
+						const oldFactorizeQueueContext =
+							compilation.factorizeQueue.getContext();
+						compilation.factorizeQueue.setContext("import-module");
+						const oldAddModuleQueueContext =
+							compilation.addModuleQueue.getContext();
+						compilation.addModuleQueue.setContext("import-module");
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
+								contextInfo: {
+									issuerLayer: options.layer
+								},
+								context: loaderContext.context,
+								connectOrigin: false,
+								checkCycle: true
+							},
+							err => {
+								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
+								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								compilation.buildQueue.increaseParallelism();
+								compilation.executeModule(
+									referencedModule,
+									{
+										entryOptions: {
+											baseUri: options.baseUri,
+											publicPath: options.publicPath
+										}
+									},
+									(err, result) => {
+										compilation.buildQueue.decreaseParallelism();
+										if (err) return callback(err);
+										const {
+											fileDependencies,
+											contextDependencies,
+											missingDependencies,
+											buildDependencies,
+											cacheable,
+											assets,
+											exports
+										} = /** @type {ExecuteModuleResult} */ (result);
+										for (const d of fileDependencies) {
+											loaderContext.addDependency(d);
+										}
+										for (const d of contextDependencies) {
+											loaderContext.addContextDependency(d);
+										}
+										for (const d of missingDependencies) {
+											loaderContext.addMissingDependency(d);
+										}
+										for (const d of buildDependencies) {
+											loaderContext.addBuildDependency(d);
+										}
+										if (cacheable === false) loaderContext.cacheable(false);
+										for (const [name, { source, info }] of assets) {
+											const buildInfo =
+												/** @type {BuildInfo} */
+												(
+													/** @type {NormalModule} */ (loaderContext._module)
+														.buildInfo
+												);
+											if (!buildInfo.assets) {
+												buildInfo.assets = Object.create(null);
+												buildInfo.assetsInfo = new Map();
+											}
+											/** @type {NonNullable<BuildInfo["assets"]>} */
+											(buildInfo.assets)[name] = source;
+											/** @type {NonNullable<BuildInfo["assetsInfo"]>} */
+											(buildInfo.assetsInfo).set(name, info);
+										}
+										callback(null, exports);
+									}
+								);
+							}
+						);
+					};
+
+					// @ts-expect-error overloading doesn't work
+					loaderContext.importModule = (request, options, callback) => {
+						if (!callback) {
+							return new Promise((resolve, reject) => {
+								importModule(request, options || {}, (err, result) => {
+									if (err) reject(err);
+									else resolve(result);
+								});
+							});
+						}
+						return importModule(request, options || {}, callback);
+					};
+				}
+			);
+		});
+	}
+}
+module.exports = LoaderPlugin;

app_vue/node_modules/webpack/lib/dependencies/LocalModule.js

@@ -0,0 +1,60 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class LocalModule {
+	/**
+	 * @param {string} name name
+	 * @param {number} idx index
+	 */
+	constructor(name, idx) {
+		this.name = name;
+		this.idx = idx;
+		this.used = false;
+	}
+
+	flagUsed() {
+		this.used = true;
+	}
+
+	/**
+	 * @returns {string} variable name
+	 */
+	variableName() {
+		return `__WEBPACK_LOCAL_MODULE_${this.idx}__`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.name);
+		write(this.idx);
+		write(this.used);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.name = read();
+		this.idx = read();
+		this.used = read();
+	}
+}
+
+makeSerializable(LocalModule, "webpack/lib/dependencies/LocalModule");
+
+module.exports = LocalModule;

app_vue/node_modules/webpack/lib/dependencies/LocalModuleDependency.js

@@ -0,0 +1,84 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+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 */
+/** @typedef {import("./LocalModule")} LocalModule */
+
+class LocalModuleDependency extends NullDependency {
+	/**
+	 * @param {LocalModule} localModule local module
+	 * @param {Range | undefined} range range
+	 * @param {boolean} callNew true, when the local module should be called with new
+	 */
+	constructor(localModule, range, callNew) {
+		super();
+
+		this.localModule = localModule;
+		this.range = range;
+		this.callNew = callNew;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.localModule);
+		write(this.range);
+		write(this.callNew);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.localModule = read();
+		this.range = read();
+		this.callNew = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	LocalModuleDependency,
+	"webpack/lib/dependencies/LocalModuleDependency"
+);
+
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate 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, templateContext) {
+		const dep = /** @type {LocalModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const moduleInstance = dep.callNew
+			? `new (function () { return ${dep.localModule.variableName()}; })()`
+			: dep.localModule.variableName();
+		source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
+	}
+};
+
+module.exports = LocalModuleDependency;

app_vue/node_modules/webpack/lib/dependencies/LocalModulesHelpers.js

@@ -0,0 +1,68 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const LocalModule = require("./LocalModule");
+
+/** @typedef {import("../javascript/JavascriptParser").ParserState} ParserState */
+
+/**
+ * @param {string} parent parent module
+ * @param {string} mod module to resolve
+ * @returns {string} resolved module
+ */
+const lookup = (parent, mod) => {
+	if (mod.charAt(0) !== ".") return mod;
+
+	const path = parent.split("/");
+	const segments = mod.split("/");
+	path.pop();
+
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (seg === "..") {
+			path.pop();
+		} else if (seg !== ".") {
+			path.push(seg);
+		}
+	}
+
+	return path.join("/");
+};
+
+/**
+ * @param {ParserState} state parser state
+ * @param {string} name name
+ * @returns {LocalModule} local module
+ */
+module.exports.addLocalModule = (state, name) => {
+	if (!state.localModules) {
+		state.localModules = [];
+	}
+	const m = new LocalModule(name, state.localModules.length);
+	state.localModules.push(m);
+	return m;
+};
+
+/**
+ * @param {ParserState} state parser state
+ * @param {string} name name
+ * @param {string=} namedModule named module
+ * @returns {LocalModule | null} local module or null
+ */
+module.exports.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 (let i = 0; i < state.localModules.length; i++) {
+		if (state.localModules[i].name === name) {
+			return state.localModules[i];
+		}
+	}
+	return null;
+};

app_vue/node_modules/webpack/lib/dependencies/ModuleDecoratorDependency.js

@@ -0,0 +1,137 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const InitFragment = require("../InitFragment");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ModuleDecoratorDependency extends NullDependency {
+	/**
+	 * @param {string} decorator the decorator requirement
+	 * @param {boolean} allowExportsAccess allow to access exports from module
+	 */
+	constructor(decorator, allowExportsAccess) {
+		super();
+		this.decorator = decorator;
+		this.allowExportsAccess = allowExportsAccess;
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * @returns {string} a display name for the type of dependency
+	 */
+	get type() {
+		return "module decorator";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return "self";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return this.allowExportsAccess
+			? Dependency.EXPORTS_OBJECT_REFERENCED
+			: Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.decorator);
+		write(this.allowExportsAccess);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.decorator = read();
+		this.allowExportsAccess = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ModuleDecoratorDependency,
+	"webpack/lib/dependencies/ModuleDecoratorDependency"
+);
+
+ModuleDecoratorDependency.Template = class ModuleDecoratorDependencyTemplate 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,
+		{ module, chunkGraph, initFragments, runtimeRequirements }
+	) {
+		const dep = /** @type {ModuleDecoratorDependency} */ (dependency);
+		runtimeRequirements.add(RuntimeGlobals.moduleLoaded);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(dep.decorator);
+		initFragments.push(
+			new InitFragment(
+				`/* module decorator */ ${module.moduleArgument} = ${dep.decorator}(${module.moduleArgument});\n`,
+				InitFragment.STAGE_PROVIDES,
+				0,
+				`module decorator ${chunkGraph.getModuleId(module)}`
+			)
+		);
+	}
+};
+
+module.exports = ModuleDecoratorDependency;

app_vue/node_modules/webpack/lib/dependencies/ModuleDependency.js

@@ -0,0 +1,98 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const DependencyTemplate = require("../DependencyTemplate");
+const RawModule = require("../RawModule");
+
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class ModuleDependency extends Dependency {
+	/**
+	 * @param {string} request request path which needs resolving
+	 */
+	constructor(request) {
+		super();
+		this.request = request;
+		this.userRequest = request;
+		this.range = undefined;
+		// TODO move it to subclasses and rename
+		// assertions must be serialized by subclasses that use it
+		/** @type {ImportAttributes | undefined} */
+		this.assertions = undefined;
+		this._context = undefined;
+	}
+
+	/**
+	 * @returns {string | undefined} a request context
+	 */
+	getContext() {
+		return this._context;
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = `context${this._context || ""}|module${this.request}`;
+		if (this.assertions !== undefined) {
+			str += JSON.stringify(this.assertions);
+		}
+		return str;
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
+	}
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} ignored module
+	 */
+	createIgnoredModule(context) {
+		return new RawModule(
+			"/* (ignored) */",
+			`ignored|${context}|${this.request}`,
+			`${this.request} (ignored)`
+		);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.request);
+		write(this.userRequest);
+		write(this._context);
+		write(this.range);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.request = read();
+		this.userRequest = read();
+		this._context = read();
+		this.range = read();
+		super.deserialize(context);
+	}
+}
+
+ModuleDependency.Template = DependencyTemplate;
+
+module.exports = ModuleDependency;

app_vue/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsId.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+
+class ModuleDependencyTemplateAsId extends ModuleDependency.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, { runtimeTemplate, moduleGraph, chunkGraph }) {
+		const dep = /** @type {ModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const content = runtimeTemplate.moduleId({
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+
+module.exports = ModuleDependencyTemplateAsId;

app_vue/node_modules/webpack/lib/dependencies/ModuleDependencyTemplateAsRequireId.js

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class ModuleDependencyTemplateAsRequireId extends ModuleDependency.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,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const content = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+module.exports = ModuleDependencyTemplateAsRequireId;

app_vue/node_modules/webpack/lib/dependencies/ModuleHotAcceptDependency.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ModuleHotAcceptDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "module.hot.accept";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+makeSerializable(
+	ModuleHotAcceptDependency,
+	"webpack/lib/dependencies/ModuleHotAcceptDependency"
+);
+
+ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotAcceptDependency;

app_vue/node_modules/webpack/lib/dependencies/ModuleHotDeclineDependency.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class ModuleHotDeclineDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "module.hot.decline";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+makeSerializable(
+	ModuleHotDeclineDependency,
+	"webpack/lib/dependencies/ModuleHotDeclineDependency"
+);
+
+ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotDeclineDependency;

app_vue/node_modules/webpack/lib/dependencies/NullDependency.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const DependencyTemplate = require("../DependencyTemplate");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class NullDependency extends Dependency {
+	get type() {
+		return "null";
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return false;
+	}
+}
+
+NullDependency.Template = class NullDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @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, templateContext) {}
+};
+
+module.exports = NullDependency;

app_vue/node_modules/webpack/lib/dependencies/PrefetchDependency.js

@@ -0,0 +1,27 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("./ModuleDependency");
+
+class PrefetchDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 */
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "prefetch";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+module.exports = PrefetchDependency;

app_vue/node_modules/webpack/lib/dependencies/ProvidedDependency.js

@@ -0,0 +1,157 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const InitFragment = require("../InitFragment");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @param {string[]|null} path the property path array
+ * @returns {string} the converted path
+ */
+const pathToString = path =>
+	path !== null && path.length > 0
+		? path.map(part => `[${JSON.stringify(part)}]`).join("")
+		: "";
+
+class ProvidedDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {string} identifier identifier
+	 * @param {string[]} ids ids
+	 * @param {Range} range range
+	 */
+	constructor(request, identifier, ids, range) {
+		super(request);
+		this.identifier = identifier;
+		this.ids = ids;
+		this.range = range;
+		this._hashUpdate = undefined;
+	}
+
+	get type() {
+		return "provided";
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		const ids = this.ids;
+		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		return [ids];
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.identifier + (this.ids ? this.ids.join(",") : "");
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.identifier);
+		write(this.ids);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.identifier = read();
+		this.ids = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ProvidedDependency,
+	"webpack/lib/dependencies/ProvidedDependency"
+);
+
+class ProvidedDependencyTemplate extends ModuleDependency.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,
+		{
+			runtime,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			initFragments,
+			runtimeRequirements
+		}
+	) {
+		const dep = /** @type {ProvidedDependency} */ (dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(moduleGraph.getConnection(dep));
+		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
+		const usedName = exportsInfo.getUsedName(dep.ids, runtime);
+		initFragments.push(
+			new InitFragment(
+				`/* provided dependency */ var ${
+					dep.identifier
+				} = ${runtimeTemplate.moduleExports({
+					module: moduleGraph.getModule(dep),
+					chunkGraph,
+					request: dep.request,
+					runtimeRequirements
+				})}${pathToString(/** @type {string[]} */ (usedName))};\n`,
+				InitFragment.STAGE_PROVIDES,
+				1,
+				`provided ${dep.identifier}`
+			)
+		);
+		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
+	}
+}
+
+ProvidedDependency.Template = ProvidedDependencyTemplate;
+
+module.exports = ProvidedDependency;

app_vue/node_modules/webpack/lib/dependencies/PureExpressionDependency.js

@@ -0,0 +1,162 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { UsageState } = require("../ExportsInfo");
+const makeSerializable = require("../util/makeSerializable");
+const { filterRuntime, runtimeToString } = require("../util/runtime");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class PureExpressionDependency extends NullDependency {
+	/**
+	 * @param {Range} range the source range
+	 */
+	constructor(range) {
+		super();
+		this.range = range;
+		/** @type {Set<string> | false} */
+		this.usedByExports = false;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime current runtimes
+	 * @returns {boolean | RuntimeSpec} runtime condition
+	 */
+	_getRuntimeCondition(moduleGraph, runtime) {
+		const usedByExports = this.usedByExports;
+		if (usedByExports !== false) {
+			const selfModule =
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this));
+			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+			const runtimeCondition = filterRuntime(runtime, runtime => {
+				for (const exportName of usedByExports) {
+					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+						return true;
+					}
+				}
+				return false;
+			});
+			return runtimeCondition;
+		}
+		return false;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const runtimeCondition = this._getRuntimeCondition(
+			context.chunkGraph.moduleGraph,
+			context.runtime
+		);
+		if (runtimeCondition === true) {
+			return;
+		} else if (runtimeCondition === false) {
+			hash.update("null");
+		} else {
+			hash.update(
+				`${runtimeToString(runtimeCondition)}|${runtimeToString(
+					context.runtime
+				)}`
+			);
+		}
+		hash.update(String(this.range));
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.usedByExports);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.usedByExports = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	PureExpressionDependency,
+	"webpack/lib/dependencies/PureExpressionDependency"
+);
+
+PureExpressionDependency.Template = class PureExpressionDependencyTemplate 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,
+		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+	) {
+		const dep = /** @type {PureExpressionDependency} */ (dependency);
+		const runtimeCondition = dep._getRuntimeCondition(moduleGraph, runtime);
+		if (runtimeCondition === true) {
+			// Do nothing
+		} else if (runtimeCondition === false) {
+			source.insert(
+				dep.range[0],
+				"(/* unused pure expression or super */ null && ("
+			);
+			source.insert(dep.range[1], "))");
+		} else {
+			const condition = runtimeTemplate.runtimeConditionExpression({
+				chunkGraph,
+				runtime,
+				runtimeCondition,
+				runtimeRequirements
+			});
+			source.insert(
+				dep.range[0],
+				`(/* runtime-dependent pure expression or super */ ${condition} ? (`
+			);
+			source.insert(dep.range[1], ") : null)");
+		}
+	}
+};
+
+module.exports = PureExpressionDependency;

app_vue/node_modules/webpack/lib/dependencies/RequireContextDependency.js

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+class RequireContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options
+	 * @param {Range} range range
+	 */
+	constructor(options, range) {
+		super(options);
+
+		this.range = range;
+	}
+
+	get type() {
+		return "require.context";
+	}
+}
+
+makeSerializable(
+	RequireContextDependency,
+	"webpack/lib/dependencies/RequireContextDependency"
+);
+
+RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = RequireContextDependency;

app_vue/node_modules/webpack/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "RequireContextDependencyParserPlugin";
+
+module.exports = class RequireContextDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.call.for("require.context").tap(PLUGIN_NAME, expr => {
+			let regExp = /^\.\/.*$/;
+			let recursive = true;
+			/** @type {ContextMode} */
+			let mode = "sync";
+			switch (expr.arguments.length) {
+				case 4: {
+					const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!modeExpr.isString()) return;
+					mode = /** @type {ContextMode} */ (modeExpr.string);
+				}
+				// falls through
+				case 3: {
+					const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+					if (!regExpExpr.isRegExp()) return;
+					regExp = /** @type {RegExp} */ (regExpExpr.regExp);
+				}
+				// falls through
+				case 2: {
+					const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+					if (!recursiveExpr.isBoolean()) return;
+					recursive = /** @type {boolean} */ (recursiveExpr.bool);
+				}
+				// falls through
+				case 1: {
+					const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+					if (!requestExpr.isString()) return;
+					const dep = new RequireContextDependency(
+						{
+							request: /** @type {string} */ (requestExpr.string),
+							recursive,
+							regExp,
+							mode,
+							category: "commonjs"
+						},
+						/** @type {Range} */
+						(expr.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+					return true;
+				}
+			}
+		});
+	}
+};

app_vue/node_modules/webpack/lib/dependencies/RequireContextPlugin.js

@@ -0,0 +1,164 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
+const { cachedSetProperty } = require("../util/cleverMerge");
+const ContextElementDependency = require("./ContextElementDependency");
+const RequireContextDependency = require("./RequireContextDependency");
+const RequireContextDependencyParserPlugin = require("./RequireContextDependencyParserPlugin");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+/** @type {ResolveOptions} */
+const EMPTY_RESOLVE_OPTIONS = {};
+
+const PLUGIN_NAME = "RequireContextPlugin";
+
+class RequireContextPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireContextDependency,
+					new RequireContextDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ContextElementDependency,
+					normalModuleFactory
+				);
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireContext !== undefined &&
+						!parserOptions.requireContext
+					)
+						return;
+
+					new RequireContextDependencyParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+
+				contextModuleFactory.hooks.alternativeRequests.tap(
+					PLUGIN_NAME,
+					(items, options) => {
+						if (items.length === 0) return items;
+
+						const finalResolveOptions = compiler.resolverFactory.get(
+							"normal",
+							cachedSetProperty(
+								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
+								"dependencyType",
+								/** @type {string} */
+								(options.category)
+							)
+						).options;
+
+						let newItems;
+						if (!finalResolveOptions.fullySpecified) {
+							newItems = [];
+							for (const item of items) {
+								const { request, context } = item;
+								for (const ext of finalResolveOptions.extensions) {
+									if (request.endsWith(ext)) {
+										newItems.push({
+											context,
+											request: request.slice(0, -ext.length)
+										});
+									}
+								}
+								if (!finalResolveOptions.enforceExtension) {
+									newItems.push(item);
+								}
+							}
+							items = newItems;
+
+							newItems = [];
+							for (const obj of items) {
+								const { request, context } = obj;
+								for (const mainFile of finalResolveOptions.mainFiles) {
+									if (request.endsWith(`/${mainFile}`)) {
+										newItems.push({
+											context,
+											request: request.slice(0, -mainFile.length)
+										});
+										newItems.push({
+											context,
+											request: request.slice(0, -mainFile.length - 1)
+										});
+									}
+								}
+								newItems.push(obj);
+							}
+							items = newItems;
+						}
+
+						newItems = [];
+						for (const item of items) {
+							let hideOriginal = false;
+							for (const modulesItems of finalResolveOptions.modules) {
+								if (Array.isArray(modulesItems)) {
+									for (const dir of modulesItems) {
+										if (item.request.startsWith(`./${dir}/`)) {
+											newItems.push({
+												context: item.context,
+												request: item.request.slice(dir.length + 3)
+											});
+											hideOriginal = true;
+										}
+									}
+								} else {
+									const dir = modulesItems.replace(/\\/g, "/");
+									const fullPath =
+										item.context.replace(/\\/g, "/") + item.request.slice(1);
+									if (fullPath.startsWith(dir)) {
+										newItems.push({
+											context: item.context,
+											request: fullPath.slice(dir.length + 1)
+										});
+									}
+								}
+							}
+							if (!hideOriginal) {
+								newItems.push(item);
+							}
+						}
+						return newItems;
+					}
+				);
+			}
+		);
+	}
+}
+module.exports = RequireContextPlugin;

app_vue/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
+/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+
+class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
+	/**
+	 * @param {GroupOptions | null} chunkName chunk name
+	 * @param {(DependencyLocation | null)=} loc location info
+	 */
+	constructor(chunkName, loc) {
+		super(chunkName, loc, null);
+	}
+}
+
+makeSerializable(
+	RequireEnsureDependenciesBlock,
+	"webpack/lib/dependencies/RequireEnsureDependenciesBlock"
+);
+
+module.exports = RequireEnsureDependenciesBlock;

app_vue/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -0,0 +1,141 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RequireEnsureDependenciesBlock = require("./RequireEnsureDependenciesBlock");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
+/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "RequireEnsureDependenciesBlockParserPlugin";
+
+module.exports = class RequireEnsureDependenciesBlockParserPlugin {
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.call.for("require.ensure").tap(PLUGIN_NAME, expr => {
+			/** @type {string | GroupOptions | null} */
+			let chunkName = null;
+			let errorExpressionArg = null;
+			let errorExpression = null;
+			switch (expr.arguments.length) {
+				case 4: {
+					const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!chunkNameExpr.isString()) return;
+					chunkName =
+						/** @type {string} */
+						(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;
+						chunkName =
+							/** @type {string} */
+							(chunkNameExpr.string);
+					}
+				}
+				// falls through
+				case 2: {
+					const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]);
+					const dependenciesItems = /** @type {BasicEvaluatedExpression[]} */ (
+						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 depBlock = new RequireEnsureDependenciesBlock(
+						chunkName,
+						/** @type {DependencyLocation} */
+						(expr.loc)
+					);
+					const errorCallbackExists =
+						expr.arguments.length === 4 ||
+						(!chunkName && expr.arguments.length === 3);
+					const dep = new RequireEnsureDependency(
+						/** @type {Range} */ (expr.range),
+						/** @type {Range} */ (expr.arguments[1].range),
+						errorCallbackExists &&
+							/** @type {Range} */ (expr.arguments[2].range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					depBlock.addDependency(dep);
+					const old = parser.state.current;
+					parser.state.current = /** @type {TODO} */ (depBlock);
+					try {
+						let failed = false;
+						parser.inScope([], () => {
+							for (const ee of dependenciesItems) {
+								if (ee.isString()) {
+									const ensureDependency = new RequireEnsureItemDependency(
+										/** @type {string} */ (ee.string)
+									);
+									ensureDependency.loc =
+										/** @type {DependencyLocation} */
+										(expr.loc);
+									depBlock.addDependency(ensureDependency);
+								} else {
+									failed = true;
+								}
+							}
+						});
+						if (failed) {
+							return;
+						}
+						if (successExpression) {
+							if (successExpression.fn.body.type === "BlockStatement") {
+								// Opt-out of Dead Control Flow detection for this block
+								const oldTerminated = parser.scope.terminated;
+								parser.walkStatement(successExpression.fn.body);
+								parser.scope.terminated = oldTerminated;
+							} else {
+								parser.walkExpression(successExpression.fn.body);
+							}
+						}
+						old.addBlock(depBlock);
+					} 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;
+				}
+			}
+		});
+	}
+};

app_vue/node_modules/webpack/lib/dependencies/RequireEnsureDependency.js

@@ -0,0 +1,115 @@
+/*
+	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("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @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 */
+
+class RequireEnsureDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range} contentRange content range
+	 * @param {Range | false} errorHandlerRange error handler range
+	 */
+	constructor(range, contentRange, errorHandlerRange) {
+		super();
+
+		this.range = range;
+		this.contentRange = contentRange;
+		this.errorHandlerRange = errorHandlerRange;
+	}
+
+	get type() {
+		return "require.ensure";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+		write(this.contentRange);
+		write(this.errorHandlerRange);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+		this.contentRange = read();
+		this.errorHandlerRange = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	RequireEnsureDependency,
+	"webpack/lib/dependencies/RequireEnsureDependency"
+);
+
+RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate 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,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {RequireEnsureDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block: depBlock,
+			message: "require.ensure",
+			runtimeRequirements
+		});
+		const range = dep.range;
+		const contentRange = dep.contentRange;
+		const errorHandlerRange = dep.errorHandlerRange;
+		source.replace(range[0], contentRange[0] - 1, `${promise}.then((`);
+		if (errorHandlerRange) {
+			source.replace(
+				contentRange[1],
+				errorHandlerRange[0] - 1,
+				`).bind(null, ${RuntimeGlobals.require}))['catch'](`
+			);
+			source.replace(errorHandlerRange[1], range[1] - 1, ")");
+		} else {
+			source.replace(
+				contentRange[1],
+				range[1] - 1,
+				`).bind(null, ${RuntimeGlobals.require}))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`
+			);
+		}
+	}
+};
+
+module.exports = RequireEnsureDependency;

app_vue/node_modules/webpack/lib/dependencies/RequireEnsureItemDependency.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const NullDependency = require("./NullDependency");
+
+class RequireEnsureItemDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 */
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "require.ensure item";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+makeSerializable(
+	RequireEnsureItemDependency,
+	"webpack/lib/dependencies/RequireEnsureItemDependency"
+);
+
+RequireEnsureItemDependency.Template = NullDependency.Template;
+
+module.exports = RequireEnsureItemDependency;

app_vue/node_modules/webpack/lib/dependencies/RequireEnsurePlugin.js

@@ -0,0 +1,86 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+
+const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
+const {
+	evaluateToString,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "RequireEnsurePlugin";
+
+class RequireEnsurePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireEnsureItemDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireEnsureItemDependency,
+					new RequireEnsureItemDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					RequireEnsureDependency,
+					new RequireEnsureDependency.Template()
+				);
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireEnsure !== undefined &&
+						!parserOptions.requireEnsure
+					)
+						return;
+
+					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);
+					parser.hooks.evaluateTypeof
+						.for("require.ensure")
+						.tap(PLUGIN_NAME, evaluateToString("function"));
+					parser.hooks.typeof
+						.for("require.ensure")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+module.exports = RequireEnsurePlugin;

app_vue/node_modules/webpack/lib/dependencies/RequireHeaderDependency.js

@@ -0,0 +1,70 @@
+/*
+	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 */
+
+class RequireHeaderDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 */
+	constructor(range) {
+		super();
+		if (!Array.isArray(range)) throw new Error("range must be valid");
+		this.range = range;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {RequireHeaderDependency} RequireHeaderDependency
+	 */
+	static deserialize(context) {
+		const obj = new RequireHeaderDependency(context.read());
+		obj.deserialize(context);
+		return obj;
+	}
+}
+
+makeSerializable(
+	RequireHeaderDependency,
+	"webpack/lib/dependencies/RequireHeaderDependency"
+);
+
+RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate 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 {RequireHeaderDependency} */ (dependency);
+		runtimeRequirements.add(RuntimeGlobals.require);
+		source.replace(dep.range[0], dep.range[1] - 1, RuntimeGlobals.require);
+	}
+};
+
+module.exports = RequireHeaderDependency;

app_vue/node_modules/webpack/lib/dependencies/RequireIncludeDependency.js

@@ -0,0 +1,79 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class RequireIncludeDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "require.include";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+makeSerializable(
+	RequireIncludeDependency,
+	"webpack/lib/dependencies/RequireIncludeDependency"
+);
+
+RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate extends (
+	ModuleDependency.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, { runtimeTemplate }) {
+		const dep = /** @type {RequireIncludeDependency} */ (dependency);
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`require.include ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
+				)
+			: "";
+
+		source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`);
+	}
+};
+
+module.exports = RequireIncludeDependency;