first commit

app_vue/node_modules/webpack/lib/config/browserslistTargetHandler.js

@@ -0,0 +1,363 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+"use strict";
+
+const browserslist = require("browserslist");
+const path = require("path");
+
+/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
+/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
+/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
+
+// [[C:]/path/to/config][:env]
+const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
+
+/**
+ * @typedef {object} BrowserslistHandlerConfig
+ * @property {string=} configPath
+ * @property {string=} env
+ * @property {string=} query
+ */
+
+/**
+ * @param {string | null | undefined} input input string
+ * @param {string} context the context directory
+ * @returns {BrowserslistHandlerConfig} config
+ */
+const parse = (input, context) => {
+	if (!input) {
+		return {};
+	}
+
+	if (path.isAbsolute(input)) {
+		const [, configPath, env] = inputRx.exec(input) || [];
+		return { configPath, env };
+	}
+
+	const config = browserslist.findConfig(context);
+
+	if (config && Object.keys(config).includes(input)) {
+		return { env: input };
+	}
+
+	return { query: input };
+};
+
+/**
+ * @param {string | null | undefined} input input string
+ * @param {string} context the context directory
+ * @returns {string[] | undefined} selected browsers
+ */
+const load = (input, context) => {
+	const { configPath, env, query } = parse(input, context);
+
+	// if a query is specified, then use it, else
+	// if a path to a config is specified then load it, else
+	// find a nearest config
+	const config =
+		query ||
+		(configPath
+			? browserslist.loadConfig({
+					config: configPath,
+					env
+				})
+			: browserslist.loadConfig({ path: context, env }));
+
+	if (!config) return;
+	return browserslist(config);
+};
+
+/**
+ * @param {string[]} browsers supported browsers list
+ * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
+ */
+const resolve = browsers => {
+	/**
+	 * Checks all against a version number
+	 * @param {Record<string, number | [number, number]>} versions first supported version
+	 * @returns {boolean} true if supports
+	 */
+	const rawChecker = versions =>
+		browsers.every(v => {
+			const [name, parsedVersion] = v.split(" ");
+			if (!name) return false;
+			const requiredVersion = versions[name];
+			if (!requiredVersion) return false;
+			const [parsedMajor, parserMinor] =
+				// safari TP supports all features for normal safari
+				parsedVersion === "TP"
+					? [Infinity, Infinity]
+					: parsedVersion.includes("-")
+						? parsedVersion.split("-")[0].split(".")
+						: parsedVersion.split(".");
+			if (typeof requiredVersion === "number") {
+				return Number(parsedMajor) >= requiredVersion;
+			}
+			return requiredVersion[0] === Number(parsedMajor)
+				? Number(parserMinor) >= requiredVersion[1]
+				: Number(parsedMajor) > requiredVersion[0];
+		});
+	const anyNode = browsers.some(b => b.startsWith("node "));
+	const anyBrowser = browsers.some(b => /^(?!node)/.test(b));
+	const browserProperty = !anyBrowser ? false : anyNode ? null : true;
+	const nodeProperty = !anyNode ? false : anyBrowser ? null : true;
+	// Internet Explorer Mobile, Blackberry browser and Opera Mini are very old browsers, they do not support new features
+	const es6DynamicImport = rawChecker({
+		/* eslint-disable camelcase */
+		chrome: 63,
+		and_chr: 63,
+		edge: 79,
+		firefox: 67,
+		and_ff: 67,
+		// ie: Not supported
+		opera: 50,
+		op_mob: 46,
+		safari: [11, 1],
+		ios_saf: [11, 3],
+		samsung: [8, 2],
+		android: 63,
+		and_qq: [10, 4],
+		baidu: [13, 18],
+		and_uc: [15, 5],
+		kaios: [3, 0],
+		node: [12, 17]
+		/* eslint-enable camelcase */
+	});
+
+	return {
+		/* eslint-disable camelcase */
+		const: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 12,
+			// Prior to Firefox 13, <code>const</code> is implemented, but re-assignment is not failing.
+			// Prior to Firefox 46, a <code>TypeError</code> was thrown on redeclaration instead of a <code>SyntaxError</code>.
+			firefox: 36,
+			and_ff: 36,
+			// Not supported in for-in and for-of loops
+			// ie: Not supported
+			opera: 36,
+			op_mob: 36,
+			safari: [10, 0],
+			ios_saf: [10, 0],
+			// Before 5.0 supported correctly in strict mode, otherwise supported without block scope
+			samsung: [5, 0],
+			android: 37,
+			and_qq: [10, 4],
+			// Supported correctly in strict mode, otherwise supported without block scope
+			baidu: [13, 18],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		arrowFunction: rawChecker({
+			chrome: 45,
+			and_chr: 45,
+			edge: 12,
+			// The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of <code>'use strict';</code> is now required.
+			// Prior to Firefox 39, a line terminator (<code>\\n</code>) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like <code>() \\n => {}</code> will now throw a <code>SyntaxError</code> in this and later versions.
+			firefox: 39,
+			and_ff: 39,
+			// ie: Not supported,
+			opera: 32,
+			op_mob: 32,
+			safari: 10,
+			ios_saf: 10,
+			samsung: [5, 0],
+			android: 45,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		forOf: rawChecker({
+			chrome: 38,
+			and_chr: 38,
+			edge: 12,
+			// Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration").
+			firefox: 51,
+			and_ff: 51,
+			// ie: Not supported,
+			opera: 25,
+			op_mob: 25,
+			safari: 7,
+			ios_saf: 7,
+			samsung: [3, 0],
+			android: 38,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			kaios: [3, 0],
+			node: [0, 12]
+		}),
+		destructuring: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 14,
+			firefox: 41,
+			and_ff: 41,
+			// ie: Not supported,
+			opera: 36,
+			op_mob: 36,
+			safari: 8,
+			ios_saf: 8,
+			samsung: [5, 0],
+			android: 49,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		bigIntLiteral: rawChecker({
+			chrome: 67,
+			and_chr: 67,
+			edge: 79,
+			firefox: 68,
+			and_ff: 68,
+			// ie: Not supported,
+			opera: 54,
+			op_mob: 48,
+			safari: 14,
+			ios_saf: 14,
+			samsung: [9, 2],
+			android: 67,
+			and_qq: [13, 1],
+			baidu: [13, 18],
+			and_uc: [15, 5],
+			kaios: [3, 0],
+			node: [10, 4]
+		}),
+		// Support syntax `import` and `export` and no limitations and bugs on Node.js
+		// Not include `export * as namespace`
+		module: rawChecker({
+			chrome: 61,
+			and_chr: 61,
+			edge: 16,
+			firefox: 60,
+			and_ff: 60,
+			// ie: Not supported,
+			opera: 48,
+			op_mob: 45,
+			safari: [10, 1],
+			ios_saf: [10, 3],
+			samsung: [8, 0],
+			android: 61,
+			and_qq: [10, 4],
+			baidu: [13, 18],
+			and_uc: [15, 5],
+			kaios: [3, 0],
+			node: [12, 17]
+		}),
+		dynamicImport: es6DynamicImport,
+		dynamicImportInWorker: es6DynamicImport && !anyNode,
+		// browserslist does not have info about globalThis
+		// so this is based on mdn-browser-compat-data
+		globalThis: rawChecker({
+			chrome: 71,
+			and_chr: 71,
+			edge: 79,
+			firefox: 65,
+			and_ff: 65,
+			// ie: Not supported,
+			opera: 58,
+			op_mob: 50,
+			safari: [12, 1],
+			ios_saf: [12, 2],
+			samsung: [10, 1],
+			android: 71,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			kaios: [3, 0],
+			node: 12
+		}),
+		optionalChaining: rawChecker({
+			chrome: 80,
+			and_chr: 80,
+			edge: 80,
+			firefox: 74,
+			and_ff: 79,
+			// ie: Not supported,
+			opera: 67,
+			op_mob: 64,
+			safari: [13, 1],
+			ios_saf: [13, 4],
+			samsung: 13,
+			android: 80,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			kaios: [3, 0],
+			node: 14
+		}),
+		templateLiteral: rawChecker({
+			chrome: 41,
+			and_chr: 41,
+			edge: 13,
+			firefox: 34,
+			and_ff: 34,
+			// ie: Not supported,
+			opera: 29,
+			op_mob: 64,
+			safari: [9, 1],
+			ios_saf: 9,
+			samsung: 4,
+			android: 41,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: 4
+		}),
+		asyncFunction: rawChecker({
+			chrome: 55,
+			and_chr: 55,
+			edge: 15,
+			firefox: 52,
+			and_ff: 52,
+			// ie: Not supported,
+			opera: 42,
+			op_mob: 42,
+			safari: 11,
+			ios_saf: 11,
+			samsung: [6, 2],
+			android: 55,
+			and_qq: [13, 1],
+			baidu: [13, 18],
+			and_uc: [15, 5],
+			kaios: 3,
+			node: [7, 6]
+		}),
+		/* eslint-enable camelcase */
+		browser: browserProperty,
+		electron: false,
+		node: nodeProperty,
+		nwjs: false,
+		web: browserProperty,
+		webworker: false,
+
+		document: browserProperty,
+		fetchWasm: browserProperty,
+		global: nodeProperty,
+		importScripts: false,
+		importScriptsInWorker: true,
+		nodeBuiltins: nodeProperty,
+		nodePrefixForCoreModules:
+			nodeProperty &&
+			!browsers.some(b => b.startsWith("node 15")) &&
+			rawChecker({
+				node: [14, 18]
+			}),
+		require: nodeProperty
+	};
+};
+
+module.exports = {
+	resolve,
+	load
+};

app_vue/node_modules/webpack/lib/config/normalization.js

@@ -0,0 +1,565 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+
+/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
+/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptionsNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").Plugins} Plugins */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
+
+const handledDeprecatedNoEmitOnErrors = util.deprecate(
+	/**
+	 * @param {boolean} noEmitOnErrors no emit on errors
+	 * @param {boolean | undefined} emitOnErrors emit on errors
+	 * @returns {boolean} emit on errors
+	 */
+	(noEmitOnErrors, emitOnErrors) => {
+		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
+			throw new Error(
+				"Conflicting use of 'optimization.noEmitOnErrors' and 'optimization.emitOnErrors'. Remove deprecated 'optimization.noEmitOnErrors' from config."
+			);
+		}
+		return !noEmitOnErrors;
+	},
+	"optimization.noEmitOnErrors is deprecated in favor of optimization.emitOnErrors",
+	"DEP_WEBPACK_CONFIGURATION_OPTIMIZATION_NO_EMIT_ON_ERRORS"
+);
+
+/**
+ * @template T
+ * @template R
+ * @param {T | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @returns {R} result value
+ */
+const nestedConfig = (value, fn) =>
+	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
+
+/**
+ * @template T
+ * @param {T|undefined} value value or not
+ * @returns {T} result value
+ */
+const cloneObject = value => /** @type {T} */ ({ ...value });
+/**
+ * @template T
+ * @template R
+ * @param {T | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @returns {R | undefined} result value
+ */
+const optionalNestedConfig = (value, fn) =>
+	value === undefined ? undefined : fn(value);
+
+/**
+ * @template T
+ * @template R
+ * @param {T[] | undefined} value array or not
+ * @param {(value: T[]) => R[]} fn nested handler
+ * @returns {R[] | undefined} cloned value
+ */
+const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
+
+/**
+ * @template T
+ * @template R
+ * @param {T[] | undefined} value array or not
+ * @param {(value: T[]) => R[]} fn nested handler
+ * @returns {R[] | undefined} cloned value
+ */
+const optionalNestedArray = (value, fn) =>
+	Array.isArray(value) ? fn(value) : undefined;
+
+/**
+ * @template T
+ * @template R
+ * @param {Record<string, T>|undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @param {Record<string, (value: T) => R>=} customKeys custom nested handler for some keys
+ * @returns {Record<string, R>} result value
+ */
+const keyedNestedConfig = (value, fn, customKeys) => {
+	/* eslint-disable no-sequences */
+	const result =
+		value === undefined
+			? {}
+			: Object.keys(value).reduce(
+					(obj, key) => (
+						(obj[key] = (
+							customKeys && key in customKeys ? customKeys[key] : fn
+						)(value[key])),
+						obj
+					),
+					/** @type {Record<string, R>} */ ({})
+				);
+	/* eslint-enable no-sequences */
+	if (customKeys) {
+		for (const key of Object.keys(customKeys)) {
+			if (!(key in result)) {
+				result[key] = customKeys[key](/** @type {T} */ ({}));
+			}
+		}
+	}
+	return result;
+};
+
+/**
+ * @param {WebpackOptions} config input config
+ * @returns {WebpackOptionsNormalized} normalized options
+ */
+const getNormalizedWebpackOptions = config => ({
+	amd: config.amd,
+	bail: config.bail,
+	cache:
+		/** @type {NonNullable<CacheOptions>} */
+		(
+			optionalNestedConfig(config.cache, cache => {
+				if (cache === false) return false;
+				if (cache === true) {
+					return {
+						type: "memory",
+						maxGenerations: undefined
+					};
+				}
+				switch (cache.type) {
+					case "filesystem":
+						return {
+							type: "filesystem",
+							allowCollectingMemory: cache.allowCollectingMemory,
+							maxMemoryGenerations: cache.maxMemoryGenerations,
+							maxAge: cache.maxAge,
+							profile: cache.profile,
+							buildDependencies: cloneObject(cache.buildDependencies),
+							cacheDirectory: cache.cacheDirectory,
+							cacheLocation: cache.cacheLocation,
+							hashAlgorithm: cache.hashAlgorithm,
+							compression: cache.compression,
+							idleTimeout: cache.idleTimeout,
+							idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
+							idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
+							name: cache.name,
+							store: cache.store,
+							version: cache.version,
+							readonly: cache.readonly
+						};
+					case undefined:
+					case "memory":
+						return {
+							type: "memory",
+							maxGenerations: cache.maxGenerations
+						};
+					default:
+						// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+						throw new Error(`Not implemented cache.type ${cache.type}`);
+				}
+			})
+		),
+	context: config.context,
+	dependencies: config.dependencies,
+	devServer: optionalNestedConfig(config.devServer, devServer => {
+		if (devServer === false) return false;
+		return { ...devServer };
+	}),
+	devtool: config.devtool,
+	entry:
+		config.entry === undefined
+			? { main: {} }
+			: typeof config.entry === "function"
+				? (
+						fn => () =>
+							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
+					)(config.entry)
+				: getNormalizedEntryStatic(config.entry),
+	experiments: nestedConfig(config.experiments, experiments => ({
+		...experiments,
+		buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
+			Array.isArray(options) ? { allowedUris: options } : options
+		),
+		lazyCompilation: optionalNestedConfig(
+			experiments.lazyCompilation,
+			options => (options === true ? {} : options)
+		)
+	})),
+	externals: /** @type {NonNullable<Externals>} */ (config.externals),
+	externalsPresets: cloneObject(config.externalsPresets),
+	externalsType: config.externalsType,
+	ignoreWarnings: config.ignoreWarnings
+		? config.ignoreWarnings.map(ignore => {
+				if (typeof ignore === "function") return ignore;
+				const i = ignore instanceof RegExp ? { message: ignore } : ignore;
+				return (warning, { requestShortener }) => {
+					if (!i.message && !i.module && !i.file) return false;
+					if (i.message && !i.message.test(warning.message)) {
+						return false;
+					}
+					if (
+						i.module &&
+						(!(/** @type {WebpackError} */ (warning).module) ||
+							!i.module.test(
+								/** @type {WebpackError} */
+								(warning).module.readableIdentifier(requestShortener)
+							))
+					) {
+						return false;
+					}
+					if (
+						i.file &&
+						(!(/** @type {WebpackError} */ (warning).file) ||
+							!i.file.test(/** @type {WebpackError} */ (warning).file))
+					) {
+						return false;
+					}
+					return true;
+				};
+			})
+		: undefined,
+	infrastructureLogging: cloneObject(config.infrastructureLogging),
+	loader: cloneObject(config.loader),
+	mode: config.mode,
+	module:
+		/** @type {ModuleOptionsNormalized} */
+		(
+			nestedConfig(config.module, module => ({
+				noParse: module.noParse,
+				unsafeCache: module.unsafeCache,
+				parser: keyedNestedConfig(module.parser, cloneObject, {
+					javascript: parserOptions => ({
+						unknownContextRequest: module.unknownContextRequest,
+						unknownContextRegExp: module.unknownContextRegExp,
+						unknownContextRecursive: module.unknownContextRecursive,
+						unknownContextCritical: module.unknownContextCritical,
+						exprContextRequest: module.exprContextRequest,
+						exprContextRegExp: module.exprContextRegExp,
+						exprContextRecursive: module.exprContextRecursive,
+						exprContextCritical: module.exprContextCritical,
+						wrappedContextRegExp: module.wrappedContextRegExp,
+						wrappedContextRecursive: module.wrappedContextRecursive,
+						wrappedContextCritical: module.wrappedContextCritical,
+						// TODO webpack 6 remove
+						strictExportPresence: module.strictExportPresence,
+						strictThisContextOnImports: module.strictThisContextOnImports,
+						...parserOptions
+					})
+				}),
+				generator: cloneObject(module.generator),
+				defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
+				rules: nestedArray(module.rules, r => [...r])
+			}))
+		),
+	name: config.name,
+	node: nestedConfig(
+		config.node,
+		node =>
+			node && {
+				...node
+			}
+	),
+	optimization: nestedConfig(config.optimization, optimization => ({
+		...optimization,
+		runtimeChunk: getNormalizedOptimizationRuntimeChunk(
+			optimization.runtimeChunk
+		),
+		splitChunks: nestedConfig(
+			optimization.splitChunks,
+			splitChunks =>
+				splitChunks && {
+					...splitChunks,
+					defaultSizeTypes: splitChunks.defaultSizeTypes
+						? [...splitChunks.defaultSizeTypes]
+						: ["..."],
+					cacheGroups: cloneObject(splitChunks.cacheGroups)
+				}
+		),
+		emitOnErrors:
+			optimization.noEmitOnErrors !== undefined
+				? handledDeprecatedNoEmitOnErrors(
+						optimization.noEmitOnErrors,
+						optimization.emitOnErrors
+					)
+				: optimization.emitOnErrors
+	})),
+	output: nestedConfig(config.output, output => {
+		const { library } = output;
+		const libraryAsName = /** @type {LibraryName} */ (library);
+		const libraryBase =
+			typeof library === "object" &&
+			library &&
+			!Array.isArray(library) &&
+			"type" in library
+				? library
+				: libraryAsName || output.libraryTarget
+					? /** @type {LibraryOptions} */ ({
+							name: libraryAsName
+						})
+					: undefined;
+		/** @type {OutputNormalized} */
+		const result = {
+			assetModuleFilename: output.assetModuleFilename,
+			asyncChunks: output.asyncChunks,
+			charset: output.charset,
+			chunkFilename: output.chunkFilename,
+			chunkFormat: output.chunkFormat,
+			chunkLoading: output.chunkLoading,
+			chunkLoadingGlobal: output.chunkLoadingGlobal,
+			chunkLoadTimeout: output.chunkLoadTimeout,
+			cssFilename: output.cssFilename,
+			cssChunkFilename: output.cssChunkFilename,
+			clean: output.clean,
+			compareBeforeEmit: output.compareBeforeEmit,
+			crossOriginLoading: output.crossOriginLoading,
+			devtoolFallbackModuleFilenameTemplate:
+				output.devtoolFallbackModuleFilenameTemplate,
+			devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
+			devtoolNamespace: output.devtoolNamespace,
+			environment: cloneObject(output.environment),
+			enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
+				? [...output.enabledChunkLoadingTypes]
+				: ["..."],
+			enabledLibraryTypes: output.enabledLibraryTypes
+				? [...output.enabledLibraryTypes]
+				: ["..."],
+			enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
+				? [...output.enabledWasmLoadingTypes]
+				: ["..."],
+			filename: output.filename,
+			globalObject: output.globalObject,
+			hashDigest: output.hashDigest,
+			hashDigestLength: output.hashDigestLength,
+			hashFunction: output.hashFunction,
+			hashSalt: output.hashSalt,
+			hotUpdateChunkFilename: output.hotUpdateChunkFilename,
+			hotUpdateGlobal: output.hotUpdateGlobal,
+			hotUpdateMainFilename: output.hotUpdateMainFilename,
+			ignoreBrowserWarnings: output.ignoreBrowserWarnings,
+			iife: output.iife,
+			importFunctionName: output.importFunctionName,
+			importMetaName: output.importMetaName,
+			scriptType: output.scriptType,
+			// TODO webpack6 remove `libraryTarget`/`auxiliaryComment`/`amdContainer`/etc in favor of the `library` option
+			library: libraryBase && {
+				type:
+					output.libraryTarget !== undefined
+						? output.libraryTarget
+						: libraryBase.type,
+				auxiliaryComment:
+					output.auxiliaryComment !== undefined
+						? output.auxiliaryComment
+						: libraryBase.auxiliaryComment,
+				amdContainer:
+					output.amdContainer !== undefined
+						? output.amdContainer
+						: libraryBase.amdContainer,
+				export:
+					output.libraryExport !== undefined
+						? output.libraryExport
+						: libraryBase.export,
+				name: libraryBase.name,
+				umdNamedDefine:
+					output.umdNamedDefine !== undefined
+						? output.umdNamedDefine
+						: libraryBase.umdNamedDefine
+			},
+			module: output.module,
+			path: output.path,
+			pathinfo: output.pathinfo,
+			publicPath: output.publicPath,
+			sourceMapFilename: output.sourceMapFilename,
+			sourcePrefix: output.sourcePrefix,
+			strictModuleErrorHandling: output.strictModuleErrorHandling,
+			strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+			trustedTypes: optionalNestedConfig(output.trustedTypes, trustedTypes => {
+				if (trustedTypes === true) return {};
+				if (typeof trustedTypes === "string")
+					return { policyName: trustedTypes };
+				return { ...trustedTypes };
+			}),
+			uniqueName: output.uniqueName,
+			wasmLoading: output.wasmLoading,
+			webassemblyModuleFilename: output.webassemblyModuleFilename,
+			workerPublicPath: output.workerPublicPath,
+			workerChunkLoading: output.workerChunkLoading,
+			workerWasmLoading: output.workerWasmLoading
+		};
+		return result;
+	}),
+	parallelism: config.parallelism,
+	performance: optionalNestedConfig(config.performance, performance => {
+		if (performance === false) return false;
+		return {
+			...performance
+		};
+	}),
+	plugins: /** @type {Plugins} */ (nestedArray(config.plugins, p => [...p])),
+	profile: config.profile,
+	recordsInputPath:
+		config.recordsInputPath !== undefined
+			? config.recordsInputPath
+			: config.recordsPath,
+	recordsOutputPath:
+		config.recordsOutputPath !== undefined
+			? config.recordsOutputPath
+			: config.recordsPath,
+	resolve: nestedConfig(config.resolve, resolve => ({
+		...resolve,
+		byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
+	})),
+	resolveLoader: cloneObject(config.resolveLoader),
+	snapshot: nestedConfig(config.snapshot, snapshot => ({
+		resolveBuildDependencies: optionalNestedConfig(
+			snapshot.resolveBuildDependencies,
+			resolveBuildDependencies => ({
+				timestamp: resolveBuildDependencies.timestamp,
+				hash: resolveBuildDependencies.hash
+			})
+		),
+		buildDependencies: optionalNestedConfig(
+			snapshot.buildDependencies,
+			buildDependencies => ({
+				timestamp: buildDependencies.timestamp,
+				hash: buildDependencies.hash
+			})
+		),
+		resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
+			timestamp: resolve.timestamp,
+			hash: resolve.hash
+		})),
+		module: optionalNestedConfig(snapshot.module, module => ({
+			timestamp: module.timestamp,
+			hash: module.hash
+		})),
+		immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
+		managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p]),
+		unmanagedPaths: optionalNestedArray(snapshot.unmanagedPaths, p => [...p])
+	})),
+	stats: nestedConfig(config.stats, stats => {
+		if (stats === false) {
+			return {
+				preset: "none"
+			};
+		}
+		if (stats === true) {
+			return {
+				preset: "normal"
+			};
+		}
+		if (typeof stats === "string") {
+			return {
+				preset: stats
+			};
+		}
+		return {
+			...stats
+		};
+	}),
+	target: config.target,
+	watch: config.watch,
+	watchOptions: cloneObject(config.watchOptions)
+});
+
+/**
+ * @param {EntryStatic} entry static entry options
+ * @returns {EntryStaticNormalized} normalized static entry options
+ */
+const getNormalizedEntryStatic = entry => {
+	if (typeof entry === "string") {
+		return {
+			main: {
+				import: [entry]
+			}
+		};
+	}
+	if (Array.isArray(entry)) {
+		return {
+			main: {
+				import: entry
+			}
+		};
+	}
+	/** @type {EntryStaticNormalized} */
+	const result = {};
+	for (const key of Object.keys(entry)) {
+		const value = entry[key];
+		if (typeof value === "string") {
+			result[key] = {
+				import: [value]
+			};
+		} else if (Array.isArray(value)) {
+			result[key] = {
+				import: value
+			};
+		} else {
+			result[key] = {
+				import:
+					/** @type {EntryDescriptionNormalized["import"]} */
+					(
+						value.import &&
+							(Array.isArray(value.import) ? value.import : [value.import])
+					),
+				filename: value.filename,
+				layer: value.layer,
+				runtime: value.runtime,
+				baseUri: value.baseUri,
+				publicPath: value.publicPath,
+				chunkLoading: value.chunkLoading,
+				asyncChunks: value.asyncChunks,
+				wasmLoading: value.wasmLoading,
+				dependOn:
+					/** @type {EntryDescriptionNormalized["dependOn"]} */
+					(
+						value.dependOn &&
+							(Array.isArray(value.dependOn)
+								? value.dependOn
+								: [value.dependOn])
+					),
+				library: value.library
+			};
+		}
+	}
+	return result;
+};
+
+/**
+ * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
+ * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
+ */
+const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
+	if (runtimeChunk === undefined) return;
+	if (runtimeChunk === false) return false;
+	if (runtimeChunk === "single") {
+		return {
+			name: () => "runtime"
+		};
+	}
+	if (runtimeChunk === true || runtimeChunk === "multiple") {
+		return {
+			name: entrypoint => `runtime~${entrypoint.name}`
+		};
+	}
+	const { name } = runtimeChunk;
+	return {
+		name:
+			typeof name === "function"
+				? /** @type {Exclude<OptimizationRuntimeChunkNormalized, false>["name"]} */
+					(name)
+				: () => /** @type {string} */ (name)
+	};
+};
+
+module.exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;

app_vue/node_modules/webpack/lib/config/target.js

@@ -0,0 +1,377 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const memoize = require("../util/memoize");
+
+const getBrowserslistTargetHandler = memoize(() =>
+	require("./browserslistTargetHandler")
+);
+
+/**
+ * @param {string} context the context directory
+ * @returns {string} default target
+ */
+const getDefaultTarget = context => {
+	const browsers = getBrowserslistTargetHandler().load(null, context);
+	return browsers ? "browserslist" : "web";
+};
+
+/**
+ * @typedef {object} PlatformTargetProperties
+ * @property {boolean | null=} web web platform, importing of http(s) and std: is available
+ * @property {boolean | null=} browser browser platform, running in a normal web browser
+ * @property {boolean | null=} webworker (Web)Worker platform, running in a web/shared/service worker
+ * @property {boolean | null=} node node platform, require of node built-in modules is available
+ * @property {boolean | null=} nwjs nwjs platform, require of legacy nw.gui is available
+ * @property {boolean | null=} electron electron platform, require of some electron built-in modules is available
+ */
+
+/**
+ * @typedef {object} ElectronContextTargetProperties
+ * @property {boolean | null} electronMain in main context
+ * @property {boolean | null} electronPreload in preload context
+ * @property {boolean | null} electronRenderer in renderer context with node integration
+ */
+
+/**
+ * @typedef {object} ApiTargetProperties
+ * @property {boolean | null} require has require function available
+ * @property {boolean | null} nodeBuiltins has node.js built-in modules available
+ * @property {boolean | null} nodePrefixForCoreModules node.js allows to use `node:` prefix for core modules
+ * @property {boolean | null} document has document available (allows script tags)
+ * @property {boolean | null} importScripts has importScripts available
+ * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
+ * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
+ * @property {boolean | null} global has global variable available
+ */
+
+/**
+ * @typedef {object} EcmaTargetProperties
+ * @property {boolean | null} globalThis has globalThis variable available
+ * @property {boolean | null} bigIntLiteral big int literal syntax is available
+ * @property {boolean | null} const const and let variable declarations are available
+ * @property {boolean | null} arrowFunction arrow functions are available
+ * @property {boolean | null} forOf for of iteration is available
+ * @property {boolean | null} destructuring destructuring is available
+ * @property {boolean | null} dynamicImport async import() is available
+ * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
+ * @property {boolean | null} module ESM syntax is available (when in module)
+ * @property {boolean | null} optionalChaining optional chaining is available
+ * @property {boolean | null} templateLiteral template literal is available
+ * @property {boolean | null} asyncFunction async functions and await are available
+ */
+
+/**
+ * @template T
+ * @typedef {{ [P in keyof T]?: never }} Never<T>
+ */
+
+/**
+ * @template A
+ * @template B
+ * @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A, B>
+ */
+
+/** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
+
+/**
+ * @param {string} major major version
+ * @param {string | undefined} minor minor version
+ * @returns {(vMajor: number, vMinor?: number) => boolean | undefined} check if version is greater or equal
+ */
+const versionDependent = (major, minor) => {
+	if (!major) {
+		return () => /** @type {undefined} */ (undefined);
+	}
+	/** @type {number} */
+	const nMajor = Number(major);
+	/** @type {number} */
+	const nMinor = minor ? Number(minor) : 0;
+	return (vMajor, vMinor = 0) =>
+		nMajor > vMajor || (nMajor === vMajor && nMinor >= vMinor);
+};
+
+/** @type {[string, string, RegExp, (...args: string[]) => Partial<TargetProperties>][]} */
+const TARGETS = [
+	[
+		"browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
+		"Resolve features from browserslist. Will resolve browserslist config automatically. Only browser or node queries are supported (electron is not supported). Examples: 'browserslist:modern' to use 'modern' environment from browserslist config",
+		/^browserslist(?::(.+))?$/,
+		(rest, context) => {
+			const browserslistTargetHandler = getBrowserslistTargetHandler();
+			const browsers = browserslistTargetHandler.load(
+				rest ? rest.trim() : null,
+				context
+			);
+			if (!browsers) {
+				throw new Error(`No browserslist config found to handle the 'browserslist' target.
+See https://github.com/browserslist/browserslist#queries for possible ways to provide a config.
+The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
+You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
+			}
+
+			return browserslistTargetHandler.resolve(browsers);
+		}
+	],
+	[
+		"web",
+		"Web browser.",
+		/^web$/,
+		() => ({
+			node: false,
+			web: true,
+			webworker: null,
+			browser: true,
+			electron: false,
+			nwjs: false,
+
+			document: true,
+			importScriptsInWorker: true,
+			fetchWasm: true,
+			nodeBuiltins: false,
+			importScripts: false,
+			require: false,
+			global: false
+		})
+	],
+	[
+		"webworker",
+		"Web Worker, SharedWorker or Service Worker.",
+		/^webworker$/,
+		() => ({
+			node: false,
+			web: true,
+			webworker: true,
+			browser: true,
+			electron: false,
+			nwjs: false,
+
+			importScripts: true,
+			importScriptsInWorker: true,
+			fetchWasm: true,
+			nodeBuiltins: false,
+			require: false,
+			document: false,
+			global: false
+		})
+	],
+	[
+		"[async-]node[X[.Y]]",
+		"Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
+		/^(async-)?node((\d+)(?:\.(\d+))?)?$/,
+		(asyncFlag, _, major, minor) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/
+			return {
+				node: true,
+				web: false,
+				webworker: false,
+				browser: false,
+				electron: false,
+				nwjs: false,
+
+				require: !asyncFlag,
+				nodeBuiltins: true,
+				// v16.0.0, v14.18.0
+				nodePrefixForCoreModules: Number(major) < 15 ? v(14, 18) : v(16),
+				global: true,
+				document: false,
+				fetchWasm: false,
+				importScripts: false,
+				importScriptsInWorker: false,
+
+				globalThis: v(12),
+				const: v(6),
+				templateLiteral: v(4),
+				optionalChaining: v(14),
+				arrowFunction: v(6),
+				asyncFunction: v(7, 6),
+				forOf: v(5),
+				destructuring: v(6),
+				bigIntLiteral: v(10, 4),
+				dynamicImport: v(12, 17),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(12, 17)
+			};
+		}
+	],
+	[
+		"electron[X[.Y]]-main/preload/renderer",
+		"Electron in version X.Y. Script is running in main, preload resp. renderer context.",
+		/^electron((\d+)(?:\.(\d+))?)?-(main|preload|renderer)$/,
+		(_, major, minor, context) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/ + https://github.com/electron/releases
+			return {
+				node: true,
+				web: context !== "main",
+				webworker: false,
+				browser: false,
+				electron: true,
+				nwjs: false,
+
+				electronMain: context === "main",
+				electronPreload: context === "preload",
+				electronRenderer: context === "renderer",
+
+				global: true,
+				nodeBuiltins: true,
+				// 15.0.0	- Node.js	v16.5
+				// 14.0.0 - Mode.js v14.17, but prefixes only since v14.18
+				nodePrefixForCoreModules: v(15),
+
+				require: true,
+				document: context === "renderer",
+				fetchWasm: context === "renderer",
+				importScripts: false,
+				importScriptsInWorker: true,
+
+				globalThis: v(5),
+				const: v(1, 1),
+				templateLiteral: v(1, 1),
+				optionalChaining: v(8),
+				arrowFunction: v(1, 1),
+				asyncFunction: v(1, 7),
+				forOf: v(0, 36),
+				destructuring: v(1, 1),
+				bigIntLiteral: v(4),
+				dynamicImport: v(11),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(11)
+			};
+		}
+	],
+	[
+		"nwjs[X[.Y]] / node-webkit[X[.Y]]",
+		"NW.js in version X.Y.",
+		/^(?:nwjs|node-webkit)((\d+)(?:\.(\d+))?)?$/,
+		(_, major, minor) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
+			return {
+				node: true,
+				web: true,
+				webworker: null,
+				browser: false,
+				electron: false,
+				nwjs: true,
+
+				global: true,
+				nodeBuiltins: true,
+				document: false,
+				importScriptsInWorker: false,
+				fetchWasm: false,
+				importScripts: false,
+				require: false,
+
+				globalThis: v(0, 43),
+				const: v(0, 15),
+				templateLiteral: v(0, 13),
+				optionalChaining: v(0, 44),
+				arrowFunction: v(0, 15),
+				asyncFunction: v(0, 21),
+				forOf: v(0, 13),
+				destructuring: v(0, 15),
+				bigIntLiteral: v(0, 32),
+				dynamicImport: v(0, 43),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(0, 43)
+			};
+		}
+	],
+	[
+		"esX",
+		"EcmaScript in this version. Examples: es2020, es5.",
+		/^es(\d+)$/,
+		version => {
+			let v = Number(version);
+			if (v < 1000) v = v + 2009;
+			return {
+				const: v >= 2015,
+				templateLiteral: v >= 2015,
+				optionalChaining: v >= 2020,
+				arrowFunction: v >= 2015,
+				forOf: v >= 2015,
+				destructuring: v >= 2015,
+				module: v >= 2015,
+				asyncFunction: v >= 2017,
+				globalThis: v >= 2020,
+				bigIntLiteral: v >= 2020,
+				dynamicImport: v >= 2020,
+				dynamicImportInWorker: v >= 2020
+			};
+		}
+	]
+];
+
+/**
+ * @param {string} target the target
+ * @param {string} context the context directory
+ * @returns {TargetProperties} target properties
+ */
+const getTargetProperties = (target, context) => {
+	for (const [, , regExp, handler] of TARGETS) {
+		const match = regExp.exec(target);
+		if (match) {
+			const [, ...args] = match;
+			const result = handler(...args, context);
+			if (result) return /** @type {TargetProperties} */ (result);
+		}
+	}
+	throw new Error(
+		`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(
+			([name, description]) => `* ${name}: ${description}`
+		).join("\n")}`
+	);
+};
+
+/**
+ * @param {TargetProperties[]} targetProperties array of target properties
+ * @returns {TargetProperties} merged target properties
+ */
+const mergeTargetProperties = targetProperties => {
+	/** @type {Set<keyof TargetProperties>} */
+	const keys = new Set();
+	for (const tp of targetProperties) {
+		for (const key of Object.keys(tp)) {
+			keys.add(/** @type {keyof TargetProperties} */ (key));
+		}
+	}
+	/** @type {TargetProperties} */
+	const result = {};
+	for (const key of keys) {
+		let hasTrue = false;
+		let hasFalse = false;
+		for (const tp of targetProperties) {
+			const value = tp[key];
+			switch (value) {
+				case true:
+					hasTrue = true;
+					break;
+				case false:
+					hasFalse = true;
+					break;
+			}
+		}
+		if (hasTrue || hasFalse)
+			/** @type {TargetProperties} */
+			(result)[key] = hasFalse && hasTrue ? null : Boolean(hasTrue);
+	}
+	return result;
+};
+
+/**
+ * @param {string[]} targets the targets
+ * @param {string} context the context directory
+ * @returns {TargetProperties} target properties
+ */
+const getTargetsProperties = (targets, context) =>
+	mergeTargetProperties(targets.map(t => getTargetProperties(t, context)));
+
+module.exports.getDefaultTarget = getDefaultTarget;
+module.exports.getTargetProperties = getTargetProperties;
+module.exports.getTargetsProperties = getTargetsProperties;