webpack 5.59.0 → 5.94.0

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -13,6 +13,7 @@ const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
@@ -21,7 +22,14 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 
 const TYPES = new Set(["webassembly"]);
 
+/**
+ * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
+ */
+
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {OutputOptions["webassemblyModuleFilename"]} filenameTemplate template for the WebAssembly module filename
+	 */
 	constructor(filenameTemplate) {
 		super();
 		this.filenameTemplate = filenameTemplate;
@@ -61,15 +69,15 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		runtimeRequirements.add(RuntimeGlobals.moduleId);
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment[]} */
+		/** @type {InitFragment<InitFragment<string>>[]} */
 		const initFragments = [];
-		/** @type {Map<Module, { request: string, importVar: string }>} */
+		/** @type {Map<Module, ImportObjRequestItem>} */
 		const depModules = new Map();
 		/** @type {Map<string, WebAssemblyImportDependency[]>} */
 		const wasmDepsByRequest = new Map();
 		for (const dep of module.dependencies) {
 			if (dep instanceof WebAssemblyImportDependency) {
-				const module = moduleGraph.getModule(dep);
+				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 				if (!depModules.has(module)) {
 					depModules.set(module, {
 						request: dep.request,
@@ -85,6 +93,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			}
 		}
 
+		/** @type {Array<string>} */
 		const promises = [];
 
 		const importStatements = Array.from(
@@ -111,8 +120,12 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			wasmDepsByRequest,
 			([request, deps]) => {
 				const exportItems = deps.map(dep => {
-					const importedModule = moduleGraph.getModule(dep);
-					const importVar = depModules.get(importedModule).importVar;
+					const importedModule =
+						/** @type {Module} */
+						(moduleGraph.getModule(dep));
+					const importVar =
+						/** @type {ImportObjRequestItem} */
+						(depModules.get(importedModule)).importVar;
 					return `${JSON.stringify(
 						dep.name
 					)}: ${runtimeTemplate.exportFromImport({
@@ -145,15 +158,14 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 						"{",
 						Template.indent(importObjRequestItems.join(",\n")),
 						"}"
-				  ])
+					])
 				: undefined;
 
-		const instantiateCall =
-			`${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
-				module.moduleArgument
-			}.id, ${JSON.stringify(
-				chunkGraph.getRenderedModuleHash(module, runtime)
-			)}` + (importsObj ? `, ${importsObj})` : `)`);
+		const instantiateCall = `${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
+			module.moduleArgument
+		}.id, ${JSON.stringify(
+			chunkGraph.getRenderedModuleHash(module, runtime)
+		)}${importsObj ? `, ${importsObj})` : ")"}`;
 
 		if (promises.length > 0)
 			runtimeRequirements.add(RuntimeGlobals.asyncModule);
@@ -167,17 +179,23 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 						)}`,
 						`${RuntimeGlobals.asyncModule}(${
 							module.moduleArgument
-						}, ${runtimeTemplate.basicFunction(
-							"__webpack_handle_async_dependencies__",
+						}, async ${runtimeTemplate.basicFunction(
+							"__webpack_handle_async_dependencies__, __webpack_async_result__",
 							[
+								"try {",
 								importsCode,
 								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
 									", "
 								)}]);`,
-								"return __webpack_async_dependencies__.then ? __webpack_async_dependencies__.then(__webpack_instantiate__) : __webpack_instantiate__(__webpack_async_dependencies__);"
+								`var [${promises.join(
+									", "
+								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
+								`${importsCompatCode}await ${instantiateCall};`,
+								"__webpack_async_result__();",
+								"} catch(e) { __webpack_async_result__(e); }"
 							]
 						)}, 1);`
-				  ])
+					])
 				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
 		);
 

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -9,11 +9,13 @@ const { SyncWaterfallHook } = require("tapable");
 const Compilation = require("../Compilation");
 const Generator = require("../Generator");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
+const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
@@ -24,6 +26,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
 /** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const getAsyncWebAssemblyGenerator = memoize(() =>
 	require("./AsyncWebAssemblyGenerator")
@@ -36,7 +39,7 @@ const getAsyncWebAssemblyParser = memoize(() =>
 );
 
 /**
- * @typedef {Object} WebAssemblyRenderContext
+ * @typedef {object} WebAssemblyRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -46,13 +49,20 @@ const getAsyncWebAssemblyParser = memoize(() =>
  */
 
 /**
- * @typedef {Object} CompilationHooks
+ * @typedef {object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
  */
 
+/**
+ * @typedef {object} AsyncWebAssemblyModulesPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "AsyncWebAssemblyModulesPlugin";
+
 class AsyncWebAssemblyModulesPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -78,6 +88,9 @@ class AsyncWebAssemblyModulesPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {AsyncWebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -89,7 +102,7 @@ class AsyncWebAssemblyModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"AsyncWebAssemblyModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks =
 					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
@@ -99,15 +112,15 @@ class AsyncWebAssemblyModulesPlugin {
 				);
 
 				normalModuleFactory.hooks.createParser
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
+					.tap(PLUGIN_NAME, () => {
 						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
 
 						return new AsyncWebAssemblyParser();
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_ASYNC)
+					.tap(PLUGIN_NAME, () => {
 						const AsyncWebAssemblyJavascriptGenerator =
 							getAsyncWebAssemblyJavascriptGenerator();
 						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
@@ -135,9 +148,10 @@ class AsyncWebAssemblyModulesPlugin {
 							chunk,
 							compareModulesByIdentifier
 						)) {
-							if (module.type === "webassembly/async") {
+							if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
 								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
+									/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+									(outputOptions.webassemblyModuleFilename);
 
 								result.push({
 									render: () =>
@@ -175,6 +189,12 @@ class AsyncWebAssemblyModulesPlugin {
 		);
 	}
 
+	/**
+	 * @param {Module} module the rendered module
+	 * @param {WebAssemblyRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Source} the newly generated source from rendering
+	 */
 	renderModule(module, renderContext, hooks) {
 		const { codeGenerationResults, chunk } = renderContext;
 		try {
@@ -188,9 +208,9 @@ class AsyncWebAssemblyModulesPlugin {
 					hooks.renderModuleContent.call(moduleSource, module, renderContext),
 				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
 			);
-		} catch (e) {
-			e.module = module;
-			throw e;
+		} catch (err) {
+			/** @type {WebpackError} */ (err).module = module;
+			throw err;
 		}
 	}
 }

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -7,10 +7,13 @@
 
 const t = require("@webassemblyjs/ast");
 const { decode } = require("@webassemblyjs/wasm-parser");
+const EnvironmentNotSupportAsyncWarning = require("../EnvironmentNotSupportAsyncWarning");
 const Parser = require("../Parser");
 const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -23,6 +26,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});
@@ -40,14 +46,21 @@ class WebAssemblyParser extends Parser {
 		}
 
 		// flag it as async module
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
-		state.module.buildMeta.async = true;
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.strict = true;
+		const BuildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		BuildMeta.exportsType = "namespace";
+		BuildMeta.async = true;
+		EnvironmentNotSupportAsyncWarning.check(
+			state.module,
+			state.compilation.runtimeTemplate,
+			"asyncWebAssembly"
+		);
 
 		// parse it
 		const program = decode(source, decoderOpts);
 		const module = program.body[0];
-
+		/** @type {Array<string>} */
 		const exports = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -10,14 +10,25 @@ const Template = require("../Template");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
+/** @typedef {import("@webassemblyjs/ast").Signature} Signature */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 // TODO webpack 6 remove the whole folder
 
 // Get all wasm modules
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} chunk the chunk
+ * @returns {Module[]} all wasm modules
+ */
 const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
 	const wasmModules = chunk.getAllAsyncChunks();
 	const array = [];
@@ -39,7 +50,7 @@ const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
  * generates the import object function for a module
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} module the module
- * @param {boolean} mangle mangle imports
+ * @param {boolean | undefined} mangle mangle imports
  * @param {string[]} declarations array where declarations are pushed to
  * @param {RuntimeSpec} runtime the runtime
  * @returns {string} source code
@@ -52,6 +63,7 @@ const generateImportObject = (
 	runtime
 ) => {
 	const moduleGraph = chunkGraph.moduleGraph;
+	/** @type {Map<string, string | number>} */
 	const waitForInstances = new Map();
 	const properties = [];
 	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
@@ -76,32 +88,42 @@ const generateImportObject = (
 
 		if (direct) {
 			const instanceVar = `m${waitForInstances.size}`;
-			waitForInstances.set(instanceVar, chunkGraph.getModuleId(importedModule));
+			waitForInstances.set(
+				instanceVar,
+				/** @type {ModuleId} */
+				(chunkGraph.getModuleId(/** @type {Module} */ (importedModule)))
+			);
 			properties.push({
 				module,
 				name,
 				value: `${instanceVar}[${JSON.stringify(usedName)}]`
 			});
 		} else {
-			const params = description.signature.params.map(
-				(param, k) => "p" + k + param.valtype
-			);
+			const params =
+				/** @type {Signature} */
+				(description.signature).params.map(
+					(param, k) => `p${k}${param.valtype}`
+				);
 
 			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
-				chunkGraph.getModuleId(importedModule)
+				chunkGraph.getModuleId(/** @type {Module} */ (importedModule))
 			)}]`;
 			const modExports = `${mod}.exports`;
 
 			const cache = `wasmImportedFuncCache${declarations.length}`;
 			declarations.push(`var ${cache};`);
 
+			const modCode =
+				/** @type {Module} */
+				(importedModule).type.startsWith("webassembly")
+					? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
+					: "";
+
 			properties.push({
 				module,
 				name,
 				value: Template.asString([
-					(importedModule.type.startsWith("webassembly")
-						? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
-						: "") + `function(${params}) {`,
+					`${modCode}function(${params}) {`,
 					Template.indent([
 						`if(${cache} === undefined) ${cache} = ${modExports};`,
 						`return ${cache}[${JSON.stringify(usedName)}](${params});`
@@ -122,6 +144,7 @@ const generateImportObject = (
 			"};"
 		];
 	} else {
+		/** @type {Map<string, Array<{ name: string, value: string }>>} */
 		const propertiesByModule = new Map();
 		for (const p of properties) {
 			let list = propertiesByModule.get(p.module);
@@ -133,15 +156,15 @@ const generateImportObject = (
 		importObject = [
 			"return {",
 			Template.indent([
-				Array.from(propertiesByModule, ([module, list]) => {
-					return Template.asString([
+				Array.from(propertiesByModule, ([module, list]) =>
+					Template.asString([
 						`${JSON.stringify(module)}: {`,
 						Template.indent([
 							list.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
 						]),
 						"}"
-					]);
-				}).join(",\n")
+					])
+				).join(",\n")
 			]),
 			"};"
 		];
@@ -179,16 +202,26 @@ const generateImportObject = (
 			]),
 			"},"
 		]);
-	} else {
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent(importObject),
-			"},"
-		]);
 	}
+	return Template.asString([
+		`${moduleIdStringified}: function() {`,
+		Template.indent(importObject),
+		"},"
+	]);
 };
 
+/**
+ * @typedef {object} WasmChunkLoadingRuntimeModuleOptions
+ * @property {(path: string) => string} generateLoadBinaryCode
+ * @property {boolean} [supportsStreaming]
+ * @property {boolean} [mangleImports]
+ * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
+ */
+
 class WasmChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {WasmChunkLoadingRuntimeModuleOptions} options options
+	 */
 	constructor({
 		generateLoadBinaryCode,
 		supportsStreaming,
@@ -203,29 +236,37 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, compilation, chunk, mangleImports } = this;
-		const { moduleGraph, outputOptions } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withHmr = this._runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadUpdateHandlers
 		);
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { moduleGraph, outputOptions } = compilation;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		const { mangleImports } = this;
+		/** @type {string[]} */
 		const declarations = [];
-		const importObjects = wasmModules.map(module => {
-			return generateImportObject(
+		const importObjects = wasmModules.map(module =>
+			generateImportObject(
 				chunkGraph,
 				module,
-				this.mangleImports,
+				mangleImports,
 				declarations,
 				chunk.runtime
-			);
-		});
+			)
+		);
 		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
 			m.type.startsWith("webassembly")
 		);
+		/**
+		 * @param {string} content content
+		 * @returns {string} created import object
+		 */
 		const createImportObject = content =>
 			mangleImports
 				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
@@ -291,7 +332,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			`${fn}.wasm = function(chunkId, promises) {`,
 			Template.indent([
 				"",
-				`var wasmModules = wasmModuleMap[chunkId] || [];`,
+				"var wasmModules = wasmModuleMap[chunkId] || [];",
 				"",
 				"wasmModules.forEach(function(wasmModuleId, idx) {",
 				Template.indent([
@@ -302,7 +343,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 					Template.indent(["promises.push(installedWasmModuleData);"]),
 					"else {",
 					Template.indent([
-						`var importObject = wasmImportObjects[wasmModuleId]();`,
+						"var importObject = wasmImportObjects[wasmModuleId]();",
 						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
 						"var promise;",
 						this.supportsStreaming
@@ -323,7 +364,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 											"importObject"
 										)});`
 									])
-							  ])
+								])
 							: Template.asString([
 									"if(importObject && typeof importObject.then === 'function') {",
 									Template.indent([
@@ -341,7 +382,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 										]),
 										"});"
 									])
-							  ]),
+								]),
 						"} else {",
 						Template.indent([
 							"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -9,6 +9,9 @@ const formatLocation = require("../formatLocation");
 const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeatureError");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 class WasmFinalizeExportsPlugin {
 	/**
@@ -25,7 +28,8 @@ class WasmFinalizeExportsPlugin {
 						// 1. if a WebAssembly module
 						if (module.type.startsWith("webassembly") === true) {
 							const jsIncompatibleExports =
-								module.buildMeta.jsIncompatibleExports;
+								/** @type {BuildMeta} */
+								(module.buildMeta).jsIncompatibleExports;
 
 							if (jsIncompatibleExports === undefined) {
 								continue;
@@ -37,12 +41,13 @@ class WasmFinalizeExportsPlugin {
 								// 2. is active and referenced by a non-WebAssembly module
 								if (
 									connection.isTargetActive(undefined) &&
-									connection.originModule.type.startsWith("webassembly") ===
+									/** @type {Module} */
+									(connection.originModule).type.startsWith("webassembly") ===
 										false
 								) {
 									const referencedExports =
 										compilation.getDependencyReferencedExports(
-											connection.dependency,
+											/** @type {Dependency} */ (connection.dependency),
 											undefined
 										);
 
@@ -61,9 +66,15 @@ class WasmFinalizeExportsPlugin {
 											// 4. error
 											const error = new UnsupportedWebAssemblyFeatureError(
 												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
-													`It's used from ${connection.originModule.readableIdentifier(
-														compilation.requestShortener
-													)} at ${formatLocation(connection.dependency.loc)}.`
+													`It's used from ${
+														/** @type {Module} */
+														(connection.originModule).readableIdentifier(
+															compilation.requestShortener
+														)
+													} at ${formatLocation(
+														/** @type {Dependency} */ (connection.dependency)
+															.loc
+													)}.`
 											);
 											error.module = module;
 											compilation.errors.push(error);