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/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -12,6 +12,7 @@ const {
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
 const InnerGraph = require("../optimize/InnerGraph");
+const AppendOnlyStackedSet = require("../util/AppendOnlyStackedSet");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
@@ -36,9 +37,18 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
 /** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
+/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
+/**
+ * @typedef {object} HarmonySpecifierGuards
+ * @property {AppendOnlyStackedSet<string> | undefined} guards
+ */
+
+/** @typedef {Map<string, Set<string>>} Guards Map of import root to guarded member keys */
+
 const harmonySpecifierTag = Symbol("harmony import");
+const harmonySpecifierGuardTag = Symbol("harmony import guard");
 
 /**
  * @typedef {object} HarmonySettings
@@ -53,12 +63,25 @@ const harmonySpecifierTag = Symbol("harmony import");
 
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
+/** @type {(members: Members) => string} */
+const getMembersKey = (members) => members.join(".");
+
+/**
+ * Strip the root binding name if needed
+ * @param {HarmonySettings} settings settings
+ * @param {Ids} ids ids
+ * @returns {Ids} ids for presence check
+ */
+const getIdsForPresence = (settings, ids) =>
+	settings.ids.length ? ids.slice(1) : ids;
+
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
 		this.options = options;
+		/** @type {ExportPresenceMode} */
 		this.exportPresenceMode =
 			options.importExportsPresence !== undefined
 				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
@@ -70,13 +93,30 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Ids} ids ids
+	 * @returns {ExportPresenceMode} exportPresenceMode
+	 */
+	getExportPresenceMode(parser, ids) {
+		const harmonySettings = /** @type {HarmonySettings=} */ (
+			parser.currentTagData
+		);
+		if (!harmonySettings) return this.exportPresenceMode;
+
+		const data = /** @type {HarmonySpecifierGuards=} */ (
+			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
+		);
+		return data && data.guards && data.guards.has(getMembersKey(ids))
+			? ExportPresenceModes.NONE
+			: this.exportPresenceMode;
+	}
+
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		const { exportPresenceMode } = this;
-
 		const getImportPhase = createGetImportPhase(this.options.deferImport);
 
 		/**
@@ -228,6 +268,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
@@ -235,7 +276,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					settings.name,
 					/** @type {Range} */
 					(expr.range),
-					exportPresenceMode,
+					this.getExportPresenceMode(
+						parser,
+						getIdsForPresence(settings, settings.ids)
+					),
 					settings.phase,
 					settings.attributes,
 					[]
@@ -285,7 +329,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						settings.name,
 						/** @type {Range} */
 						(expr.range),
-						exportPresenceMode,
+						this.getExportPresenceMode(
+							parser,
+							getIdsForPresence(settings, ids)
+						),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -335,7 +382,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						ids,
 						settings.name,
 						/** @type {Range} */ (expr.range),
-						exportPresenceMode,
+						this.getExportPresenceMode(
+							parser,
+							getIdsForPresence(settings, ids)
+						),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -402,7 +452,221 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				parser.state.module.addDependency(dep);
 			}
 		});
+
+		/**
+		 * @param {Expression} expression expression
+		 * @returns {{ root: string, members: Members } | undefined} info
+		 */
+		const getHarmonyImportInfo = (expression) => {
+			const nameInfo = parser.getNameForExpression(expression);
+			if (!nameInfo) return;
+
+			const rootInfo = nameInfo.rootInfo;
+			const root =
+				typeof rootInfo === "string"
+					? rootInfo
+					: rootInfo instanceof VariableInfo
+						? rootInfo.name
+						: undefined;
+			if (!root) return;
+			if (!parser.getTagData(root, harmonySpecifierTag)) return;
+			return { root, members: nameInfo.getMembers() };
+		};
+
+		/**
+		 * @param {Guards} guards guards
+		 * @param {string} root root name
+		 * @param {Members} members members
+		 */
+		const addToGuards = (guards, root, members) => {
+			const membersKey = getMembersKey(members);
+			const guardedMembers = guards.get(root);
+			if (guardedMembers) {
+				guardedMembers.add(membersKey);
+				return;
+			}
+
+			guards.set(
+				root,
+				// Adding `foo.bar` implies guarding `foo` as well
+				membersKey === "" ? new Set([""]) : new Set([membersKey, ""])
+			);
+		};
+
+		/**
+		 * @param {Expression} expression expression
+		 * @param {Guards} guards guards
+		 * @param {boolean} needTruthy need to be truthy
+		 */
+		const collect = (expression, guards, needTruthy) => {
+			// !foo
+			if (
+				expression.type === "UnaryExpression" &&
+				expression.operator === "!"
+			) {
+				collect(expression.argument, guards, !needTruthy);
+				return;
+			} else if (expression.type === "LogicalExpression" && needTruthy) {
+				// foo && bar
+				if (expression.operator === "&&") {
+					collect(expression.left, guards, true);
+					collect(expression.right, guards, true);
+				}
+				// falsy || foo
+				else if (expression.operator === "||") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					const leftBool = leftEvaluation.asBool();
+					if (leftBool === false) {
+						collect(expression.right, guards, true);
+					}
+				}
+				// nullish ?? foo
+				else if (expression.operator === "??") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					const leftNullish = leftEvaluation.asNullish();
+					if (leftNullish === true) {
+						collect(expression.right, guards, true);
+					}
+				}
+				return;
+			}
+			if (!needTruthy) return;
+
+			/**
+			 * @param {Expression} targetExpression expression
+			 * @returns {boolean} is added
+			 */
+			const addGuardForExpression = (targetExpression) => {
+				const info = getHarmonyImportInfo(targetExpression);
+				if (!info) return false;
+				addToGuards(guards, info.root, info.members);
+				return true;
+			};
+
+			/**
+			 * @param {Expression} left left expression
+			 * @param {Expression} right right expression
+			 * @param {(evaluation: ReturnType<JavascriptParser["evaluateExpression"]>) => boolean} matcher matcher
+			 * @returns {boolean} is added
+			 */
+			const addGuardForNullishCompare = (left, right, matcher) => {
+				const leftEval = parser.evaluateExpression(left);
+				if (leftEval && matcher(leftEval)) {
+					return addGuardForExpression(right);
+				}
+				const rightEval = parser.evaluateExpression(right);
+				if (rightEval && matcher(rightEval)) {
+					return addGuardForExpression(/** @type {Expression} */ (left));
+				}
+				return false;
+			};
+
+			if (expression.type === "BinaryExpression") {
+				// "bar" in foo
+				if (expression.operator === "in") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					if (leftEvaluation.couldHaveSideEffects()) return;
+					const propertyName = leftEvaluation.asString();
+					if (!propertyName) return;
+					parser.evaluateExpression(expression.right);
+					const info = getHarmonyImportInfo(expression.right);
+					if (!info) return;
+
+					if (info.members.length) {
+						for (const member of info.members) {
+							addToGuards(guards, info.root, [member]);
+						}
+					}
+					addToGuards(guards, info.root, [...info.members, propertyName]);
+					return;
+				}
+				// foo !== undefined
+				else if (
+					expression.operator === "!==" &&
+					addGuardForNullishCompare(
+						/** @type {Expression} */ (expression.left),
+						expression.right,
+						(evaluation) => evaluation.isUndefined()
+					)
+				) {
+					return;
+				}
+				// foo != undefined
+				// foo != null
+				else if (
+					expression.operator === "!=" &&
+					addGuardForNullishCompare(
+						/** @type {Expression} */ (expression.left),
+						expression.right,
+						(evaluation) => Boolean(evaluation.asNullish())
+					)
+				) {
+					return;
+				}
+			}
+			addGuardForExpression(expression);
+		};
+
+		/**
+		 * @param {Guards} guards guards
+		 * @param {() => void} walk walk callback
+		 * @returns {void}
+		 */
+		const withGuards = (guards, walk) => {
+			const applyGuards = () => {
+				/** @type {(() => void)[]} */
+				const restoreFns = [];
+
+				for (const [rootName, members] of guards) {
+					const previous = parser.getVariableInfo(rootName);
+					const exist = /** @type {HarmonySpecifierGuards=} */ (
+						parser.getTagData(rootName, harmonySpecifierGuardTag)
+					);
+
+					const mergedGuards =
+						exist && exist.guards
+							? exist.guards.createChild()
+							: new AppendOnlyStackedSet();
+
+					for (const memberKey of members) mergedGuards.add(memberKey);
+					parser.tagVariable(rootName, harmonySpecifierGuardTag, {
+						guards: mergedGuards
+					});
+					restoreFns.push(() => {
+						parser.setVariable(rootName, previous);
+					});
+				}
+
+				return () => {
+					for (const restore of restoreFns) {
+						restore();
+					}
+				};
+			};
+
+			const restore = applyGuards();
+			try {
+				walk();
+			} finally {
+				restore();
+			}
+		};
+
+		if (this.exportPresenceMode !== ExportPresenceModes.NONE) {
+			parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
+				if (parser.scope.isAsmJs) return;
+				/** @type {Guards} */
+				const guards = new Map();
+				collect(expression, guards, true);
+
+				if (guards.size === 0) return;
+				return (walk) => {
+					withGuards(guards, walk);
+				};
+			});
+		}
 	}
 };
 
+module.exports.harmonySpecifierGuardTag = harmonySpecifierGuardTag;
 module.exports.harmonySpecifierTag = harmonySpecifierTag;