@wyw-in-js/transform 2.0.0-alpha.0 → 2.0.0-alpha.1

package/esm/utils/collectOxcTemplateDependencies/staticEvaluator.js

@@ -0,0 +1,540 @@
+import { lookupStaticBinding } from "./staticBindings.js";
+import { resolveBindingAt } from "./scopeAnalysis.js";
+export const literalCode = (value) => {
+	if (typeof value === "number") {
+		return Number.isFinite(value) ? JSON.stringify(value) : null;
+	}
+	if (value === null || typeof value === "string" || typeof value === "boolean") {
+		return JSON.stringify(value);
+	}
+	if (Array.isArray(value)) {
+		return JSON.stringify(value);
+	}
+	if (typeof value === "object" && value !== null) {
+		return `(${JSON.stringify(value)})`;
+	}
+	return null;
+};
+export const isStaticSerializableValue = (value) => literalCode(value) !== null;
+export const cloneStaticValue = (value) => {
+	if (Array.isArray(value)) {
+		return value.map((item) => cloneStaticValue(item));
+	}
+	if (typeof value === "object" && value !== null) {
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneStaticValue(item)]));
+	}
+	return value;
+};
+const INT32_SIZE = 2 ** 32;
+const INT32_SIGN_BIT = 2 ** 31;
+const toInt32 = (value) => {
+	if (!Number.isFinite(value) || value === 0) {
+		return 0;
+	}
+	const integer = Math.sign(value) * Math.floor(Math.abs(value));
+	const int32bit = (integer % INT32_SIZE + INT32_SIZE) % INT32_SIZE;
+	return int32bit >= INT32_SIGN_BIT ? int32bit - INT32_SIZE : int32bit;
+};
+const bitwiseNot = (value) => -toInt32(value) - 1;
+const getObjectMember = (objectValue, property) => {
+	if (objectValue === null || objectValue === undefined || typeof objectValue !== "object" && typeof objectValue !== "string" && typeof objectValue !== "number" && typeof objectValue !== "boolean") {
+		return undefined;
+	}
+	return objectValue[property];
+};
+const oxcStaticCallableValue = Symbol("wyw.oxc.staticCallableValue");
+const isOxcStaticCallableValue = (value) => typeof value === "object" && value !== null && oxcStaticCallableValue in value;
+const unwrapOxcStaticCallableValue = (value) => isOxcStaticCallableValue(value) ? value[oxcStaticCallableValue] : value;
+export const createOxcStaticCallableValue = (value) => ({ [oxcStaticCallableValue]: value });
+const assignPatternValue = (pattern, value, ctx, env, stack) => {
+	if (pattern.type === "Identifier") {
+		env.set(pattern.name, value);
+		return true;
+	}
+	if (pattern.type === "AssignmentPattern") {
+		return assignPatternValue(pattern.left, value === undefined ? evaluateStatic(pattern.right, ctx, env, stack) : value, ctx, env, stack);
+	}
+	if (pattern.type === "ObjectPattern") {
+		if (typeof value !== "object" || value === null) {
+			return false;
+		}
+		return pattern.properties.every((property) => {
+			if (property.type === "RestElement") {
+				return false;
+			}
+			let key;
+			if (property.computed) {
+				key = evaluateStatic(property.key, ctx, env, stack);
+			} else if (property.key.type === "Identifier") {
+				key = property.key.name;
+			} else if (property.key.type === "Literal") {
+				key = property.key.value;
+			}
+			if (key === undefined || key === null) {
+				return false;
+			}
+			return assignPatternValue(property.value, getObjectMember(value, key), ctx, env, stack);
+		});
+	}
+	if (pattern.type === "ArrayPattern") {
+		if (!Array.isArray(value)) {
+			return false;
+		}
+		return pattern.elements.every((element, index) => element ? assignPatternValue(element, value[index], ctx, env, stack) : true);
+	}
+	return false;
+};
+const applyRootMutation = (bindingName, baseValue, mutation, ctx, env, stack) => {
+	const resolvePath = (node) => {
+		if (node.type === "Identifier") {
+			return node.name === bindingName ? { path: [] } : null;
+		}
+		if (node.type !== "MemberExpression") {
+			return null;
+		}
+		const parent = resolvePath(node.object);
+		if (!parent) {
+			return null;
+		}
+		let key;
+		if (node.computed) {
+			key = evaluateStatic(node.property, ctx, env, stack);
+		} else if (node.property.type === "Identifier") {
+			key = node.property.name;
+		}
+		if (key === undefined || key === null || typeof key !== "string" && typeof key !== "number") {
+			return null;
+		}
+		return { path: [...parent.path, key] };
+	};
+	const pathInfo = resolvePath(mutation.type === "AssignmentExpression" ? mutation.left : mutation.argument);
+	if (!pathInfo) {
+		return undefined;
+	}
+	const cloned = cloneStaticValue(baseValue);
+	if (pathInfo.path.length === 0) {
+		if (mutation.type !== "AssignmentExpression") {
+			return undefined;
+		}
+		return evaluateStatic(mutation.right, ctx, env, stack);
+	}
+	let target = cloned;
+	for (let idx = 0; idx < pathInfo.path.length - 1; idx += 1) {
+		const key = pathInfo.path[idx];
+		const next = target?.[key];
+		if (typeof next !== "object" || next === null) {
+			return undefined;
+		}
+		target = next;
+	}
+	const lastKey = pathInfo.path[pathInfo.path.length - 1];
+	if (mutation.type === "AssignmentExpression") {
+		const nextValue = evaluateStatic(mutation.right, ctx, env, stack);
+		if (nextValue === undefined) {
+			return undefined;
+		}
+		target[lastKey] = nextValue;
+		return cloned;
+	}
+	const currentValue = target[lastKey];
+	if (typeof currentValue !== "number") {
+		return undefined;
+	}
+	target[lastKey] = mutation.operator === "++" ? currentValue + 1 : currentValue - 1;
+	return cloned;
+};
+const evaluateFunctionCall = (fn, args, ctx, env, stack) => {
+	if (fn.async || !fn.body) {
+		return undefined;
+	}
+	const localEnv = new Map(env);
+	for (let idx = 0; idx < fn.params.length; idx += 1) {
+		if (!assignPatternValue(fn.params[idx], args[idx], ctx, localEnv, stack)) {
+			return undefined;
+		}
+	}
+	if (fn.body.type !== "BlockStatement") {
+		return evaluateStatic(fn.body, ctx, localEnv, stack);
+	}
+	for (const statement of fn.body.body) {
+		if (statement.type === "VariableDeclaration") {
+			for (const declarator of statement.declarations) {
+				const value = declarator.init ? evaluateStatic(declarator.init, ctx, localEnv, stack) : undefined;
+				if (!assignPatternValue(declarator.id, value, ctx, localEnv, stack)) {
+					return undefined;
+				}
+			}
+			continue;
+		}
+		if (statement.type === "ReturnStatement") {
+			if (!statement.argument) {
+				return undefined;
+			}
+			return evaluateStatic(statement.argument, ctx, localEnv, stack);
+		}
+		return undefined;
+	}
+	return undefined;
+};
+const isProcessEnvMember = (node) => {
+	if (node.type !== "MemberExpression" || node.computed) {
+		return false;
+	}
+	if (node.property.type !== "Identifier" || node.property.name !== "env") {
+		return false;
+	}
+	return node.object.type === "Identifier" && node.object.name === "process";
+};
+const isProcessEnvValueAccess = (expression, env) => expression.type === "MemberExpression" && isProcessEnvMember(expression.object) && !env.has("process");
+const isDeterministicUndefinedExpression = (expression, ctx, env) => {
+	if (isProcessEnvValueAccess(expression, env)) {
+		return true;
+	}
+	if (expression.type === "UnaryExpression" && expression.operator === "void") {
+		return true;
+	}
+	return expression.type === "Identifier" && expression.name === "undefined" && !resolveBindingAt(ctx, expression.name, expression.start);
+};
+const evaluateBinary = (expression, ctx, env = new Map(), stack = []) => {
+	if (expression.type !== "BinaryExpression") {
+		return undefined;
+	}
+	const left = evaluateStatic(expression.left, ctx, env, stack);
+	const right = evaluateStatic(expression.right, ctx, env, stack);
+	const leftIsDeterministicUndefined = left === undefined && isDeterministicUndefinedExpression(expression.left, ctx, env);
+	const rightIsDeterministicUndefined = right === undefined && isDeterministicUndefinedExpression(expression.right, ctx, env);
+	if (left === undefined && !leftIsDeterministicUndefined || right === undefined && !rightIsDeterministicUndefined) {
+		return undefined;
+	}
+	switch (expression.operator) {
+		case "===": return left === right;
+		case "!==": return left !== right;
+		case "==":
+ // eslint-disable-next-line eqeqeq
+		return left == right;
+		case "!=":
+ // eslint-disable-next-line eqeqeq
+		return left != right;
+		default: break;
+	}
+	if (expression.operator === "+") {
+		if (typeof left === "number" && typeof right === "number") {
+			return left + right;
+		}
+		if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number")) {
+			return `${left}${right}`;
+		}
+	}
+	if (typeof left === "number" && typeof right === "number") {
+		switch (expression.operator) {
+			case "<": return left < right;
+			case "<=": return left <= right;
+			case ">": return left > right;
+			case ">=": return left >= right;
+			case "-": return left - right;
+			case "*": return left * right;
+			case "/": return left / right;
+			case "%": return left % right;
+			case "**": return left ** right;
+			default: break;
+		}
+	}
+	return undefined;
+};
+export const evaluateStatic = (expression, ctx, env = new Map(), stack = []) => {
+	if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSInstantiationExpression" || expression.type === "TSTypeAssertion" || expression.type === "ParenthesizedExpression") {
+		return evaluateStatic(expression.expression, ctx, env, stack);
+	}
+	if (expression.type === "Literal") {
+		return expression.value;
+	}
+	if (expression.type === "UnaryExpression") {
+		if (expression.operator === "typeof") {
+			const argIsProcessEnvAccess = isProcessEnvValueAccess(expression.argument, env);
+			// `typeof someIdentifier` is the canonical undeclared-global
+			// probe — it returns 'undefined' regardless of whether the
+			// symbol is declared. Only fold truly unbound identifiers: declared
+			// but dynamic locals still have runtime values we cannot infer.
+			const argIsUnboundBareIdentifier = expression.argument.type === "Identifier" && !resolveBindingAt(ctx, expression.argument.name, expression.argument.start);
+			const arg = evaluateStatic(expression.argument, ctx, env, stack);
+			if (arg === undefined) {
+				return argIsProcessEnvAccess || argIsUnboundBareIdentifier ? "undefined" : undefined;
+			}
+			return typeof arg;
+		}
+		const arg = evaluateStatic(expression.argument, ctx, env, stack);
+		if (arg === undefined) {
+			return undefined;
+		}
+		switch (expression.operator) {
+			case "-": return typeof arg === "number" ? -arg : undefined;
+			case "+": return typeof arg === "number" ? +arg : undefined;
+			case "!": return !arg;
+			case "~": return typeof arg === "number" ? bitwiseNot(arg) : undefined;
+			case "void": return undefined;
+			default: return undefined;
+		}
+	}
+	if (expression.type === "LogicalExpression") {
+		const left = evaluateStatic(expression.left, ctx, env, stack);
+		// process.env.X access is the only source we trust as "deterministically
+		// undefined" — it's a build-time lookup we control. For everything else,
+		// undefined means "couldn't evaluate" and we must bail to avoid inlining
+		// a wrong fallback when the runtime value isn't actually nullish.
+		const leftIsProcessEnvAccess = isProcessEnvValueAccess(expression.left, env);
+		if (left === undefined && !leftIsProcessEnvAccess) {
+			return undefined;
+		}
+		if (expression.operator === "||") {
+			return left || evaluateStatic(expression.right, ctx, env, stack);
+		}
+		if (expression.operator === "??") {
+			return left ?? evaluateStatic(expression.right, ctx, env, stack);
+		}
+		if (expression.operator === "&&") {
+			return left && evaluateStatic(expression.right, ctx, env, stack);
+		}
+		return undefined;
+	}
+	if (expression.type === "ConditionalExpression") {
+		const test = evaluateStatic(expression.test, ctx, env, stack);
+		if (test === undefined) {
+			return undefined;
+		}
+		return evaluateStatic(test ? expression.consequent : expression.alternate, ctx, env, stack);
+	}
+	if (expression.type === "TemplateLiteral") {
+		let result = "";
+		for (let idx = 0; idx < expression.quasis.length; idx += 1) {
+			result += expression.quasis[idx]?.value.cooked ?? "";
+			const nextExpression = expression.expressions[idx];
+			if (!nextExpression) {
+				continue;
+			}
+			const value = evaluateStatic(nextExpression, ctx, env, stack);
+			if (value === undefined || typeof value !== "string" && typeof value !== "number") {
+				return undefined;
+			}
+			result += String(value);
+		}
+		return result;
+	}
+	if (expression.type === "Identifier") {
+		if (env.has(expression.name)) {
+			return unwrapOxcStaticCallableValue(env.get(expression.name));
+		}
+		const binding = resolveBindingAt(ctx, expression.name, expression.start);
+		if (binding?.importedFrom) {
+			// staticBindings can supply a literal value for an imported name,
+			// bypassing whatever the source module would otherwise resolve to.
+			// Function values are deferred to the CallExpression branch.
+			const override = lookupStaticBinding(ctx.staticBindings, binding.importedFrom, binding.imported);
+			if (override.found && typeof override.value !== "function") {
+				return override.value;
+			}
+			return undefined;
+		}
+		if (!binding) {
+			return undefined;
+		}
+		if (binding.kind === "param") {
+			return undefined;
+		}
+		if (stack.includes(binding.name)) {
+			return undefined;
+		}
+		let value;
+		const { declarator } = binding;
+		const init = declarator?.init;
+		if (init) {
+			if (declarator.id.type !== "Identifier") {
+				return undefined;
+			}
+			value = evaluateStatic(init, ctx, env, [...stack, binding.name]);
+		} else if (binding.functionNode) {
+			value = binding.functionNode;
+		}
+		if (value !== undefined && binding.isRoot && typeof value === "object" && value !== null && !Array.isArray(value)) {
+			const mutations = ctx.rootMutationsByBinding.get(binding.name) ?? [];
+			let nextValue = cloneStaticValue(value);
+			for (const mutation of mutations) {
+				if (mutation.start >= ctx.currentExpressionStart) {
+					break;
+				}
+				const applied = applyRootMutation(binding.name, nextValue, mutation, ctx, env, [...stack, binding.name]);
+				if (applied === undefined) {
+					return undefined;
+				}
+				nextValue = applied;
+			}
+			return nextValue;
+		}
+		return value;
+	}
+	if (expression.type === "ObjectExpression") {
+		const result = {};
+		for (const property of expression.properties) {
+			if (property.type === "SpreadElement") {
+				const spreadValue = evaluateStatic(property.argument, ctx, env, stack);
+				if (typeof spreadValue !== "object" || spreadValue === null) {
+					return undefined;
+				}
+				Object.assign(result, spreadValue);
+				continue;
+			}
+			let key;
+			if (property.computed) {
+				key = evaluateStatic(property.key, ctx, env, stack);
+			} else if (property.key.type === "Identifier") {
+				key = property.key.name;
+			} else if (property.key.type === "Literal") {
+				key = property.key.value;
+			}
+			if (key === undefined || key === null || typeof key !== "string" && typeof key !== "number") {
+				return undefined;
+			}
+			const value = evaluateStatic(property.value, ctx, env, stack);
+			if (value === undefined) {
+				return undefined;
+			}
+			result[key] = value;
+		}
+		return result;
+	}
+	if (expression.type === "ArrayExpression") {
+		const result = [];
+		for (const element of expression.elements) {
+			if (!element) {
+				return undefined;
+			}
+			if (element.type === "SpreadElement") {
+				const spreadValue = evaluateStatic(element.argument, ctx, env, stack);
+				if (!Array.isArray(spreadValue)) {
+					return undefined;
+				}
+				result.push(...spreadValue);
+				continue;
+			}
+			const value = evaluateStatic(element, ctx, env, stack);
+			if (value === undefined) {
+				return undefined;
+			}
+			result.push(value);
+		}
+		return result;
+	}
+	if (expression.type === "MemberExpression") {
+		let key;
+		if (expression.computed) {
+			key = evaluateStatic(expression.property, ctx, env, stack);
+		} else if (expression.property.type === "Identifier") {
+			key = expression.property.name;
+		}
+		if (key === undefined || key === null || typeof key !== "string" && typeof key !== "number") {
+			return undefined;
+		}
+		if (isProcessEnvValueAccess(expression, env) && typeof key === "string") {
+			// Treat process.env.X as deterministically undefined at build time.
+			// Reading from real process.env would couple the bundle to whatever
+			// happens to be set on the build machine; falling back to the
+			// ?? / || branch (or a runtime read) is more predictable.
+			return undefined;
+		}
+		const objectValue = evaluateStatic(expression.object, ctx, env, stack);
+		if (objectValue === undefined) {
+			return undefined;
+		}
+		return getObjectMember(objectValue, key);
+	}
+	if (expression.type === "NewExpression") {
+		if (expression.callee.type !== "Identifier" || expression.arguments.length !== 1) {
+			return undefined;
+		}
+		const [argument] = expression.arguments;
+		if (!argument || argument.type === "SpreadElement") {
+			return undefined;
+		}
+		const value = evaluateStatic(argument, ctx, env, stack);
+		if (value === undefined) {
+			return undefined;
+		}
+		if (expression.callee.name === "String") {
+			return String(value);
+		}
+		if (expression.callee.name === "Number") {
+			return Number(value);
+		}
+		if (expression.callee.name === "Boolean") {
+			return Boolean(value);
+		}
+		return undefined;
+	}
+	if (expression.type === "CallExpression") {
+		if (expression.callee.type === "Identifier") {
+			const args = expression.arguments.map((arg) => arg.type === "SpreadElement" ? undefined : evaluateStatic(arg, ctx, env, stack));
+			if (args.some((value) => value === undefined)) {
+				return undefined;
+			}
+			const staticCallable = env.get(expression.callee.name);
+			if (isOxcStaticCallableValue(staticCallable) && expression.arguments.length === 0) {
+				return unwrapOxcStaticCallableValue(staticCallable);
+			}
+			// Plain function in env (e.g. supplied via staticBindings as a
+			// pure helper). Invoke with already-evaluated args.
+			if (typeof staticCallable === "function") {
+				try {
+					return staticCallable(...args);
+				} catch {
+					return undefined;
+				}
+			}
+			if (expression.callee.name === "String" && args.length === 1) {
+				return String(args[0]);
+			}
+			if (expression.callee.name === "Number" && args.length === 1) {
+				return Number(args[0]);
+			}
+			if (expression.callee.name === "Boolean" && args.length === 1) {
+				return Boolean(args[0]);
+			}
+			const binding = resolveBindingAt(ctx, expression.callee.name, expression.callee.start);
+			// staticBindings can register a pure helper for an imported name
+			// (e.g. linaria's `cx` from '@linaria/core'). When the callee
+			// resolves to such an import and every arg evaluated, invoke the
+			// helper and return its result as a static value.
+			if (binding?.importedFrom) {
+				const override = lookupStaticBinding(ctx.staticBindings, binding.importedFrom, binding.imported);
+				if (override.found && typeof override.value === "function") {
+					try {
+						return override.value(...args);
+					} catch {
+						return undefined;
+					}
+				}
+			}
+			const fn = binding?.functionNode ?? binding?.declarator?.init;
+			if (fn && (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression")) {
+				return evaluateFunctionCall(fn, args, ctx, env, [...stack, expression.callee.name]);
+			}
+		}
+		if (expression.callee.type === "MemberExpression") {
+			const objectValue = evaluateStatic(expression.callee.object, ctx, env, stack);
+			let key;
+			if (expression.callee.computed) {
+				key = evaluateStatic(expression.callee.property, ctx, env, stack);
+			} else if (expression.callee.property.type === "Identifier") {
+				key = expression.callee.property.name;
+			}
+			if (typeof objectValue === "string") {
+				if (key === "toLowerCase" && expression.arguments.length === 0) {
+					return objectValue.toLowerCase();
+				}
+				if (key === "toUpperCase" && expression.arguments.length === 0) {
+					return objectValue.toUpperCase();
+				}
+			}
+		}
+	}
+	return evaluateBinary(expression, ctx, env, stack);
+};
+//# sourceMappingURL=staticEvaluator.js.map

package/esm/utils/collectOxcTemplateDependencies/staticEvaluator.js.map

@@ -0,0 +1 @@
+{"mappings":"AASA,SAAS,2BAA2B;AACpC,SAAS,wBAAwB;AAGjC,OAAO,MAAM,eAAe,UAAkC;AAC5D,KAAI,OAAO,UAAU,UAAU;AAC7B,SAAO,OAAO,SAAS,MAAM,GAAG,KAAK,UAAU,MAAM,GAAG;;AAG1D,KACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAO,UAAU,WACjB;AACA,SAAO,KAAK,UAAU,MAAM;;AAG9B,KAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,SAAO,KAAK,UAAU,MAAM;;AAG9B,KAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,SAAO,IAAI,KAAK,UAAU,MAAM,CAAC;;AAGnC,QAAO;;AAGT,OAAO,MAAM,6BAA6B,UACxC,YAAY,MAAM,KAAK;AAEzB,OAAO,MAAM,oBAAoB,UAA4B;AAC3D,KAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,SAAO,MAAM,KAAK,SAAS,iBAAiB,KAAK,CAAC;;AAGpD,KAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,SAAO,OAAO,YACZ,OAAO,QAAQ,MAAM,CAAC,KAAK,CAAC,KAAK,UAAU,CAAC,KAAK,iBAAiB,KAAK,CAAC,CAAC,CAC1E;;AAGH,QAAO;;AAGT,MAAM,aAAa,KAAK;AACxB,MAAM,iBAAiB,KAAK;AAE5B,MAAM,WAAW,UAA0B;AACzC,KAAI,CAAC,OAAO,SAAS,MAAM,IAAI,UAAU,GAAG;AAC1C,SAAO;;CAGT,MAAM,UAAU,KAAK,KAAK,MAAM,GAAG,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC;CAC9D,MAAM,YAAa,UAAU,aAAc,cAAc;AAEzD,QAAO,YAAY,iBAAiB,WAAW,aAAa;;AAG9D,MAAM,cAAc,UAA0B,CAAC,QAAQ,MAAM,GAAG;AAEhE,MAAM,mBACJ,aACA,aACwB;AACxB,KACE,gBAAgB,QAChB,gBAAgB,aACf,OAAO,gBAAgB,YACtB,OAAO,gBAAgB,YACvB,OAAO,gBAAgB,YACvB,OAAO,gBAAgB,WACzB;AACA,SAAO;;AAGT,QAAQ,YAAiD;;AAK3D,MAAM,yBAAyB,OAAO,8BAA8B;AAMpE,MAAM,4BACJ,UAEA,OAAO,UAAU,YACjB,UAAU,QACV,0BAA0B;AAE5B,MAAM,gCAAgC,UACpC,yBAAyB,MAAM,GAAG,MAAM,0BAA0B;AAEpE,OAAO,MAAM,gCACX,WAC4B,GAC3B,yBAAyB,OAC3B;AAED,MAAM,sBACJ,SACA,OACA,KACA,KACA,UACY;AACZ,KAAI,QAAQ,SAAS,cAAc;AACjC,MAAI,IAAI,QAAQ,MAAM,MAAM;AAC5B,SAAO;;AAGT,KAAI,QAAQ,SAAS,qBAAqB;AACxC,SAAO,mBACL,QAAQ,MACR,UAAU,YACN,eAAe,QAAQ,OAAO,KAAK,KAAK,MAAM,GAC9C,OACJ,KACA,KACA,MACD;;AAGH,KAAI,QAAQ,SAAS,iBAAiB;AACpC,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,UAAO;;AAGT,SAAO,QAAQ,WAAW,OAAO,aAAa;AAC5C,OAAI,SAAS,SAAS,eAAe;AACnC,WAAO;;GAGT,IAAI;AACJ,OAAI,SAAS,UAAU;AACrB,UAAM,eAAe,SAAS,KAAmB,KAAK,KAAK,MAAM;cACxD,SAAS,IAAI,SAAS,cAAc;AAC7C,UAAM,SAAS,IAAI;cACV,SAAS,IAAI,SAAS,WAAW;AAC1C,UAAM,SAAS,IAAI;;AAErB,OAAI,QAAQ,aAAa,QAAQ,MAAM;AACrC,WAAO;;AAGT,UAAO,mBACL,SAAS,OACT,gBAAgB,OAAO,IAAuB,EAC9C,KACA,KACA,MACD;IACD;;AAGJ,KAAI,QAAQ,SAAS,gBAAgB;AACnC,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO;;AAGT,SAAO,QAAQ,SAAS,OAAO,SAAS,UACtC,UACI,mBAAmB,SAAS,MAAM,QAAQ,KAAK,KAAK,MAAM,GAC1D,KACL;;AAGH,QAAO;;AAGT,MAAM,qBACJ,aACA,WACA,UACA,KACA,KACA,UACwB;CACxB,MAAM,eAAe,SAAwD;AAC3E,MAAI,KAAK,SAAS,cAAc;AAC9B,UAAO,KAAK,SAAS,cAAc,EAAE,MAAM,EAAE,EAAE,GAAG;;AAGpD,MAAI,KAAK,SAAS,oBAAoB;AACpC,UAAO;;EAGT,MAAM,SAAS,YAAY,KAAK,OAAO;AACvC,MAAI,CAAC,QAAQ;AACX,UAAO;;EAGT,IAAI;AACJ,MAAI,KAAK,UAAU;AACjB,SAAM,eAAe,KAAK,UAAwB,KAAK,KAAK,MAAM;aACzD,KAAK,SAAS,SAAS,cAAc;AAC9C,SAAM,KAAK,SAAS;;AAEtB,MACE,QAAQ,aACR,QAAQ,QACP,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAC3C;AACA,UAAO;;AAGT,SAAO,EACL,MAAM,CAAC,GAAG,OAAO,MAAM,IAAI,EAC5B;;CAGH,MAAM,WAAW,YACf,SAAS,SAAS,yBAAyB,SAAS,OAAO,SAAS,SACrE;AACD,KAAI,CAAC,UAAU;AACb,SAAO;;CAGT,MAAM,SAAS,iBAAiB,UAAU;AAC1C,KAAI,SAAS,KAAK,WAAW,GAAG;AAC9B,MAAI,SAAS,SAAS,wBAAwB;AAC5C,UAAO;;AAGT,SAAO,eAAe,SAAS,OAAO,KAAK,KAAK,MAAM;;CAGxD,IAAI,SAAS;AACb,MAAK,IAAI,MAAM,GAAG,MAAM,SAAS,KAAK,SAAS,GAAG,OAAO,GAAG;EAC1D,MAAM,MAAM,SAAS,KAAK;EAC1B,MAAM,OAAO,SAAS;AACtB,MAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC7C,UAAO;;AAGT,WAAS;;CAGX,MAAM,UAAU,SAAS,KAAK,SAAS,KAAK,SAAS;AACrD,KAAI,SAAS,SAAS,wBAAwB;EAC5C,MAAM,YAAY,eAAe,SAAS,OAAO,KAAK,KAAK,MAAM;AACjE,MAAI,cAAc,WAAW;AAC3B,UAAO;;AAGT,SAAO,WAAW;AAClB,SAAO;;CAGT,MAAM,eAAe,OAAO;AAC5B,KAAI,OAAO,iBAAiB,UAAU;AACpC,SAAO;;AAGT,QAAO,WACL,SAAS,aAAa,OAAO,eAAe,IAAI,eAAe;AACjE,QAAO;;AAGT,MAAM,wBACJ,IACA,MACA,KACA,KACA,UACwB;AACxB,KAAI,GAAG,SAAS,CAAC,GAAG,MAAM;AACxB,SAAO;;CAGT,MAAM,WAAW,IAAI,IAAI,IAAI;AAC7B,MAAK,IAAI,MAAM,GAAG,MAAM,GAAG,OAAO,QAAQ,OAAO,GAAG;AAClD,MAAI,CAAC,mBAAmB,GAAG,OAAO,MAAM,KAAK,MAAM,KAAK,UAAU,MAAM,EAAE;AACxE,UAAO;;;AAIX,KAAI,GAAG,KAAK,SAAS,kBAAkB;AACrC,SAAO,eAAe,GAAG,MAAoB,KAAK,UAAU,MAAM;;AAGpE,MAAK,MAAM,aAAa,GAAG,KAAK,MAAM;AACpC,MAAI,UAAU,SAAS,uBAAuB;AAC5C,QAAK,MAAM,cAAc,UAAU,cAAc;IAC/C,MAAM,QAAQ,WAAW,OACrB,eAAe,WAAW,MAAM,KAAK,UAAU,MAAM,GACrD;AACJ,QAAI,CAAC,mBAAmB,WAAW,IAAI,OAAO,KAAK,UAAU,MAAM,EAAE;AACnE,YAAO;;;AAGX;;AAGF,MAAI,UAAU,SAAS,mBAAmB;AACxC,OAAI,CAAC,UAAU,UAAU;AACvB,WAAO;;AAGT,UAAO,eAAe,UAAU,UAAU,KAAK,UAAU,MAAM;;AAGjE,SAAO;;AAGT,QAAO;;AAGT,MAAM,sBAAsB,SAAwB;AAClD,KAAI,KAAK,SAAS,sBAAsB,KAAK,UAAU;AACrD,SAAO;;AAGT,KAAI,KAAK,SAAS,SAAS,gBAAgB,KAAK,SAAS,SAAS,OAAO;AACvE,SAAO;;AAGT,QAAO,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS;;AAGnE,MAAM,2BACJ,YACA,QAEA,WAAW,SAAS,sBACpB,mBAAmB,WAAW,OAAO,IACrC,CAAC,IAAI,IAAI,UAAU;AAErB,MAAM,sCACJ,YACA,KACA,QACY;AACZ,KAAI,wBAAwB,YAAY,IAAI,EAAE;AAC5C,SAAO;;AAGT,KAAI,WAAW,SAAS,qBAAqB,WAAW,aAAa,QAAQ;AAC3E,SAAO;;AAGT,QACE,WAAW,SAAS,gBACpB,WAAW,SAAS,eACpB,CAAC,iBAAiB,KAAK,WAAW,MAAM,WAAW,MAAM;;AAI7D,MAAM,kBACJ,YACA,KACA,MAAe,IAAI,KAAK,EACxB,QAAkB,EAAE,KACI;AACxB,KAAI,WAAW,SAAS,oBAAoB;AAC1C,SAAO;;CAGT,MAAM,OAAO,eAAe,WAAW,MAAoB,KAAK,KAAK,MAAM;CAC3E,MAAM,QAAQ,eAAe,WAAW,OAAqB,KAAK,KAAK,MAAM;CAE7E,MAAM,+BACJ,SAAS,aACT,mCAAmC,WAAW,MAAoB,KAAK,IAAI;CAC7E,MAAM,gCACJ,UAAU,aACV,mCACE,WAAW,OACX,KACA,IACD;AAEH,KACG,SAAS,aAAa,CAAC,gCACvB,UAAU,aAAa,CAAC,+BACzB;AACA,SAAO;;AAGT,SAAQ,WAAW,UAAnB;EACE,KAAK,MACH,QAAO,SAAS;EAClB,KAAK,MACH,QAAO,SAAS;EAClB,KAAK;;AAEH,SAAO,QAAQ;EACjB,KAAK;;AAEH,SAAO,QAAQ;EACjB,QACE;;AAGJ,KAAI,WAAW,aAAa,KAAK;AAC/B,MAAI,OAAO,SAAS,YAAY,OAAO,UAAU,UAAU;AACzD,UAAO,OAAO;;AAGhB,OACG,OAAO,SAAS,YAAY,OAAO,SAAS,cAC5C,OAAO,UAAU,YAAY,OAAO,UAAU,WAC/C;AACA,UAAO,GAAG,OAAO;;;AAIrB,KAAI,OAAO,SAAS,YAAY,OAAO,UAAU,UAAU;AACzD,UAAQ,WAAW,UAAnB;GACE,KAAK,IACH,QAAO,OAAO;GAChB,KAAK,KACH,QAAO,QAAQ;GACjB,KAAK,IACH,QAAO,OAAO;GAChB,KAAK,KACH,QAAO,QAAQ;GACjB,KAAK,IACH,QAAO,OAAO;GAChB,KAAK,IACH,QAAO,OAAO;GAChB,KAAK,IACH,QAAO,OAAO;GAChB,KAAK,IACH,QAAO,OAAO;GAChB,KAAK,KACH,QAAO,QAAQ;GACjB,QACE;;;AAIN,QAAO;;AAGT,OAAO,MAAM,kBACX,YACA,KACA,MAAe,IAAI,KAAK,EACxB,QAAkB,EAAE,KACI;AACxB,KACE,WAAW,SAAS,oBACpB,WAAW,SAAS,2BACpB,WAAW,SAAS,yBACpB,WAAW,SAAS,+BACpB,WAAW,SAAS,qBACpB,WAAW,SAAS,2BACpB;AACA,SAAO,eAAe,WAAW,YAA0B,KAAK,KAAK,MAAM;;AAG7E,KAAI,WAAW,SAAS,WAAW;AACjC,SAAO,WAAW;;AAGpB,KAAI,WAAW,SAAS,mBAAmB;AACzC,MAAI,WAAW,aAAa,UAAU;GACpC,MAAM,wBAAwB,wBAC5B,WAAW,UACX,IACD;;;;;GAKD,MAAM,6BACJ,WAAW,SAAS,SAAS,gBAC7B,CAAC,iBACC,KACA,WAAW,SAAS,MACpB,WAAW,SAAS,MACrB;GACH,MAAM,MAAM,eACV,WAAW,UACX,KACA,KACA,MACD;AACD,OAAI,QAAQ,WAAW;AACrB,WAAO,yBAAyB,6BAC5B,cACA;;AAGN,UAAO,OAAO;;EAGhB,MAAM,MAAM,eACV,WAAW,UACX,KACA,KACA,MACD;AACD,MAAI,QAAQ,WAAW;AACrB,UAAO;;AAGT,UAAQ,WAAW,UAAnB;GACE,KAAK,IACH,QAAO,OAAO,QAAQ,WAAW,CAAC,MAAM;GAC1C,KAAK,IACH,QAAO,OAAO,QAAQ,WAAW,CAAC,MAAM;GAC1C,KAAK,IACH,QAAO,CAAC;GACV,KAAK,IACH,QAAO,OAAO,QAAQ,WAAW,WAAW,IAAI,GAAG;GACrD,KAAK,OACH,QAAO;GACT,QACE,QAAO;;;AAIb,KAAI,WAAW,SAAS,qBAAqB;EAC3C,MAAM,OAAO,eAAe,WAAW,MAAM,KAAK,KAAK,MAAM;;;;;EAK7D,MAAM,yBAAyB,wBAC7B,WAAW,MACX,IACD;AAED,MAAI,SAAS,aAAa,CAAC,wBAAwB;AACjD,UAAO;;AAGT,MAAI,WAAW,aAAa,MAAM;AAChC,UAAO,QAAQ,eAAe,WAAW,OAAO,KAAK,KAAK,MAAM;;AAGlE,MAAI,WAAW,aAAa,MAAM;AAChC,UAAO,QAAQ,eAAe,WAAW,OAAO,KAAK,KAAK,MAAM;;AAGlE,MAAI,WAAW,aAAa,MAAM;AAChC,UAAO,QAAQ,eAAe,WAAW,OAAO,KAAK,KAAK,MAAM;;AAGlE,SAAO;;AAGT,KAAI,WAAW,SAAS,yBAAyB;EAC/C,MAAM,OAAO,eAAe,WAAW,MAAM,KAAK,KAAK,MAAM;AAC7D,MAAI,SAAS,WAAW;AACtB,UAAO;;AAGT,SAAO,eACL,OAAO,WAAW,aAAa,WAAW,WAC1C,KACA,KACA,MACD;;AAGH,KAAI,WAAW,SAAS,mBAAmB;EACzC,IAAI,SAAS;AAEb,OAAK,IAAI,MAAM,GAAG,MAAM,WAAW,OAAO,QAAQ,OAAO,GAAG;AAC1D,aAAU,WAAW,OAAO,MAAM,MAAM,UAAU;GAElD,MAAM,iBAAiB,WAAW,YAAY;AAC9C,OAAI,CAAC,gBAAgB;AACnB;;GAGF,MAAM,QAAQ,eAAe,gBAAgB,KAAK,KAAK,MAAM;AAC7D,OACE,UAAU,aACT,OAAO,UAAU,YAAY,OAAO,UAAU,UAC/C;AACA,WAAO;;AAGT,aAAU,OAAO,MAAM;;AAGzB,SAAO;;AAGT,KAAI,WAAW,SAAS,cAAc;AACpC,MAAI,IAAI,IAAI,WAAW,KAAK,EAAE;AAC5B,UAAO,6BAA6B,IAAI,IAAI,WAAW,KAAK,CAAC;;EAG/D,MAAM,UAAU,iBAAiB,KAAK,WAAW,MAAM,WAAW,MAAM;AACxE,MAAI,SAAS,cAAc;;;;GAIzB,MAAM,WAAW,oBACf,IAAI,gBACJ,QAAQ,cACR,QAAQ,SACT;AACD,OAAI,SAAS,SAAS,OAAO,SAAS,UAAU,YAAY;AAC1D,WAAO,SAAS;;AAElB,UAAO;;AAET,MAAI,CAAC,SAAS;AACZ,UAAO;;AAGT,MAAI,QAAQ,SAAS,SAAS;AAC5B,UAAO;;AAGT,MAAI,MAAM,SAAS,QAAQ,KAAK,EAAE;AAChC,UAAO;;EAGT,IAAI;EACJ,MAAM,EAAE,eAAe;EACvB,MAAM,OAAO,YAAY;AACzB,MAAI,MAAM;AACR,OAAI,WAAW,GAAG,SAAS,cAAc;AACvC,WAAO;;AAGT,WAAQ,eAAe,MAAM,KAAK,KAAK,CAAC,GAAG,OAAO,QAAQ,KAAK,CAAC;aACvD,QAAQ,cAAc;AAC/B,WAAQ,QAAQ;;AAGlB,MACE,UAAU,aACV,QAAQ,UACR,OAAO,UAAU,YACjB,UAAU,QACV,CAAC,MAAM,QAAQ,MAAM,EACrB;GACA,MAAM,YAAY,IAAI,uBAAuB,IAAI,QAAQ,KAAK,IAAI,EAAE;GACpE,IAAI,YAAY,iBAAiB,MAAM;AACvC,QAAK,MAAM,YAAY,WAAW;AAChC,QAAI,SAAS,SAAS,IAAI,wBAAwB;AAChD;;IAGF,MAAM,UAAU,kBACd,QAAQ,MACR,WACA,UACA,KACA,KACA,CAAC,GAAG,OAAO,QAAQ,KAAK,CACzB;AACD,QAAI,YAAY,WAAW;AACzB,YAAO;;AAGT,gBAAY;;AAGd,UAAO;;AAGT,SAAO;;AAGT,KAAI,WAAW,SAAS,oBAAoB;EAC1C,MAAM,SAAkC,EAAE;AAE1C,OAAK,MAAM,YAAY,WAAW,YAAY;AAC5C,OAAI,SAAS,SAAS,iBAAiB;IACrC,MAAM,cAAc,eAAe,SAAS,UAAU,KAAK,KAAK,MAAM;AACtE,QAAI,OAAO,gBAAgB,YAAY,gBAAgB,MAAM;AAC3D,YAAO;;AAGT,WAAO,OAAO,QAAQ,YAAY;AAClC;;GAGF,IAAI;AACJ,OAAI,SAAS,UAAU;AACrB,UAAM,eAAe,SAAS,KAAmB,KAAK,KAAK,MAAM;cACxD,SAAS,IAAI,SAAS,cAAc;AAC7C,UAAM,SAAS,IAAI;cACV,SAAS,IAAI,SAAS,WAAW;AAC1C,UAAM,SAAS,IAAI;;AAErB,OACE,QAAQ,aACR,QAAQ,QACP,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAC3C;AACA,WAAO;;GAGT,MAAM,QAAQ,eAAe,SAAS,OAAO,KAAK,KAAK,MAAM;AAC7D,OAAI,UAAU,WAAW;AACvB,WAAO;;AAGT,UAAO,OAAO;;AAGhB,SAAO;;AAGT,KAAI,WAAW,SAAS,mBAAmB;EACzC,MAAM,SAAoB,EAAE;AAE5B,OAAK,MAAM,WAAW,WAAW,UAAU;AACzC,OAAI,CAAC,SAAS;AACZ,WAAO;;AAGT,OAAI,QAAQ,SAAS,iBAAiB;IACpC,MAAM,cAAc,eAAe,QAAQ,UAAU,KAAK,KAAK,MAAM;AACrE,QAAI,CAAC,MAAM,QAAQ,YAAY,EAAE;AAC/B,YAAO;;AAGT,WAAO,KAAK,GAAG,YAAY;AAC3B;;GAGF,MAAM,QAAQ,eAAe,SAAS,KAAK,KAAK,MAAM;AACtD,OAAI,UAAU,WAAW;AACvB,WAAO;;AAGT,UAAO,KAAK,MAAM;;AAGpB,SAAO;;AAGT,KAAI,WAAW,SAAS,oBAAoB;EAC1C,IAAI;AACJ,MAAI,WAAW,UAAU;AACvB,SAAM,eAAe,WAAW,UAAwB,KAAK,KAAK,MAAM;aAC/D,WAAW,SAAS,SAAS,cAAc;AACpD,SAAM,WAAW,SAAS;;AAE5B,MACE,QAAQ,aACR,QAAQ,QACP,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAC3C;AACA,UAAO;;AAGT,MAAI,wBAAwB,YAAY,IAAI,IAAI,OAAO,QAAQ,UAAU;;;;;AAKvE,UAAO;;EAGT,MAAM,cAAc,eAAe,WAAW,QAAQ,KAAK,KAAK,MAAM;AACtE,MAAI,gBAAgB,WAAW;AAC7B,UAAO;;AAGT,SAAO,gBAAgB,aAAa,IAAI;;AAG1C,KAAI,WAAW,SAAS,iBAAiB;AACvC,MACE,WAAW,OAAO,SAAS,gBAC3B,WAAW,UAAU,WAAW,GAChC;AACA,UAAO;;EAGT,MAAM,CAAC,YAAY,WAAW;AAC9B,MAAI,CAAC,YAAY,SAAS,SAAS,iBAAiB;AAClD,UAAO;;EAGT,MAAM,QAAQ,eAAe,UAAU,KAAK,KAAK,MAAM;AACvD,MAAI,UAAU,WAAW;AACvB,UAAO;;AAGT,MAAI,WAAW,OAAO,SAAS,UAAU;AACvC,UAAO,OAAO,MAAM;;AAGtB,MAAI,WAAW,OAAO,SAAS,UAAU;AACvC,UAAO,OAAO,MAAM;;AAGtB,MAAI,WAAW,OAAO,SAAS,WAAW;AACxC,UAAO,QAAQ,MAAM;;AAGvB,SAAO;;AAGT,KAAI,WAAW,SAAS,kBAAkB;AACxC,MAAI,WAAW,OAAO,SAAS,cAAc;GAC3C,MAAM,OAAO,WAAW,UAAU,KAAK,QACrC,IAAI,SAAS,kBACT,YACA,eAAe,KAAK,KAAK,KAAK,MAAM,CACzC;AACD,OAAI,KAAK,MAAM,UAAU,UAAU,UAAU,EAAE;AAC7C,WAAO;;GAGT,MAAM,iBAAiB,IAAI,IAAI,WAAW,OAAO,KAAK;AACtD,OACE,yBAAyB,eAAe,IACxC,WAAW,UAAU,WAAW,GAChC;AACA,WAAO,6BAA6B,eAAe;;;;AAKrD,OAAI,OAAO,mBAAmB,YAAY;AACxC,QAAI;AACF,YAAQ,eAAgD,GAAG,KAAK;YAC1D;AACN,YAAO;;;AAIX,OAAI,WAAW,OAAO,SAAS,YAAY,KAAK,WAAW,GAAG;AAC5D,WAAO,OAAO,KAAK,GAAG;;AAGxB,OAAI,WAAW,OAAO,SAAS,YAAY,KAAK,WAAW,GAAG;AAC5D,WAAO,OAAO,KAAK,GAAG;;AAGxB,OAAI,WAAW,OAAO,SAAS,aAAa,KAAK,WAAW,GAAG;AAC7D,WAAO,QAAQ,KAAK,GAAG;;GAGzB,MAAM,UAAU,iBACd,KACA,WAAW,OAAO,MAClB,WAAW,OAAO,MACnB;;;;;AAMD,OAAI,SAAS,cAAc;IACzB,MAAM,WAAW,oBACf,IAAI,gBACJ,QAAQ,cACR,QAAQ,SACT;AACD,QAAI,SAAS,SAAS,OAAO,SAAS,UAAU,YAAY;AAC1D,SAAI;AACF,aAAQ,SAAS,MAAuC,GAAG,KAAK;aAC1D;AACN,aAAO;;;;GAKb,MAAM,KAAK,SAAS,gBAAgB,SAAS,YAAY;AACzD,OACE,OACC,GAAG,SAAS,6BACX,GAAG,SAAS,yBACZ,GAAG,SAAS,uBACd;AACA,WAAO,qBAAqB,IAAI,MAAM,KAAK,KAAK,CAC9C,GAAG,OACH,WAAW,OAAO,KACnB,CAAC;;;AAIN,MAAI,WAAW,OAAO,SAAS,oBAAoB;GACjD,MAAM,cAAc,eAClB,WAAW,OAAO,QAClB,KACA,KACA,MACD;GACD,IAAI;AACJ,OAAI,WAAW,OAAO,UAAU;AAC9B,UAAM,eACJ,WAAW,OAAO,UAClB,KACA,KACA,MACD;cACQ,WAAW,OAAO,SAAS,SAAS,cAAc;AAC3D,UAAM,WAAW,OAAO,SAAS;;AAEnC,OAAI,OAAO,gBAAgB,UAAU;AACnC,QAAI,QAAQ,iBAAiB,WAAW,UAAU,WAAW,GAAG;AAC9D,YAAO,YAAY,aAAa;;AAGlC,QAAI,QAAQ,iBAAiB,WAAW,UAAU,WAAW,GAAG;AAC9D,YAAO,YAAY,aAAa;;;;;AAMxC,QAAO,eAAe,YAAY,KAAK,KAAK,MAAM","names":[],"sources":["../../../src/utils/collectOxcTemplateDependencies/staticEvaluator.ts"],"version":3,"sourcesContent":["/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */\n\nimport type {\n  AssignmentExpression,\n  Expression,\n  Node,\n  UpdateExpression,\n} from 'oxc-parser';\n\nimport { lookupStaticBinding } from './staticBindings';\nimport { resolveBindingAt } from './scopeAnalysis';\nimport type { ExtractionContext, OxcFunctionLikeNode } from './types';\n\nexport const literalCode = (value: unknown): string | null => {\n  if (typeof value === 'number') {\n    return Number.isFinite(value) ? JSON.stringify(value) : null;\n  }\n\n  if (\n    value === null ||\n    typeof value === 'string' ||\n    typeof value === 'boolean'\n  ) {\n    return JSON.stringify(value);\n  }\n\n  if (Array.isArray(value)) {\n    return JSON.stringify(value);\n  }\n\n  if (typeof value === 'object' && value !== null) {\n    return `(${JSON.stringify(value)})`;\n  }\n\n  return null;\n};\n\nexport const isStaticSerializableValue = (value: unknown): boolean =>\n  literalCode(value) !== null;\n\nexport const cloneStaticValue = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    return value.map((item) => cloneStaticValue(item));\n  }\n\n  if (typeof value === 'object' && value !== null) {\n    return Object.fromEntries(\n      Object.entries(value).map(([key, item]) => [key, cloneStaticValue(item)])\n    );\n  }\n\n  return value;\n};\n\nconst INT32_SIZE = 2 ** 32;\nconst INT32_SIGN_BIT = 2 ** 31;\n\nconst toInt32 = (value: number): number => {\n  if (!Number.isFinite(value) || value === 0) {\n    return 0;\n  }\n\n  const integer = Math.sign(value) * Math.floor(Math.abs(value));\n  const int32bit = ((integer % INT32_SIZE) + INT32_SIZE) % INT32_SIZE;\n\n  return int32bit >= INT32_SIGN_BIT ? int32bit - INT32_SIZE : int32bit;\n};\n\nconst bitwiseNot = (value: number): number => -toInt32(value) - 1;\n\nconst getObjectMember = (\n  objectValue: unknown,\n  property: string | number\n): unknown | undefined => {\n  if (\n    objectValue === null ||\n    objectValue === undefined ||\n    (typeof objectValue !== 'object' &&\n      typeof objectValue !== 'string' &&\n      typeof objectValue !== 'number' &&\n      typeof objectValue !== 'boolean')\n  ) {\n    return undefined;\n  }\n\n  return (objectValue as Record<string | number, unknown>)[property];\n};\n\ntype EvalEnv = Map<string, unknown>;\n\nconst oxcStaticCallableValue = Symbol('wyw.oxc.staticCallableValue');\n\ntype OxcStaticCallableValue = {\n  [oxcStaticCallableValue]: unknown;\n};\n\nconst isOxcStaticCallableValue = (\n  value: unknown\n): value is OxcStaticCallableValue =>\n  typeof value === 'object' &&\n  value !== null &&\n  oxcStaticCallableValue in value;\n\nconst unwrapOxcStaticCallableValue = (value: unknown): unknown =>\n  isOxcStaticCallableValue(value) ? value[oxcStaticCallableValue] : value;\n\nexport const createOxcStaticCallableValue = (\n  value: unknown\n): OxcStaticCallableValue => ({\n  [oxcStaticCallableValue]: value,\n});\n\nconst assignPatternValue = (\n  pattern: Node,\n  value: unknown,\n  ctx: ExtractionContext,\n  env: EvalEnv,\n  stack: string[]\n): boolean => {\n  if (pattern.type === 'Identifier') {\n    env.set(pattern.name, value);\n    return true;\n  }\n\n  if (pattern.type === 'AssignmentPattern') {\n    return assignPatternValue(\n      pattern.left,\n      value === undefined\n        ? evaluateStatic(pattern.right, ctx, env, stack)\n        : value,\n      ctx,\n      env,\n      stack\n    );\n  }\n\n  if (pattern.type === 'ObjectPattern') {\n    if (typeof value !== 'object' || value === null) {\n      return false;\n    }\n\n    return pattern.properties.every((property) => {\n      if (property.type === 'RestElement') {\n        return false;\n      }\n\n      let key: unknown;\n      if (property.computed) {\n        key = evaluateStatic(property.key as Expression, ctx, env, stack);\n      } else if (property.key.type === 'Identifier') {\n        key = property.key.name;\n      } else if (property.key.type === 'Literal') {\n        key = property.key.value;\n      }\n      if (key === undefined || key === null) {\n        return false;\n      }\n\n      return assignPatternValue(\n        property.value,\n        getObjectMember(value, key as string | number),\n        ctx,\n        env,\n        stack\n      );\n    });\n  }\n\n  if (pattern.type === 'ArrayPattern') {\n    if (!Array.isArray(value)) {\n      return false;\n    }\n\n    return pattern.elements.every((element, index) =>\n      element\n        ? assignPatternValue(element, value[index], ctx, env, stack)\n        : true\n    );\n  }\n\n  return false;\n};\n\nconst applyRootMutation = (\n  bindingName: string,\n  baseValue: unknown,\n  mutation: AssignmentExpression | UpdateExpression,\n  ctx: ExtractionContext,\n  env: EvalEnv,\n  stack: string[]\n): unknown | undefined => {\n  const resolvePath = (node: Node): { path: Array<string | number> } | null => {\n    if (node.type === 'Identifier') {\n      return node.name === bindingName ? { path: [] } : null;\n    }\n\n    if (node.type !== 'MemberExpression') {\n      return null;\n    }\n\n    const parent = resolvePath(node.object);\n    if (!parent) {\n      return null;\n    }\n\n    let key: unknown;\n    if (node.computed) {\n      key = evaluateStatic(node.property as Expression, ctx, env, stack);\n    } else if (node.property.type === 'Identifier') {\n      key = node.property.name;\n    }\n    if (\n      key === undefined ||\n      key === null ||\n      (typeof key !== 'string' && typeof key !== 'number')\n    ) {\n      return null;\n    }\n\n    return {\n      path: [...parent.path, key],\n    };\n  };\n\n  const pathInfo = resolvePath(\n    mutation.type === 'AssignmentExpression' ? mutation.left : mutation.argument\n  );\n  if (!pathInfo) {\n    return undefined;\n  }\n\n  const cloned = cloneStaticValue(baseValue);\n  if (pathInfo.path.length === 0) {\n    if (mutation.type !== 'AssignmentExpression') {\n      return undefined;\n    }\n\n    return evaluateStatic(mutation.right, ctx, env, stack);\n  }\n\n  let target = cloned as Record<string | number, unknown>;\n  for (let idx = 0; idx < pathInfo.path.length - 1; idx += 1) {\n    const key = pathInfo.path[idx];\n    const next = target?.[key];\n    if (typeof next !== 'object' || next === null) {\n      return undefined;\n    }\n\n    target = next as Record<string | number, unknown>;\n  }\n\n  const lastKey = pathInfo.path[pathInfo.path.length - 1]!;\n  if (mutation.type === 'AssignmentExpression') {\n    const nextValue = evaluateStatic(mutation.right, ctx, env, stack);\n    if (nextValue === undefined) {\n      return undefined;\n    }\n\n    target[lastKey] = nextValue;\n    return cloned;\n  }\n\n  const currentValue = target[lastKey];\n  if (typeof currentValue !== 'number') {\n    return undefined;\n  }\n\n  target[lastKey] =\n    mutation.operator === '++' ? currentValue + 1 : currentValue - 1;\n  return cloned;\n};\n\nconst evaluateFunctionCall = (\n  fn: OxcFunctionLikeNode,\n  args: unknown[],\n  ctx: ExtractionContext,\n  env: EvalEnv,\n  stack: string[]\n): unknown | undefined => {\n  if (fn.async || !fn.body) {\n    return undefined;\n  }\n\n  const localEnv = new Map(env);\n  for (let idx = 0; idx < fn.params.length; idx += 1) {\n    if (!assignPatternValue(fn.params[idx], args[idx], ctx, localEnv, stack)) {\n      return undefined;\n    }\n  }\n\n  if (fn.body.type !== 'BlockStatement') {\n    return evaluateStatic(fn.body as Expression, ctx, localEnv, stack);\n  }\n\n  for (const statement of fn.body.body) {\n    if (statement.type === 'VariableDeclaration') {\n      for (const declarator of statement.declarations) {\n        const value = declarator.init\n          ? evaluateStatic(declarator.init, ctx, localEnv, stack)\n          : undefined;\n        if (!assignPatternValue(declarator.id, value, ctx, localEnv, stack)) {\n          return undefined;\n        }\n      }\n      continue;\n    }\n\n    if (statement.type === 'ReturnStatement') {\n      if (!statement.argument) {\n        return undefined;\n      }\n\n      return evaluateStatic(statement.argument, ctx, localEnv, stack);\n    }\n\n    return undefined;\n  }\n\n  return undefined;\n};\n\nconst isProcessEnvMember = (node: Node): boolean => {\n  if (node.type !== 'MemberExpression' || node.computed) {\n    return false;\n  }\n\n  if (node.property.type !== 'Identifier' || node.property.name !== 'env') {\n    return false;\n  }\n\n  return node.object.type === 'Identifier' && node.object.name === 'process';\n};\n\nconst isProcessEnvValueAccess = (\n  expression: Expression,\n  env: EvalEnv\n): boolean =>\n  expression.type === 'MemberExpression' &&\n  isProcessEnvMember(expression.object) &&\n  !env.has('process');\n\nconst isDeterministicUndefinedExpression = (\n  expression: Expression,\n  ctx: ExtractionContext,\n  env: EvalEnv\n): boolean => {\n  if (isProcessEnvValueAccess(expression, env)) {\n    return true;\n  }\n\n  if (expression.type === 'UnaryExpression' && expression.operator === 'void') {\n    return true;\n  }\n\n  return (\n    expression.type === 'Identifier' &&\n    expression.name === 'undefined' &&\n    !resolveBindingAt(ctx, expression.name, expression.start)\n  );\n};\n\nconst evaluateBinary = (\n  expression: Expression,\n  ctx: ExtractionContext,\n  env: EvalEnv = new Map(),\n  stack: string[] = []\n): unknown | undefined => {\n  if (expression.type !== 'BinaryExpression') {\n    return undefined;\n  }\n\n  const left = evaluateStatic(expression.left as Expression, ctx, env, stack);\n  const right = evaluateStatic(expression.right as Expression, ctx, env, stack);\n\n  const leftIsDeterministicUndefined =\n    left === undefined &&\n    isDeterministicUndefinedExpression(expression.left as Expression, ctx, env);\n  const rightIsDeterministicUndefined =\n    right === undefined &&\n    isDeterministicUndefinedExpression(\n      expression.right as Expression,\n      ctx,\n      env\n    );\n\n  if (\n    (left === undefined && !leftIsDeterministicUndefined) ||\n    (right === undefined && !rightIsDeterministicUndefined)\n  ) {\n    return undefined;\n  }\n\n  switch (expression.operator) {\n    case '===':\n      return left === right;\n    case '!==':\n      return left !== right;\n    case '==':\n      // eslint-disable-next-line eqeqeq\n      return left == right;\n    case '!=':\n      // eslint-disable-next-line eqeqeq\n      return left != right;\n    default:\n      break;\n  }\n\n  if (expression.operator === '+') {\n    if (typeof left === 'number' && typeof right === 'number') {\n      return left + right;\n    }\n\n    if (\n      (typeof left === 'string' || typeof left === 'number') &&\n      (typeof right === 'string' || typeof right === 'number')\n    ) {\n      return `${left}${right}`;\n    }\n  }\n\n  if (typeof left === 'number' && typeof right === 'number') {\n    switch (expression.operator) {\n      case '<':\n        return left < right;\n      case '<=':\n        return left <= right;\n      case '>':\n        return left > right;\n      case '>=':\n        return left >= right;\n      case '-':\n        return left - right;\n      case '*':\n        return left * right;\n      case '/':\n        return left / right;\n      case '%':\n        return left % right;\n      case '**':\n        return left ** right;\n      default:\n        break;\n    }\n  }\n\n  return undefined;\n};\n\nexport const evaluateStatic = (\n  expression: Expression,\n  ctx: ExtractionContext,\n  env: EvalEnv = new Map(),\n  stack: string[] = []\n): unknown | undefined => {\n  if (\n    expression.type === 'TSAsExpression' ||\n    expression.type === 'TSSatisfiesExpression' ||\n    expression.type === 'TSNonNullExpression' ||\n    expression.type === 'TSInstantiationExpression' ||\n    expression.type === 'TSTypeAssertion' ||\n    expression.type === 'ParenthesizedExpression'\n  ) {\n    return evaluateStatic(expression.expression as Expression, ctx, env, stack);\n  }\n\n  if (expression.type === 'Literal') {\n    return expression.value;\n  }\n\n  if (expression.type === 'UnaryExpression') {\n    if (expression.operator === 'typeof') {\n      const argIsProcessEnvAccess = isProcessEnvValueAccess(\n        expression.argument as Expression,\n        env\n      );\n      // `typeof someIdentifier` is the canonical undeclared-global\n      // probe — it returns 'undefined' regardless of whether the\n      // symbol is declared. Only fold truly unbound identifiers: declared\n      // but dynamic locals still have runtime values we cannot infer.\n      const argIsUnboundBareIdentifier =\n        expression.argument.type === 'Identifier' &&\n        !resolveBindingAt(\n          ctx,\n          expression.argument.name,\n          expression.argument.start\n        );\n      const arg = evaluateStatic(\n        expression.argument as Expression,\n        ctx,\n        env,\n        stack\n      );\n      if (arg === undefined) {\n        return argIsProcessEnvAccess || argIsUnboundBareIdentifier\n          ? 'undefined'\n          : undefined;\n      }\n\n      return typeof arg;\n    }\n\n    const arg = evaluateStatic(\n      expression.argument as Expression,\n      ctx,\n      env,\n      stack\n    );\n    if (arg === undefined) {\n      return undefined;\n    }\n\n    switch (expression.operator) {\n      case '-':\n        return typeof arg === 'number' ? -arg : undefined;\n      case '+':\n        return typeof arg === 'number' ? +arg : undefined;\n      case '!':\n        return !arg;\n      case '~':\n        return typeof arg === 'number' ? bitwiseNot(arg) : undefined;\n      case 'void':\n        return undefined;\n      default:\n        return undefined;\n    }\n  }\n\n  if (expression.type === 'LogicalExpression') {\n    const left = evaluateStatic(expression.left, ctx, env, stack);\n    // process.env.X access is the only source we trust as \"deterministically\n    // undefined\" — it's a build-time lookup we control. For everything else,\n    // undefined means \"couldn't evaluate\" and we must bail to avoid inlining\n    // a wrong fallback when the runtime value isn't actually nullish.\n    const leftIsProcessEnvAccess = isProcessEnvValueAccess(\n      expression.left,\n      env\n    );\n\n    if (left === undefined && !leftIsProcessEnvAccess) {\n      return undefined;\n    }\n\n    if (expression.operator === '||') {\n      return left || evaluateStatic(expression.right, ctx, env, stack);\n    }\n\n    if (expression.operator === '??') {\n      return left ?? evaluateStatic(expression.right, ctx, env, stack);\n    }\n\n    if (expression.operator === '&&') {\n      return left && evaluateStatic(expression.right, ctx, env, stack);\n    }\n\n    return undefined;\n  }\n\n  if (expression.type === 'ConditionalExpression') {\n    const test = evaluateStatic(expression.test, ctx, env, stack);\n    if (test === undefined) {\n      return undefined;\n    }\n\n    return evaluateStatic(\n      test ? expression.consequent : expression.alternate,\n      ctx,\n      env,\n      stack\n    );\n  }\n\n  if (expression.type === 'TemplateLiteral') {\n    let result = '';\n\n    for (let idx = 0; idx < expression.quasis.length; idx += 1) {\n      result += expression.quasis[idx]?.value.cooked ?? '';\n\n      const nextExpression = expression.expressions[idx];\n      if (!nextExpression) {\n        continue;\n      }\n\n      const value = evaluateStatic(nextExpression, ctx, env, stack);\n      if (\n        value === undefined ||\n        (typeof value !== 'string' && typeof value !== 'number')\n      ) {\n        return undefined;\n      }\n\n      result += String(value);\n    }\n\n    return result;\n  }\n\n  if (expression.type === 'Identifier') {\n    if (env.has(expression.name)) {\n      return unwrapOxcStaticCallableValue(env.get(expression.name));\n    }\n\n    const binding = resolveBindingAt(ctx, expression.name, expression.start);\n    if (binding?.importedFrom) {\n      // staticBindings can supply a literal value for an imported name,\n      // bypassing whatever the source module would otherwise resolve to.\n      // Function values are deferred to the CallExpression branch.\n      const override = lookupStaticBinding(\n        ctx.staticBindings,\n        binding.importedFrom,\n        binding.imported\n      );\n      if (override.found && typeof override.value !== 'function') {\n        return override.value;\n      }\n      return undefined;\n    }\n    if (!binding) {\n      return undefined;\n    }\n\n    if (binding.kind === 'param') {\n      return undefined;\n    }\n\n    if (stack.includes(binding.name)) {\n      return undefined;\n    }\n\n    let value: unknown | undefined;\n    const { declarator } = binding;\n    const init = declarator?.init;\n    if (init) {\n      if (declarator.id.type !== 'Identifier') {\n        return undefined;\n      }\n\n      value = evaluateStatic(init, ctx, env, [...stack, binding.name]);\n    } else if (binding.functionNode) {\n      value = binding.functionNode;\n    }\n\n    if (\n      value !== undefined &&\n      binding.isRoot &&\n      typeof value === 'object' &&\n      value !== null &&\n      !Array.isArray(value)\n    ) {\n      const mutations = ctx.rootMutationsByBinding.get(binding.name) ?? [];\n      let nextValue = cloneStaticValue(value);\n      for (const mutation of mutations) {\n        if (mutation.start >= ctx.currentExpressionStart) {\n          break;\n        }\n\n        const applied = applyRootMutation(\n          binding.name,\n          nextValue,\n          mutation,\n          ctx,\n          env,\n          [...stack, binding.name]\n        );\n        if (applied === undefined) {\n          return undefined;\n        }\n\n        nextValue = applied;\n      }\n\n      return nextValue;\n    }\n\n    return value;\n  }\n\n  if (expression.type === 'ObjectExpression') {\n    const result: Record<string, unknown> = {};\n\n    for (const property of expression.properties) {\n      if (property.type === 'SpreadElement') {\n        const spreadValue = evaluateStatic(property.argument, ctx, env, stack);\n        if (typeof spreadValue !== 'object' || spreadValue === null) {\n          return undefined;\n        }\n\n        Object.assign(result, spreadValue);\n        continue;\n      }\n\n      let key: unknown;\n      if (property.computed) {\n        key = evaluateStatic(property.key as Expression, ctx, env, stack);\n      } else if (property.key.type === 'Identifier') {\n        key = property.key.name;\n      } else if (property.key.type === 'Literal') {\n        key = property.key.value;\n      }\n      if (\n        key === undefined ||\n        key === null ||\n        (typeof key !== 'string' && typeof key !== 'number')\n      ) {\n        return undefined;\n      }\n\n      const value = evaluateStatic(property.value, ctx, env, stack);\n      if (value === undefined) {\n        return undefined;\n      }\n\n      result[key] = value;\n    }\n\n    return result;\n  }\n\n  if (expression.type === 'ArrayExpression') {\n    const result: unknown[] = [];\n\n    for (const element of expression.elements) {\n      if (!element) {\n        return undefined;\n      }\n\n      if (element.type === 'SpreadElement') {\n        const spreadValue = evaluateStatic(element.argument, ctx, env, stack);\n        if (!Array.isArray(spreadValue)) {\n          return undefined;\n        }\n\n        result.push(...spreadValue);\n        continue;\n      }\n\n      const value = evaluateStatic(element, ctx, env, stack);\n      if (value === undefined) {\n        return undefined;\n      }\n\n      result.push(value);\n    }\n\n    return result;\n  }\n\n  if (expression.type === 'MemberExpression') {\n    let key: unknown;\n    if (expression.computed) {\n      key = evaluateStatic(expression.property as Expression, ctx, env, stack);\n    } else if (expression.property.type === 'Identifier') {\n      key = expression.property.name;\n    }\n    if (\n      key === undefined ||\n      key === null ||\n      (typeof key !== 'string' && typeof key !== 'number')\n    ) {\n      return undefined;\n    }\n\n    if (isProcessEnvValueAccess(expression, env) && typeof key === 'string') {\n      // Treat process.env.X as deterministically undefined at build time.\n      // Reading from real process.env would couple the bundle to whatever\n      // happens to be set on the build machine; falling back to the\n      // ?? / || branch (or a runtime read) is more predictable.\n      return undefined;\n    }\n\n    const objectValue = evaluateStatic(expression.object, ctx, env, stack);\n    if (objectValue === undefined) {\n      return undefined;\n    }\n\n    return getObjectMember(objectValue, key);\n  }\n\n  if (expression.type === 'NewExpression') {\n    if (\n      expression.callee.type !== 'Identifier' ||\n      expression.arguments.length !== 1\n    ) {\n      return undefined;\n    }\n\n    const [argument] = expression.arguments;\n    if (!argument || argument.type === 'SpreadElement') {\n      return undefined;\n    }\n\n    const value = evaluateStatic(argument, ctx, env, stack);\n    if (value === undefined) {\n      return undefined;\n    }\n\n    if (expression.callee.name === 'String') {\n      return String(value);\n    }\n\n    if (expression.callee.name === 'Number') {\n      return Number(value);\n    }\n\n    if (expression.callee.name === 'Boolean') {\n      return Boolean(value);\n    }\n\n    return undefined;\n  }\n\n  if (expression.type === 'CallExpression') {\n    if (expression.callee.type === 'Identifier') {\n      const args = expression.arguments.map((arg) =>\n        arg.type === 'SpreadElement'\n          ? undefined\n          : evaluateStatic(arg, ctx, env, stack)\n      );\n      if (args.some((value) => value === undefined)) {\n        return undefined;\n      }\n\n      const staticCallable = env.get(expression.callee.name);\n      if (\n        isOxcStaticCallableValue(staticCallable) &&\n        expression.arguments.length === 0\n      ) {\n        return unwrapOxcStaticCallableValue(staticCallable);\n      }\n\n      // Plain function in env (e.g. supplied via staticBindings as a\n      // pure helper). Invoke with already-evaluated args.\n      if (typeof staticCallable === 'function') {\n        try {\n          return (staticCallable as (...a: unknown[]) => unknown)(...args);\n        } catch {\n          return undefined;\n        }\n      }\n\n      if (expression.callee.name === 'String' && args.length === 1) {\n        return String(args[0]);\n      }\n\n      if (expression.callee.name === 'Number' && args.length === 1) {\n        return Number(args[0]);\n      }\n\n      if (expression.callee.name === 'Boolean' && args.length === 1) {\n        return Boolean(args[0]);\n      }\n\n      const binding = resolveBindingAt(\n        ctx,\n        expression.callee.name,\n        expression.callee.start\n      );\n\n      // staticBindings can register a pure helper for an imported name\n      // (e.g. linaria's `cx` from '@linaria/core'). When the callee\n      // resolves to such an import and every arg evaluated, invoke the\n      // helper and return its result as a static value.\n      if (binding?.importedFrom) {\n        const override = lookupStaticBinding(\n          ctx.staticBindings,\n          binding.importedFrom,\n          binding.imported\n        );\n        if (override.found && typeof override.value === 'function') {\n          try {\n            return (override.value as (...a: unknown[]) => unknown)(...args);\n          } catch {\n            return undefined;\n          }\n        }\n      }\n\n      const fn = binding?.functionNode ?? binding?.declarator?.init;\n      if (\n        fn &&\n        (fn.type === 'ArrowFunctionExpression' ||\n          fn.type === 'FunctionDeclaration' ||\n          fn.type === 'FunctionExpression')\n      ) {\n        return evaluateFunctionCall(fn, args, ctx, env, [\n          ...stack,\n          expression.callee.name,\n        ]);\n      }\n    }\n\n    if (expression.callee.type === 'MemberExpression') {\n      const objectValue = evaluateStatic(\n        expression.callee.object,\n        ctx,\n        env,\n        stack\n      );\n      let key: unknown;\n      if (expression.callee.computed) {\n        key = evaluateStatic(\n          expression.callee.property as Expression,\n          ctx,\n          env,\n          stack\n        );\n      } else if (expression.callee.property.type === 'Identifier') {\n        key = expression.callee.property.name;\n      }\n      if (typeof objectValue === 'string') {\n        if (key === 'toLowerCase' && expression.arguments.length === 0) {\n          return objectValue.toLowerCase();\n        }\n\n        if (key === 'toUpperCase' && expression.arguments.length === 0) {\n          return objectValue.toUpperCase();\n        }\n      }\n    }\n  }\n\n  return evaluateBinary(expression, ctx, env, stack);\n};\n"],"file":"staticEvaluator.js"}

package/esm/utils/collectOxcTemplateDependencies/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/esm/utils/collectOxcTemplateDependencies/types.js.map

@@ -0,0 +1 @@
+{"mappings":"","names":[],"sources":["../../../src/utils/collectOxcTemplateDependencies/types.ts"],"version":3,"sourcesContent":["import type { ExpressionValue, ValueType } from '@wyw-in-js/shared';\nimport type {\n  AssignmentExpression,\n  Expression,\n  Node,\n  TemplateLiteral,\n  UpdateExpression,\n  VariableDeclaration,\n  VariableDeclarator,\n} from 'oxc-parser';\n\nimport type { OxcValueReplacement } from '../oxc/replacements';\nimport type { OxcLocationLookup } from '../oxc/sourceLocations';\n\nexport type OxcFunctionLikeNode = Node & {\n  async: boolean;\n  body: Node | null;\n  id?: { name: string } | null;\n  params: Node[];\n};\nexport type BindingKind = 'function' | 'import' | 'param' | 'variable';\nexport type ScopedDeclarationKind = 'const' | 'let' | 'var';\n\nexport type Binding = {\n  declarationKind?: ScopedDeclarationKind;\n  declaredAt: number;\n  declaration: VariableDeclaration | null;\n  declarator: VariableDeclarator | null;\n  functionNode?: OxcFunctionLikeNode | null;\n  imported?: 'default' | '*' | string;\n  importedFrom?: string;\n  isRoot: boolean;\n  kind: BindingKind;\n  name: string;\n  scope: Scope;\n};\n\nexport type Replacement = OxcValueReplacement;\n\nexport type SpanLookup = Set<string> | null;\n\nexport type LocationLookup = OxcLocationLookup;\n\nexport type ExpressionSpan = {\n  end: number;\n  start: number;\n};\n\nexport type Scope = {\n  bindings: Map<string, Binding>;\n  depth: number;\n  end: number;\n  functionBoundary: boolean;\n  params: Set<string>;\n  parent: Scope | null;\n  root: boolean;\n  start: number;\n};\n\nexport type ReferenceIdentifier = {\n  end: number;\n  name: string;\n  start: number;\n};\n\nexport type OxcStaticImportReference = {\n  imported: 'default' | string;\n  importLocal?: string;\n  local: string;\n  source: string;\n};\n\nexport type OxcStaticValue = {\n  name: string;\n  value: unknown;\n};\n\nexport type OxcStaticValueCandidate = {\n  imports: OxcStaticImportReference[];\n  inlineConstants?: Record<string, unknown>;\n  name: string;\n  source: string;\n};\n\nexport type TemplateExtractionResult = {\n  code: string;\n  dependencyNames: string[];\n  expressionValues: Omit<ExpressionValue, 'buildCodeFrameError'>[];\n  staticValueCandidates: OxcStaticValueCandidate[];\n  staticValues: OxcStaticValue[];\n};\n\nexport type StaticBindings = Record<string, Record<string, unknown>>;\n\nexport type ExtractedExpression = {\n  expressionCode: string;\n  hasInlinableLocalReference?: boolean;\n  importedFrom: string[];\n  kind: ValueType.FUNCTION | ValueType.LAZY;\n  staticExpressionCode?: string;\n  staticImports: OxcStaticImportReference[];\n  staticValue?: unknown;\n};\n\nexport type StaticLocalExpression = {\n  importedFrom: string[];\n  imports: OxcStaticImportReference[];\n  source: string;\n};\n\nexport type ProgramAnalysis = {\n  bindingsByName: Map<string, Binding[]>;\n  rootMutationsByBinding: Map<\n    string,\n    Array<AssignmentExpression | UpdateExpression>\n  >;\n  targetExpressions: Expression[];\n  templateLiterals: TemplateLiteral[];\n  usedNames: Set<string>;\n};\n\nexport type ExtractionContext = {\n  bindingResolutionCache: Map<string, Map<number, Binding | null>>;\n  bindingsByName: Map<string, Binding[]>;\n  code: string;\n  currentInsertionPoint: number;\n  currentExpressionStart: number;\n  dependencyNames: Set<string>;\n  expressionValues: Omit<ExpressionValue, 'buildCodeFrameError'>[];\n  filename: string;\n  hoistedBindingNames: Map<string, string>;\n  hoistedDeclarations: Map<string, string>;\n  hoistedDeclarationsByInsertionPoint: Map<number, string[]>;\n  loc: LocationLookup;\n  referencesByNode: WeakMap<Node, ReferenceIdentifier[]>;\n  replacements: Replacement[];\n  rootMutationsByBinding: Map<\n    string,\n    Array<AssignmentExpression | UpdateExpression>\n  >;\n  staticBindings?: StaticBindings;\n  staticImportAliases: Map<string, string>;\n  staticValueCandidates: OxcStaticValueCandidate[];\n  staticValues: OxcStaticValue[];\n  usedNames: Set<string>;\n};\n"],"file":"types.js"}