webpack 5.112.0 → 5.112.1

package/lib/template/RuntimeTemplate.js

@@ -414,11 +414,11 @@ function getGlobalObject(definition) {
 
 	if (
 		// identifier, we do not need real identifier regarding ECMAScript/Unicode
-		/^[_\p{L}][_0-9\p{L}]*$/iu.test(trimmed) ||
+		/^[_\p{L}][_0-9\p{L}]*$/u.test(trimmed) ||
 		// iife
 		// call expression
 		// expression in parentheses
-		/^(?:[_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu.test(trimmed)
+		/^(?:[_\p{L}][_0-9\p{L}]*)?\(.*\)$/u.test(trimmed)
 	) {
 		return trimmed;
 	}
@@ -1386,7 +1386,7 @@ class RuntimeTemplate {
 				const spellable =
 					this._getAnalyzableFileSpecifier(
 						module,
-						/** @type {ChunkGraph} */ (chunkGraph),
+						chunkGraph,
 						[["literal", "x"]],
 						true
 					) !== null;
@@ -2888,7 +2888,7 @@ class RuntimeTemplate {
 	 * @returns {boolean} true when the hash exists by the time the target is hashed
 	 */
 	_hashRoundBefore(chunk, target) {
-		const chunkGraph = /** @type {ChunkGraph} */ (this.compilation.chunkGraph);
+		const chunkGraph = this.compilation.chunkGraph;
 		const round = hashRound(chunk, chunkGraph);
 		const targetRound = hashRound(target, chunkGraph);
 		if (round !== targetRound) return round < targetRound;
@@ -2956,8 +2956,7 @@ class RuntimeTemplate {
 	 */
 	_settlesLate(chunk) {
 		return (
-			/** @type {ChunkGraph} */
-			(this.compilation.chunkGraph).getChunkFullHashModulesIterable(chunk) !==
+			this.compilation.chunkGraph.getChunkFullHashModulesIterable(chunk) !==
 			undefined
 		);
 	}
@@ -2989,7 +2988,7 @@ class RuntimeTemplate {
 	_markChunksSettlingLate() {
 		this._chunksBakingFullHash = new Set();
 		const { compilation } = this;
-		const chunkGraph = /** @type {ChunkGraph} */ (compilation.chunkGraph);
+		const chunkGraph = compilation.chunkGraph;
 		const results = compilation.codeGenerationResults;
 		if (results === undefined) return;
 		/** @type {Map<Chunk, Set<string>>} */
@@ -3234,11 +3233,7 @@ class RuntimeTemplate {
 			const undo =
 				shape === undefined
 					? null
-					: getUndoPath(
-							`${shape}x`,
-							/** @type {string} */ (this.outputOptions.path),
-							true
-						);
+					: getUndoPath(`${shape}x`, this.outputOptions.path, true);
 			this._publicPathClimbText = undo === "./" ? "" : undo;
 		}
 		return this._publicPathClimbText;
@@ -3273,11 +3268,7 @@ class RuntimeTemplate {
 			undo:
 				chunkName === null
 					? null
-					: getUndoPath(
-							chunkName,
-							/** @type {string} */ (outputOptions.path),
-							true
-						),
+					: getUndoPath(chunkName, outputOptions.path, true),
 			// A chunk in an initial group and an async one both is served at two urls,
 			// one public path apart, so no one literal in it is right for both.
 			loaded: chunk.isOnlyInitial() ? false : chunk.canBeInitial() ? null : true
@@ -3338,11 +3329,7 @@ class RuntimeTemplate {
 				: shape,
 			{ chunk, contentHashType: JAVASCRIPT_TYPE }
 		);
-		return getUndoPath(
-			name,
-			/** @type {string} */ (this.outputOptions.path),
-			enforceRelative
-		);
+		return getUndoPath(name, this.outputOptions.path, enforceRelative);
 	}
 
 	/**
@@ -3495,7 +3482,7 @@ class RuntimeTemplate {
 		const filename =
 			deferred && !settled
 				? ""
-				: compilation.getPath(/** @type {string} */ (template), {
+				: compilation.getPath(template, {
 						chunk,
 						// Matches what names the asset, or a placeholder resolved here would
 						// not be the one on disk.
@@ -4113,7 +4100,7 @@ class RuntimeTemplate {
 		}
 		const undo = getUndoPath(
 			this.compilation.getPath(this._hotUpdateShapeText, { chunk }),
-			/** @type {string} */ (outputOptions.path),
+			outputOptions.path,
 			true
 		);
 		this._hotUpdateUndoByChunk.set(chunk, undo);
@@ -4131,9 +4118,7 @@ class RuntimeTemplate {
 	 */
 	getAnalyzableWasmUrl(module, chunkGraph, runtime, runtimeRequirements) {
 		const { compilation } = this;
-		const template = /** @type {string} */ (
-			this.outputOptions.webassemblyModuleFilename
-		);
+		const template = this.outputOptions.webassemblyModuleFilename;
 		// The module's own hash and id are settled here, the compilation's is not — and
 		// a placeholder nothing answers is left in the name, so what comes back is either
 		// the final name or a template carrying only `[fullhash]`.
@@ -4500,11 +4485,7 @@ class RuntimeTemplate {
 							} else if (kind === "literal") {
 								specifier += value;
 							} else if (kind === "undo") {
-								specifier += getUndoPath(
-									assetName,
-									/** @type {string} */ (outputOptions.path),
-									true
-								);
+								specifier += getUndoPath(assetName, outputOptions.path, true);
 							} else if (kind === "template") {
 								specifier += compilation.getPath(
 									/** @type {string} */ (value),

package/lib/template/Template.js

@@ -53,7 +53,7 @@ const LINE_SEPARATOR_REGEX = /\r?\n/g;
 const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-z$_])/i;
 const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-z0-9$]+/gi;
 const COMMENT_END_REGEX = /\*\//g;
-const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-z0-9_!§$()=\-^°]+/gi;
+const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
 const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
 
 /**

package/lib/util/SourceProcessor.js

@@ -186,11 +186,11 @@ const declineDeferredWrites = (text, writes) =>
  */
 /**
  * What part `M` gives the node type `R` says it is; every part `D` when `R`
- * says none (a plain node reads `unknown` there).
+ * says none (a plain node reads `number` there).
  * @template R
  * @template {Record<number, number>} M
  * @template D
- * @typedef {number extends (R & { readonly __nodeType: unknown })["__nodeType"] ? D : M[(R & { readonly __nodeType: unknown })["__nodeType"] & number]} PartOf
+ * @typedef {number extends (R & { readonly __nodeType: number })["__nodeType"] ? D : M[(R & { readonly __nodeType: number })["__nodeType"]]} PartOf
  */
 /**
  * A language's parts, by node type: what its `Field`s and `Flag`s apply to.
@@ -281,7 +281,10 @@ const declineDeferredWrites = (text, writes) =>
 const deferredKey = (offer) => {
 	let key = "";
 	for (const name of Object.keys(offer).sort()) {
-		const value = /** @type {Record<string, unknown>} */ (offer)[name];
+		const value =
+			/** @type {Record<string, DeferredWrite[keyof DeferredWrite]>} */ (offer)[
+				name
+			];
 		if (typeof value !== "function") key += `${name}\0${value}\0`;
 	}
 	return key;
@@ -402,10 +405,13 @@ class PrintContext {
 		this._printer = printer;
 		// Printed text by node handle, in two columns rather than one `Map`: the
 		// handles are dense integers, and `_moveEpoch` keeps the live set small.
-		/** @type {string[]} each finished node's printed text */
+		/** @type {(string | null)[]} each finished node's printed text */
 		this._storeText = [];
 		/** @type {Int32Array} the epoch each slot was written in */
 		this._storeGen = new Int32Array(0);
+		// A slot holding `null` prints as its source, read only once asked for.
+		/** @type {((node: TNode) => string) | undefined} reads a `null` slot's text */
+		this._sourceText = undefined;
 		/** @type {number} current epoch; a slot from an older one reads as absent */
 		this._gen = 1;
 		/** @type {number} lowest slot written since the epoch last moved */
@@ -417,6 +423,8 @@ class PrintContext {
 		// for retractable text alone, so no other emit pays for that ability.
 		/** @type {string[]} pieces already cut off, in output order */
 		this._chunks = [];
+		/** @type {Map<number, { readonly text: string }> | null} pieces whose text is read only once the output is */
+		this._deferred = null;
 		/** @type {string} output after the last cut piece */
 		this._tail = "";
 		/** @type {number} characters in `_tail`, so its length is not read off a rope */
@@ -593,6 +601,7 @@ class PrintContext {
 	 * @param {number} charCode the character to drop
 	 */
 	dropTrailing(from, charCode) {
+		this._settleDeferred();
 		const chunks = this._chunks;
 		for (let i = chunks.length; i >= from; i--) {
 			let text = i === chunks.length ? this._tail : chunks[i];
@@ -622,6 +631,7 @@ class PrintContext {
 	 * @returns {boolean} true when the output ended that way and was rewritten
 	 */
 	replaceEnd(printed, text, closer) {
+		this._settleDeferred();
 		this._cutTail();
 		const chunks = this._chunks;
 		// Joined once: this runs only where a value ran into the end of the input.
@@ -656,7 +666,16 @@ class PrintContext {
 	 * @param {TPath} path the language accessor, positioned on `node`
 	 */
 	printNode(node, path) {
-		const text = this._printer(path, this);
+		this.printedAs(node, this._printer(path, this));
+	}
+
+	/**
+	 * Store `text` as what `node` printed, where the grammar already knows what
+	 * the node printer would return and so does not call it.
+	 * @param {TNode} node the finished node
+	 * @param {string} text its printed text
+	 */
+	printedAs(node, text) {
 		const n = /** @type {number} */ (node);
 		if (n >= this._storeText.length) this._growStore(n + 1);
 		this._storeText[n] = text;
@@ -665,6 +684,22 @@ class PrintContext {
 		if (n > this._storeHigh) this._storeHigh = n;
 	}
 
+	/**
+	 * Store that `node` printed as its source, which `sourceText` reads only once
+	 * something asks for its text.
+	 * @param {TNode} node the finished node
+	 * @param {(node: TNode) => string} sourceText reads a node's source
+	 */
+	printedSource(node, sourceText) {
+		const n = /** @type {number} */ (node);
+		if (n >= this._storeText.length) this._growStore(n + 1);
+		this._sourceText = sourceText;
+		this._storeText[n] = null;
+		this._storeGen[n] = this._gen;
+		if (n < this._storeLow) this._storeLow = n;
+		if (n > this._storeHigh) this._storeHigh = n;
+	}
+
 	/**
 	 * Print one node and hand its text straight back — for a node inside one being
 	 * printed in pieces, whose text is emitted as it is printed, so the store
@@ -682,9 +717,16 @@ class PrintContext {
 	 */
 	get(node) {
 		const n = /** @type {number} */ (node);
-		return /** @type {string} */ (
-			this._storeGen[n] === this._gen ? this._storeText[n] : undefined
+		if (this._storeGen[n] !== this._gen) {
+			return /** @type {string} */ (/** @type {unknown} */ (undefined));
+		}
+		const text = this._storeText[n];
+		if (text !== null) return text;
+		const source = /** @type {(node: TNode) => string} */ (this._sourceText)(
+			node
 		);
+		this._storeText[n] = source;
+		return source;
 	}
 
 	/**
@@ -742,6 +784,7 @@ class PrintContext {
 	 * @param {number} index the piece's index, from {@link emitRetractable}
 	 */
 	retract(index) {
+		if (this._deferred !== null) this._deferred.delete(index);
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
 		const mapping = this._retractableMappings[index];
@@ -755,6 +798,7 @@ class PrintContext {
 	 * @returns {boolean} true when it does
 	 */
 	writesNonAscii(index) {
+		this._settleDeferred();
 		const chunks = this._chunks;
 		for (let i = index + 1; i < chunks.length; i++) {
 			if (NON_ASCII_RE.test(chunks[i])) return true;
@@ -776,6 +820,7 @@ class PrintContext {
 	 * @param {string} text what to fold in, its own closer included
 	 */
 	foldIntoRetractable(index, text) {
+		this._settleDeferred();
 		const piece = this._chunks[index];
 		this._chunks[index] = `${piece.slice(0, -1)}${text}`;
 	}
@@ -788,9 +833,31 @@ class PrintContext {
 	 * @param {string} text what the piece says now
 	 */
 	rewriteRetractable(index, text) {
+		if (this._deferred !== null) this._deferred.delete(index);
 		this._chunks[index] = text;
 	}
 
+	/**
+	 * {@link rewriteRetractable} with text that is asked for only once the output
+	 * is read: a piece rewritten many times over is then built once, not each time.
+	 * @param {number} index the piece's index, from {@link emitRetractable}
+	 * @param {{ readonly text: string }} source what holds the piece's text
+	 */
+	deferRetractable(index, source) {
+		if (this._deferred === null) this._deferred = new Map();
+		this._deferred.set(index, source);
+	}
+
+	/**
+	 * Write every deferred piece's text in, before anything reads the pieces.
+	 */
+	_settleDeferred() {
+		const deferred = this._deferred;
+		if (deferred === null) return;
+		this._deferred = null;
+		for (const [index, source] of deferred) this._chunks[index] = source.text;
+	}
+
 	/**
 	 * {@link take} for a top-level node a later sibling may still make dead — the
 	 * unprefixed twin of a vendor-prefixed rule, which can stand anywhere after
@@ -953,6 +1020,7 @@ class PrintContext {
 	 * @returns {SourceMap} the input->output source map
 	 */
 	sourceMap(options, code) {
+		this._settleDeferred();
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
@@ -1024,6 +1092,7 @@ class PrintContext {
 	 * @returns {void}
 	 */
 	substitute(resolve, infix) {
+		this._settleDeferred();
 		const chunks = this._chunks;
 		const mappings = this._mappings;
 		// Both pieces and mappings are output-ordered, so one cursor walks them
@@ -1086,6 +1155,7 @@ class PrintContext {
 	 * @param {string} text the output to keep instead
 	 */
 	replaceAll(text) {
+		this._deferred = null;
 		this._chunks.length = 0;
 		this._tail = text;
 		this._tailLength = text.length;
@@ -1097,6 +1167,7 @@ class PrintContext {
 	}
 
 	result() {
+		this._settleDeferred();
 		// Trailing kept comments (after the last top-level node) flush here.
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
@@ -1175,8 +1246,8 @@ class SourceProcessor {
 	 * @returns {SourceProcessor<TPath, TNode, TProcessOptions, TPrintOptions, TParts, TState, TVisitors>} `this`, for chaining
 	 */
 	/**
-	 * @param {EXPECTED_ANY} map visitor map, or the node types `bucket` visits
-	 * @param {VisitorBucket<EXPECTED_ANY>=} bucket the visitor, with an array of types
+	 * @param {number[] | TVisitors | VisitorMap<TPath>} map visitor map, or the node types `bucket` visits
+	 * @param {VisitorBucket<TypedNodePath<TPath, TNode, TParts, number, TState>>=} bucket the visitor, with an array of types
 	 * @returns {SourceProcessor<TPath, TNode, TProcessOptions, TPrintOptions, TParts, TState, TVisitors>} `this`, for chaining
 	 */
 	use(map, bucket) {
@@ -1186,14 +1257,23 @@ class SourceProcessor {
 					"SourceProcessor.use(types, bucket): a visitor is required"
 				);
 			}
-			for (let i = 0; i < map.length; i++) this._add(map[i], bucket);
+			for (let i = 0; i < map.length; i++) {
+				this._add(
+					map[i],
+					/** @type {VisitorBucket<TPath>} */ (
+						/** @type {VisitorBucket<TPath> | VisitorBucket<TypedNodePath<TPath, TNode, TParts, number, TState>>} */ (
+							bucket
+						)
+					)
+				);
+			}
 			return this;
 		}
 		// `map`'s keys are node-type enum members; `Object.keys` stringifies them,
 		// so index the compiled array by the number to match the numeric `node.type`.
-		for (const type of Object.keys(map)) {
+		for (const type of Object.keys(/** @type {VisitorMap<TPath>} */ (map))) {
 			const key = Number(type);
-			this._add(key, map[key]);
+			this._add(key, /** @type {VisitorMap<TPath>} */ (map)[key]);
 		}
 		return this;
 	}
@@ -1291,9 +1371,9 @@ class SourceProcessor {
 		// along is inert, since a printer reads only what its own type declares.
 		const ctx = new PrintContext(
 			/** @type {PrintOptions & TPrintOptions} */ (
-				/** @type {unknown} */ (opts)
+				/** @type {typeof opts | (PrintOptions & TPrintOptions)} */ (opts)
 			),
-			/** @type {NodePrinter<TPath, TNode, TPrintOptions>} */ (this._printer)
+			this._printer
 		);
 		this._run(input, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
@@ -1343,7 +1423,10 @@ class SourceProcessor {
 		// renderer's answer widened, which `Omit` cannot say and nothing reads.
 		const opts =
 			/** @type {TProcessOptions & { mode: PrintOptions["mode"] }} */
-			(/** @type {unknown} */ (options));
+			(
+				/** @type {typeof options | (TProcessOptions & { mode: PrintOptions["mode"] })} */
+				(options)
+			);
 
 		if (render === undefined) {
 			return /** @type {{ code: string, map: SourceMap | undefined }} */ (

package/lib/util/WeakTupleMap.js

@@ -5,10 +5,16 @@
 
 "use strict";
 
+/**
+ * A value one position of a tuple key may hold: a primitive kept in a `Map`, or
+ * an object (functions included) kept in a `WeakMap`.
+ * @typedef {string | number | bigint | boolean | symbol | EXPECTED_OBJECT | null | undefined} TupleElement
+ */
+
 /**
  * Strong-key child map used for tuple elements that cannot be stored in a
  * `WeakMap`.
- * @template {EXPECTED_ANY[]} T
+ * @template {TupleElement[]} T
  * @template V
  * @typedef {Map<ArrayElement<T>, WeakTupleMap<T, V>>} M
  */
@@ -16,7 +22,7 @@
 /**
  * Weak-key child map used for tuple elements that are objects and can be held
  * without preventing garbage collection.
- * @template {EXPECTED_ANY[]} T
+ * @template {TupleElement[]} T
  * @template V
  * @typedef {WeakMap<ArrayElement<T> & EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
  */
@@ -31,14 +37,14 @@ const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
 
 /**
  * Extracts the element type from a tuple-like array.
- * @template {unknown[]} T
+ * @template T
  * @typedef {T extends ReadonlyArray<infer ElementType> ? ElementType : never} ArrayElement
  */
 
 /**
  * Stores values by tuple keys while using `WeakMap` for object elements so the
  * cache can release entries when those objects are collected.
- * @template {EXPECTED_ANY[]} K
+ * @template {TupleElement[]} K
  * @template V
  */
 class WeakTupleMap {

package/lib/util/cleverMerge.js

@@ -88,19 +88,27 @@ const cachedSetProperty = (obj, property, value) => {
 
 /**
  * Defines the by values type used by this module.
- * @typedef {Map<string, EXPECTED_ANY>} ByValues
+ * @template V
+ * @typedef {Map<string, V>} ByValues
  */
 
 /**
  * Defines the object parsed property entry type used by this module.
  * @template T
+ * @template [V=T[keyof T]]
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {T[keyof T] | undefined} base base value
+ * @property {V | undefined} base base value
  * @property {`by${string}` | undefined} byProperty the name of the selector property
- * @property {ByValues | undefined} byValues value depending on selector property, merged with base
+ * @property {ByValues<V | undefined> | undefined} byValues value depending on selector property, merged with base
  */
 
-/** @typedef {((...x: EXPECTED_ANY) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
+/**
+ * Result of merging a value of type `A` with a value of type `B`.
+ * @template A, B
+ * @typedef {A & B | (A | B)[] | A | A[] | B | B[]} MergedValue
+ */
+
+/** @typedef {((...values: never[]) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
 
 /**
  * Defines the parsed object static type used by this module.
@@ -139,7 +147,11 @@ const cachedParseObject = (obj) => {
 	return result;
 };
 
-/** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
+/**
+ * Defines the by object type used by this module.
+ * @template T
+ * @typedef {{ [p: string]: Partial<T> } | DynamicFunction} ByObject
+ */
 
 /**
  * Returns parsed object.
@@ -172,7 +184,7 @@ const parseObject = (obj) => {
 		const key = /** @type {keyof T} */ (key_);
 		if (typeof key === "string" && key.startsWith("by")) {
 			const byProperty = key;
-			const byObj = /** @type {ByObject} */ (obj[byProperty]);
+			const byObj = /** @type {ByObject<T>} */ (obj[byProperty]);
 			if (typeof byObj === "object") {
 				for (const byValue of Object.keys(byObj)) {
 					const obj = byObj[/** @type {keyof (keyof T)} */ (byValue)];
@@ -183,20 +195,20 @@ const parseObject = (obj) => {
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
-								`${/** @type {string} */ (byProperty)} and ${entry.byProperty} for a single property is not supported`
+								`${byProperty} and ${entry.byProperty} for a single property is not supported`
 							);
 						}
-						/** @type {ByValues} */
-						(entry.byValues).set(byValue, obj[key]);
+						/** @type {ByValues<T[keyof T] | undefined>} */
+						(entry.byValues).set(byValue, obj[/** @type {keyof T} */ (key)]);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
 								if (
 									!(
-										/** @type {ByValues} */
+										/** @type {ByValues<T[keyof T] | undefined>} */
 										(entry.byValues).has(otherByValue)
 									)
 								) {
-									/** @type {ByValues} */
+									/** @type {ByValues<T[keyof T] | undefined>} */
 									(entry.byValues).set(otherByValue, undefined);
 								}
 							}
@@ -237,13 +249,19 @@ const parseObject = (obj) => {
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
-	const obj = /** @type {EXPECTED_ANY} */ ({});
+	const obj =
+		/** @type {Record<PropertyKey, T[keyof T] | Record<string, Record<PropertyKey, T[keyof T]>> | DynamicFunction>} */
+		({});
 	// Setup byProperty structure
 	for (const entry of info.values()) {
 		if (entry.byProperty !== undefined) {
 			const byProperty = entry.byProperty;
-			const byObj = (obj[byProperty] = obj[byProperty] || {});
-			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
+			const byObj =
+				/** @type {Record<string, Record<PropertyKey, T[keyof T]>>} */
+				(obj[byProperty] = obj[byProperty] || {});
+			for (const byValue of /** @type {ByValues<T[keyof T] | undefined>} */ (
+				entry.byValues
+			).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
 		}
@@ -255,10 +273,12 @@ const serializeObject = (info, dynamicInfo) => {
 		// Fill byProperty structure
 		if (entry.byProperty !== undefined) {
 			const byProperty = entry.byProperty;
-			const byObj = (obj[byProperty] = obj[byProperty] || {});
+			const byObj =
+				/** @type {Record<string, Record<PropertyKey, T[keyof T]>>} */
+				(obj[byProperty] = obj[byProperty] || {});
 			for (const byValue of Object.keys(byObj)) {
 				const value = getFromByValues(
-					/** @type {ByValues} */
+					/** @type {ByValues<T[keyof T] | undefined>} */
 					(entry.byValues),
 					byValue
 				);
@@ -269,7 +289,7 @@ const serializeObject = (info, dynamicInfo) => {
 	if (dynamicInfo !== undefined) {
 		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
 	}
-	return obj;
+	return /** @type {T} */ (obj);
 };
 
 const VALUE_TYPE_UNDEFINED = 0;
@@ -395,7 +415,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
  * @param {ObjectParsedPropertyEntry<T>} firstEntry a
  * @param {ObjectParsedPropertyEntry<O>} secondEntry b
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O>} new entry
+ * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O, MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -420,13 +440,16 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			} else {
 				// = first.base + (first.byProperty + second.byProperty)
 				// need to merge first and second byValues
-				/** @type {Map<string, T & O>} */
+				/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of /** @type {ByValues} */ (
+				for (const [
+					key,
+					value
+				] of /** @type {ByValues<O[keyof O] | undefined>} */ (
 					secondEntry.byValues
 				)) {
 					const firstValue = getFromByValues(
-						/** @type {ByValues} */
+						/** @type {ByValues<T[keyof T] | undefined>} */
 						(firstEntry.byValues),
 						key
 					);
@@ -461,7 +484,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			}
 			/** @type {O[keyof O] | T[keyof T] | (T[keyof T] & O[keyof O]) | (T[keyof T] | undefined)[] | (O[keyof O] | undefined)[] | (O[keyof O] | T[keyof T] | undefined)[] | undefined} */
 			let newBase;
-			/** @type {Map<string, (T & O) | O[keyof O] | (O[keyof O] | undefined)[] | ((T & O) | undefined)[] | (T & O & O[keyof O]) | ((T & O) | O[keyof O] | undefined)[] | undefined>} */
+			/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 			const intermediateByValues = new Map(firstEntry.byValues);
 			for (const [key, value] of intermediateByValues) {
 				intermediateByValues.set(
@@ -470,12 +493,14 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				[.../** @type {ByValues} */ (firstEntry.byValues).values()].every(
-					(value) => {
-						const type = getValueType(value);
-						return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-					}
-				)
+				[
+					.../** @type {ByValues<T[keyof T] | undefined>} */ (
+						firstEntry.byValues
+					).values()
+				].every((value) => {
+					const type = getValueType(value);
+					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+				})
 			) {
 				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
 				newBase = mergeSingleValue(
@@ -502,9 +527,12 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
 				);
 			}
-			/** @type {Map<string, (T & O) | O[keyof O] | (O[keyof O] | undefined)[] | (T & O & O[keyof O]) | ((T & O) | undefined)[] | ((T & O) | O[keyof O] | undefined)[] | undefined>} */
+			/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of /** @type {ByValues} */ (
+			for (const [
+				key,
+				value
+			] of /** @type {ByValues<O[keyof O] | undefined>} */ (
 				secondEntry.byValues
 			)) {
 				const firstValue = getFromByValues(intermediateByValues, key);
@@ -525,7 +553,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 /**
  * Gets from by values.
  * @template V
- * @param {ByValues} byValues all values
+ * @param {ByValues<V>} byValues all values
  * @param {string} key value of the selector
  * @returns {V | undefined} value
  */
@@ -543,7 +571,7 @@ const getFromByValues = (byValues, key) => {
  * @param {A | A[]} a value
  * @param {B | B[]} b value
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {A & B | (A | B)[] | A | A[] | B | B[]} value
+ * @returns {MergedValue<A, B>} value
  */
 const mergeSingleValue = (a, b, internalCaching) => {
 	const bType = getValueType(b);
@@ -635,7 +663,7 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 				newObj[key] =
 					/** @type {T[keyof T]} */
 					(
-						/** @type {EXPECTED_ANY[]} */
+						/** @type {T[keyof T] extends readonly (infer E)[] ? E[] : never} */
 						(value).filter((i) => i !== "...")
 					);
 				break;