first commit

app_vue/node_modules/webpack/lib/json/JsonData.js

@@ -0,0 +1,74 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { register } = require("../util/serialization");
+
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
+
+class JsonData {
+	/**
+	 * @param {Buffer | JsonValue} data JSON data
+	 */
+	constructor(data) {
+		/** @type {Buffer | undefined} */
+		this._buffer = undefined;
+		/** @type {JsonValue | undefined} */
+		this._data = undefined;
+		if (Buffer.isBuffer(data)) {
+			this._buffer = data;
+		} else {
+			this._data = data;
+		}
+	}
+
+	/**
+	 * @returns {JsonValue | undefined} Raw JSON data
+	 */
+	get() {
+		if (this._data === undefined && this._buffer !== undefined) {
+			this._data = JSON.parse(this._buffer.toString());
+		}
+		return this._data;
+	}
+
+	/**
+	 * @param {Hash} hash hash to be updated
+	 * @returns {void} the updated hash
+	 */
+	updateHash(hash) {
+		if (this._buffer === undefined && this._data !== undefined) {
+			this._buffer = Buffer.from(JSON.stringify(this._data));
+		}
+
+		if (this._buffer) hash.update(this._buffer);
+	}
+}
+
+register(JsonData, "webpack/lib/json/JsonData", null, {
+	/**
+	 * @param {JsonData} obj JSONData object
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, { write }) {
+		if (obj._buffer === undefined && obj._data !== undefined) {
+			obj._buffer = Buffer.from(JSON.stringify(obj._data));
+		}
+		write(obj._buffer);
+	},
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {JsonData} deserialized JSON data
+	 */
+	deserialize({ read }) {
+		return new JsonData(read());
+	}
+});
+
+module.exports = JsonData;

app_vue/node_modules/webpack/lib/json/JsonGenerator.js

@@ -0,0 +1,231 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
+const { UsageState } = require("../ExportsInfo");
+const Generator = require("../Generator");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./JsonData")} JsonData */
+/** @typedef {import("./JsonModulesPlugin").JsonArray} JsonArray */
+/** @typedef {import("./JsonModulesPlugin").JsonObject} JsonObject */
+/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
+
+/**
+ * @param {JsonValue} data Raw JSON data
+ * @returns {undefined|string} stringified data
+ */
+const stringifySafe = data => {
+	const stringified = JSON.stringify(data);
+	if (!stringified) {
+		return; // Invalid JSON
+	}
+
+	return stringified.replace(/\u2028|\u2029/g, str =>
+		str === "\u2029" ? "\\u2029" : "\\u2028"
+	); // invalid in JavaScript but valid JSON
+};
+
+/**
+ * @param {JsonObject | JsonArray} data Raw JSON data (always an object or array)
+ * @param {ExportsInfo} exportsInfo exports info
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {JsonObject | JsonArray} reduced data
+ */
+const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
+		return data;
+	const isArray = Array.isArray(data);
+	/** @type {JsonObject | JsonArray} */
+	const reducedData = isArray ? [] : {};
+	for (const key of Object.keys(data)) {
+		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
+		const used = exportInfo.getUsed(runtime);
+		if (used === UsageState.Unused) continue;
+
+		// The real type is `JsonObject | JsonArray`, but typescript doesn't work `Object.keys(['string', 'other-string', 'etc'])` properly
+		const newData = /** @type {JsonObject} */ (data)[key];
+		const value =
+			used === UsageState.OnlyPropertiesUsed &&
+			exportInfo.exportsInfo &&
+			typeof newData === "object" &&
+			newData
+				? createObjectForExportsInfo(newData, exportInfo.exportsInfo, runtime)
+				: newData;
+
+		const name = /** @type {string} */ (exportInfo.getUsedName(key, runtime));
+		/** @type {JsonObject} */
+		(reducedData)[name] = value;
+	}
+	if (isArray) {
+		const arrayLengthWhenUsed =
+			exportsInfo.getReadOnlyExportInfo("length").getUsed(runtime) !==
+			UsageState.Unused
+				? data.length
+				: undefined;
+
+		let sizeObjectMinusArray = 0;
+		const reducedDataLength =
+			/** @type {JsonArray} */
+			(reducedData).length;
+		for (let i = 0; i < reducedDataLength; i++) {
+			if (/** @type {JsonArray} */ (reducedData)[i] === undefined) {
+				sizeObjectMinusArray -= 2;
+			} else {
+				sizeObjectMinusArray += `${i}`.length + 3;
+			}
+		}
+		if (arrayLengthWhenUsed !== undefined) {
+			sizeObjectMinusArray +=
+				`${arrayLengthWhenUsed}`.length +
+				8 -
+				(arrayLengthWhenUsed - reducedDataLength) * 2;
+		}
+		if (sizeObjectMinusArray < 0)
+			return Object.assign(
+				arrayLengthWhenUsed === undefined
+					? {}
+					: { length: arrayLengthWhenUsed },
+				reducedData
+			);
+		/** @type {number} */
+		const generatedLength =
+			arrayLengthWhenUsed !== undefined
+				? Math.max(arrayLengthWhenUsed, reducedDataLength)
+				: reducedDataLength;
+		for (let i = 0; i < generatedLength; i++) {
+			if (/** @type {JsonArray} */ (reducedData)[i] === undefined) {
+				/** @type {JsonArray} */
+				(reducedData)[i] = 0;
+			}
+		}
+	}
+	return reducedData;
+};
+
+class JsonGenerator extends Generator {
+	/**
+	 * @param {JsonGeneratorOptions} options options
+	 */
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {SourceTypes} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return JS_TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		/** @type {JsonValue | undefined} */
+		const data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
+		if (!data) return 0;
+		return /** @type {string} */ (stringifySafe(data)).length + 10;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generate(
+		module,
+		{
+			moduleGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
+		}
+	) {
+		/** @type {JsonValue | undefined} */
+		const data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
+		if (data === undefined) {
+			return new RawSource(
+				runtimeTemplate.missingModuleStatement({
+					request: module.rawRequest
+				})
+			);
+		}
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		/** @type {JsonValue} */
+		const finalJson =
+			typeof data === "object" &&
+			data &&
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused
+				? createObjectForExportsInfo(data, exportsInfo, runtime)
+				: data;
+		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
+		const jsonStr = /** @type {string} */ (stringifySafe(finalJson));
+		const jsonExpr =
+			this.options.JSONParse &&
+			jsonStr.length > 20 &&
+			typeof finalJson === "object"
+				? `/*#__PURE__*/JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
+				: jsonStr.replace(/"__proto__":/g, '["__proto__"]:');
+		/** @type {string} */
+		let content;
+		if (concatenationScope) {
+			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			} = ${jsonExpr};`;
+			concatenationScope.registerNamespaceExport(
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			);
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			content = `${module.moduleArgument}.exports = ${jsonExpr};`;
+		}
+		return new RawSource(content);
+	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+	}
+}
+
+module.exports = JsonGenerator;

app_vue/node_modules/webpack/lib/json/JsonModulesPlugin.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { JSON_MODULE_TYPE } = require("../ModuleTypeConstants");
+const createSchemaValidation = require("../util/create-schema-validation");
+const JsonGenerator = require("./JsonGenerator");
+const JsonParser = require("./JsonParser");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../util/fs").JsonArray} JsonArray */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
+
+const validate = createSchemaValidation(
+	require("../../schemas/plugins/json/JsonModulesPluginParser.check.js"),
+	() => require("../../schemas/plugins/json/JsonModulesPluginParser.json"),
+	{
+		name: "Json Modules Plugin",
+		baseDataPath: "parser"
+	}
+);
+
+const validateGenerator = createSchemaValidation(
+	require("../../schemas/plugins/json/JsonModulesPluginGenerator.check.js"),
+	() => require("../../schemas/plugins/json/JsonModulesPluginGenerator.json"),
+	{
+		name: "Json Modules Plugin",
+		baseDataPath: "generator"
+	}
+);
+
+const PLUGIN_NAME = "JsonModulesPlugin";
+
+/**
+ * The JsonModulesPlugin is the entrypoint plugin for the json modules feature.
+ * It adds the json module type to the compiler and registers the json parser and generator.
+ */
+class JsonModulesPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for(JSON_MODULE_TYPE)
+					.tap(PLUGIN_NAME, parserOptions => {
+						validate(parserOptions);
+						return new JsonParser(parserOptions);
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for(JSON_MODULE_TYPE)
+					.tap(PLUGIN_NAME, generatorOptions => {
+						validateGenerator(generatorOptions);
+						return new JsonGenerator(generatorOptions);
+					});
+			}
+		);
+	}
+}
+
+module.exports = JsonModulesPlugin;

app_vue/node_modules/webpack/lib/json/JsonParser.js

@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Parser = require("../Parser");
+const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
+const memoize = require("../util/memoize");
+const JsonData = require("./JsonData");
+
+/** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
+
+const getParseJson = memoize(() => require("json-parse-even-better-errors"));
+
+class JsonParser extends Parser {
+	/**
+	 * @param {JsonModulesPluginParserOptions} options parser options
+	 */
+	constructor(options) {
+		super();
+		this.options = options || {};
+	}
+
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		}
+
+		/** @type {NonNullable<JsonModulesPluginParserOptions["parse"]>} */
+		const parseFn =
+			typeof this.options.parse === "function"
+				? this.options.parse
+				: getParseJson();
+		/** @type {Buffer | JsonValue | undefined} */
+		let data;
+		try {
+			data =
+				typeof source === "object"
+					? source
+					: parseFn(source[0] === "\uFEFF" ? source.slice(1) : source);
+		} catch (err) {
+			throw new Error(
+				`Cannot parse JSON: ${/** @type {Error} */ (err).message}`
+			);
+		}
+		const jsonData = new JsonData(/** @type {Buffer | JsonValue} */ (data));
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.jsonData = jsonData;
+		buildInfo.strict = true;
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject =
+			typeof data === "object" ? "redirect-warn" : false;
+		state.module.addDependency(
+			new JsonExportsDependency(
+				jsonData,
+				/** @type {number} */
+				(this.options.exportsDepth)
+			)
+		);
+		return state;
+	}
+}
+
+module.exports = JsonParser;