Update npm packages (73 packages including @jqhtml 2.3.36)

Update npm registry domain from privatenpm.hanson.xyz to npm.internal.hanson.xyz

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/webpack/lib/serialization/ObjectMiddleware.js

@@ -18,7 +18,7 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
@@ -111,7 +111,7 @@ const setMapSize = (map, size) => {
 
 /**
  * @param {Buffer} buffer buffer
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const toHash = (buffer, hashFunction) => {
@@ -207,17 +207,21 @@ const loaders = new Map();
 /** @typedef {PrimitiveSerializableType[]} SerializedType */
 /** @typedef {{ logger: Logger }} Context */
 
+/** @typedef {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} ExtendContext */
+
 /**
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} extendContext context extensions
-	 * @param {string | Hash} hashFunction hash function to use
+	 * @param {ExtendContext} extendContext context extensions
+	 * @param {HashFunction} hashFunction hash function to use
 	 */
 	constructor(extendContext, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
+		/** @type {ExtendContext} */
 		this.extendContext = extendContext;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -276,11 +280,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {Constructor} object for serialization
+	 * @param {EXPECTED_ANY} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
 		const proto = Object.getPrototypeOf(object);
+		/** @type {null | Constructor} */
 		let c;
 		if (proto === null) {
 			// Object created with Object.create(null)
@@ -295,7 +300,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 		}
 		const config = serializers.get(c);
 
-		if (!config) throw new Error(`No serializer registered for ${c.name}`);
+		if (!config) {
+			throw new Error(
+				`No serializer registered for ${/** @type {Constructor} */ (c).name}`
+			);
+		}
 		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
 
 		return /** @type {SerializerConfigWithSerializer} */ (config);
@@ -345,6 +354,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		const addReferenceable = (item) => {
 			referenceable.set(item, currentPos++);
 		};
+		/** @type {Map<number, Buffer | [Buffer, Buffer] | Map<string, Buffer>>} */
 		let bufferDedupeMap = new Map();
 		/**
 		 * @param {Buffer} buf buffer
@@ -366,6 +376,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					return buf;
 				}
 				const hash = toHash(entry, this._hashFunction);
+				/** @type {Map<string, Buffer>} */
 				const newMap = new Map();
 				newMap.set(hash, entry);
 				bufferDedupeMap.set(len, newMap);
@@ -384,8 +395,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					entry.push(buf);
 					return buf;
 				}
+				/** @type {Map<string, Buffer>} */
 				const newMap = new Map();
 				const hash = toHash(buf, this._hashFunction);
+				/** @type {undefined | Buffer} */
 				let found;
 				for (const item of entry) {
 					const itemHash = toHash(item, this._hashFunction);
@@ -408,7 +421,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			return buf;
 		};
 		let currentPosTypeLookup = 0;
+		/** @type {Map<ComplexSerializableType, number>} */
 		let objectTypeLookup = new Map();
+		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
 		/**
 		 * @param {ComplexSerializableType} item item to stack
@@ -441,12 +456,18 @@ class ObjectMiddleware extends SerializerMiddleware {
 							if (item.constructor === Object) {
 								return `Object { ${Object.keys(item).join(", ")} }`;
 							}
-							if (item.constructor === Map) return `Map { ${item.size} items }`;
-							if (item.constructor === Array) {
-								return `Array { ${item.length} items }`;
+							if (item.constructor === Map) {
+								return `Map { ${/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */ (item).size} items }`;
+							}
+							if (item.constructor === Array) {
+								return `Array { ${/** @type {EXPECTED_ANY[]} */ (item).length} items }`;
+							}
+							if (item.constructor === Set) {
+								return `Set { ${/** @type {Set<EXPECTED_ANY>} */ (item).size} items }`;
+							}
+							if (item.constructor === RegExp) {
+								return /** @type {RegExp} */ (item).toString();
 							}
-							if (item.constructor === Set) return `Set { ${item.size} items }`;
-							if (item.constructor === RegExp) return item.toString();
 							return `${item.constructor.name}`;
 						}
 						return `Object [null prototype] { ${Object.keys(item).join(
@@ -464,7 +485,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				})
 				.join(" -> ");
 		};
-		/** @type {WeakSet<Error>} */
+		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
 		/** @type {ObjectSerializerContext} */
 		let ctx = {
@@ -723,6 +744,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					);
 				} else {
 					const request = nextItem;
+					/** @type {undefined | ObjectSerializer} */
 					let serializer;
 
 					if (typeof request === "number") {
@@ -788,6 +810,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 						// As this is only for error handling, we omit creating a Map for
 						// faster access to this information, as this would affect performance
 						// in the good case
+						/** @type {undefined | [Constructor | null, SerializerConfig]} */
 						let serializerEntry;
 						for (const entry of serializers) {
 							if (entry[1].serializer === serializer) {