@nudojs/cli 0.1.0 → 0.2.0

package/dist/chunk-RBHWWZII.js

@@ -1,1467 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/narrowing.ts
-import {
-  T,
-  narrowType,
-  subtractType,
-  getPrimitiveTypeOf,
-  typeValueEquals
-} from "@nudo/core";
-function narrow(test, env) {
-  if (test.type === "BinaryExpression" && test.operator === "===" && isTypeofExpr(test.left) && test.right.type === "StringLiteral") {
-    const varName = getTypeofTarget(test.left);
-    if (varName) {
-      return narrowByTypeof(varName, test.right.value, env);
-    }
-  }
-  if (test.type === "BinaryExpression" && test.operator === "===" && test.left.type === "StringLiteral" && isTypeofExpr(test.right)) {
-    const varName = getTypeofTarget(test.right);
-    if (varName) {
-      return narrowByTypeof(varName, test.left.value, env);
-    }
-  }
-  if (test.type === "BinaryExpression" && test.operator === "!==" && isTypeofExpr(test.left) && test.right.type === "StringLiteral") {
-    const varName = getTypeofTarget(test.left);
-    if (varName) {
-      const [trueEnv, falseEnv] = narrowByTypeof(varName, test.right.value, env);
-      return [falseEnv, trueEnv];
-    }
-  }
-  if (test.type === "BinaryExpression" && test.operator === "!==" && test.left.type === "StringLiteral" && isTypeofExpr(test.right)) {
-    const varName = getTypeofTarget(test.right);
-    if (varName) {
-      const [trueEnv, falseEnv] = narrowByTypeof(varName, test.left.value, env);
-      return [falseEnv, trueEnv];
-    }
-  }
-  if (test.type === "BinaryExpression" && test.operator === "===" && test.left.type === "Identifier" && isLiteralNode(test.right)) {
-    return narrowByStrictEqual(test.left.name, getLiteralValue(test.right), env);
-  }
-  if (test.type === "BinaryExpression" && test.operator === "===" && isLiteralNode(test.left) && test.right.type === "Identifier") {
-    return narrowByStrictEqual(test.right.name, getLiteralValue(test.left), env);
-  }
-  if (test.type === "BinaryExpression" && test.operator === "!==" && test.left.type === "Identifier" && isLiteralNode(test.right)) {
-    const [trueEnv, falseEnv] = narrowByStrictEqual(test.left.name, getLiteralValue(test.right), env);
-    return [falseEnv, trueEnv];
-  }
-  if (test.type === "BinaryExpression" && test.operator === "!==" && isLiteralNode(test.left) && test.right.type === "Identifier") {
-    const [trueEnv, falseEnv] = narrowByStrictEqual(test.right.name, getLiteralValue(test.left), env);
-    return [falseEnv, trueEnv];
-  }
-  if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.left.type === "Identifier" && test.right.type === "Identifier") {
-    return narrowByInstanceof(test.left.name, test.right.name, env);
-  }
-  if (test.type === "UnaryExpression" && test.operator === "!") {
-    const [trueEnv, falseEnv] = narrow(test.argument, env);
-    return [falseEnv, trueEnv];
-  }
-  return [env, env];
-}
-function isTypeofExpr(node) {
-  return node.type === "UnaryExpression" && node.operator === "typeof";
-}
-function getTypeofTarget(node) {
-  if (node.type === "UnaryExpression" && node.operator === "typeof" && node.argument.type === "Identifier") {
-    return node.argument.name;
-  }
-  return null;
-}
-function isLiteralNode(node) {
-  return node.type === "NumericLiteral" || node.type === "StringLiteral" || node.type === "BooleanLiteral" || node.type === "NullLiteral" || node.type === "Identifier" && node.name === "undefined";
-}
-function getLiteralValue(node) {
-  if (node.type === "NumericLiteral") return T.literal(node.value);
-  if (node.type === "StringLiteral") return T.literal(node.value);
-  if (node.type === "BooleanLiteral") return T.literal(node.value);
-  if (node.type === "NullLiteral") return T.null;
-  if (node.type === "Identifier" && node.name === "undefined") return T.undefined;
-  return T.unknown;
-}
-var typeofToPrimitive = {
-  number: T.number,
-  string: T.string,
-  boolean: T.boolean,
-  bigint: T.bigint,
-  symbol: T.symbol
-};
-function narrowByTypeof(varName, typeStr, env) {
-  const current = env.lookup(varName);
-  const targetPrimitive = typeofToPrimitive[typeStr];
-  const matchesPrimitive = (m) => {
-    const pt = getPrimitiveTypeOf(m);
-    return pt === typeStr;
-  };
-  if (targetPrimitive) {
-    const narrowed = narrowType(current, matchesPrimitive);
-    const excluded = subtractType(current, matchesPrimitive);
-    const trueEnv = env.extend({});
-    trueEnv.bind(varName, narrowed.kind === "never" ? targetPrimitive : narrowed);
-    const falseEnv = env.extend({});
-    falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
-    return [trueEnv, falseEnv];
-  }
-  if (typeStr === "object") {
-    const narrowed = narrowType(current, (m) => {
-      const pt = getPrimitiveTypeOf(m);
-      return pt === "object";
-    });
-    const excluded = subtractType(current, (m) => {
-      const pt = getPrimitiveTypeOf(m);
-      return pt === "object";
-    });
-    const trueEnv = env.extend({});
-    trueEnv.bind(varName, narrowed.kind === "never" ? current : narrowed);
-    const falseEnv = env.extend({});
-    falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
-    return [trueEnv, falseEnv];
-  }
-  if (typeStr === "function") {
-    const narrowed = narrowType(current, (m) => m.kind === "function");
-    const excluded = subtractType(current, (m) => m.kind === "function");
-    const trueEnv = env.extend({});
-    trueEnv.bind(varName, narrowed.kind === "never" ? current : narrowed);
-    const falseEnv = env.extend({});
-    falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
-    return [trueEnv, falseEnv];
-  }
-  return [env, env];
-}
-function narrowByInstanceof(varName, className, env) {
-  const current = env.lookup(varName);
-  const narrowed = narrowType(
-    current,
-    (m) => m.kind === "instance" && m.className === className
-  );
-  const excluded = subtractType(
-    current,
-    (m) => m.kind === "instance" && m.className === className
-  );
-  const trueEnv = env.extend({});
-  trueEnv.bind(varName, narrowed.kind === "never" ? T.instanceOf(className) : narrowed);
-  const falseEnv = env.extend({});
-  falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
-  return [trueEnv, falseEnv];
-}
-function narrowByStrictEqual(varName, literalTV, env) {
-  const current = env.lookup(varName);
-  const narrowed = narrowType(current, (m) => typeValueEquals(m, literalTV));
-  const excluded = subtractType(current, (m) => typeValueEquals(m, literalTV));
-  const trueEnv = env.extend({});
-  trueEnv.bind(varName, narrowed.kind === "never" ? literalTV : narrowed);
-  const falseEnv = env.extend({});
-  falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
-  return [trueEnv, falseEnv];
-}
-
-// src/evaluator.ts
-import {
-  T as T2,
-  simplifyUnion,
-  applyBinaryOp,
-  Ops,
-  createEnvironment,
-  typeValueEquals as typeValueEquals2,
-  typeValueToString,
-  isSubtypeOf
-} from "@nudo/core";
-var RETURN_SIGNAL = Symbol("ReturnSignal");
-var BRANCH_SIGNAL = Symbol("BranchSignal");
-var THROW_SIGNAL = Symbol("ThrowSignal");
-function makeReturn(value) {
-  return { [RETURN_SIGNAL]: true, value };
-}
-function makeBranch(returnedValue, fallthroughEnv) {
-  return { [BRANCH_SIGNAL]: true, returnedValue, fallthroughEnv };
-}
-function makeThrow(thrown, loc) {
-  return { [THROW_SIGNAL]: true, thrown, loc };
-}
-function isReturn(v) {
-  return typeof v === "object" && v !== null && RETURN_SIGNAL in v;
-}
-function isBranch(v) {
-  return typeof v === "object" && v !== null && BRANCH_SIGNAL in v;
-}
-function isThrow(v) {
-  return typeof v === "object" && v !== null && THROW_SIGNAL in v;
-}
-var MEMO_IN_PROGRESS = Symbol("MemoInProgress");
-var callMemo = /* @__PURE__ */ new Map();
-function buildMemoKey(fn, args) {
-  const fnName = fn._memoize;
-  if (!fnName) return null;
-  const argsKey = args.map(typeValueToString).join(",");
-  return `${fnName}(${argsKey})`;
-}
-var moduleCache = /* @__PURE__ */ new Map();
-function resetMemo() {
-  callMemo.clear();
-  moduleCache.clear();
-}
-function setModuleResolver(resolver) {
-  currentModuleResolver = resolver;
-}
-var currentModuleResolver = null;
-var currentFileDir = "";
-var _nodeTypeCollector = null;
-function setNodeTypeCollector(collector) {
-  _nodeTypeCollector = collector;
-}
-function recordNodeType(node, tv) {
-  if (_nodeTypeCollector && node.loc) {
-    _nodeTypeCollector(node, tv);
-  }
-}
-function distributeOverUnion(tv, fn) {
-  if (tv.kind === "union") {
-    return simplifyUnion(tv.members.map(fn));
-  }
-  return fn(tv);
-}
-function distributeBinaryOverUnion(left, right, fn) {
-  if (left.kind === "union" && right.kind === "union") {
-    return simplifyUnion(
-      left.members.flatMap((l) => right.members.map((r) => fn(l, r)))
-    );
-  }
-  if (left.kind === "union") {
-    return simplifyUnion(left.members.map((l) => fn(l, right)));
-  }
-  if (right.kind === "union") {
-    return simplifyUnion(right.members.map((r) => fn(left, r)));
-  }
-  return fn(left, right);
-}
-var _unreachableRanges = [];
-function collectUnreachable(stmts, fromIndex) {
-  for (let j = fromIndex; j < stmts.length; j++) {
-    const s = stmts[j];
-    if (s.loc) {
-      _unreachableRanges.push({
-        start: { line: s.loc.start.line, column: s.loc.start.column },
-        end: { line: s.loc.end.line, column: s.loc.end.column }
-      });
-    }
-  }
-}
-function evaluateStatements(stmts, env) {
-  const returnValues = [];
-  let currentEnv = env;
-  let lastValue = T2.undefined;
-  for (let i = 0; i < stmts.length; i++) {
-    const stmt = stmts[i];
-    const result = evaluate(stmt, currentEnv);
-    if (isThrow(result)) {
-      collectUnreachable(stmts, i + 1);
-      return result;
-    }
-    if (isReturn(result)) {
-      returnValues.push(result.value);
-      collectUnreachable(stmts, i + 1);
-      return makeReturn(simplifyUnion(returnValues));
-    }
-    if (isBranch(result)) {
-      returnValues.push(result.returnedValue);
-      currentEnv = result.fallthroughEnv;
-      continue;
-    }
-    lastValue = result;
-  }
-  if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion(returnValues), currentEnv);
-  }
-  return lastValue;
-}
-function describeParam(p) {
-  if (p.type === "Identifier") return p.name;
-  if (p.type === "AssignmentPattern" && p.left.type === "Identifier") return p.left.name;
-  if (p.type === "AssignmentPattern") return describeParam(p.left);
-  if (p.type === "RestElement") return `...${describeParam(p.argument)}`;
-  if (p.type === "ObjectPattern") {
-    const keys = p.properties.map((prop) => {
-      if (prop.type === "RestElement") return `...${describeParam(prop.argument)}`;
-      const key = prop.key?.type === "Identifier" ? prop.key.name : "?";
-      return key;
-    });
-    return `{ ${keys.join(", ")} }`;
-  }
-  if (p.type === "ArrayPattern") {
-    const elems = p.elements.map((e) => e ? describeParam(e) : "");
-    return `[${elems.join(", ")}]`;
-  }
-  return "_";
-}
-function evaluate(node, env) {
-  const result = evaluateNode(node, env);
-  if (_nodeTypeCollector && node.loc && !isReturn(result) && !isBranch(result) && !isThrow(result)) {
-    recordNodeType(node, result);
-  }
-  return result;
-}
-function evaluateNode(node, env) {
-  switch (node.type) {
-    case "File":
-      return evaluate(node.program, env);
-    case "Program":
-      return evaluateStatements(node.body, env);
-    case "ExpressionStatement":
-      return evaluate(node.expression, env);
-    case "NumericLiteral":
-      return T2.literal(node.value);
-    case "StringLiteral":
-      return T2.literal(node.value);
-    case "BooleanLiteral":
-      return T2.literal(node.value);
-    case "NullLiteral":
-      return T2.null;
-    case "Identifier": {
-      if (node.name === "undefined") return T2.undefined;
-      return env.lookup(node.name);
-    }
-    case "ThisExpression":
-      return env.lookup("this");
-    case "TemplateLiteral": {
-      if (node.expressions.length === 0 && node.quasis.length === 1) {
-        return T2.literal(node.quasis[0].value.cooked ?? node.quasis[0].value.raw);
-      }
-      const parts = [];
-      for (let i = 0; i < node.quasis.length; i++) {
-        const quasi = node.quasis[i];
-        const raw = quasi.value.cooked ?? quasi.value.raw;
-        if (raw) parts.push(T2.literal(raw));
-        if (i < node.expressions.length) {
-          const exprVal = evaluate(node.expressions[i], env);
-          if (isReturn(exprVal) || isBranch(exprVal) || isThrow(exprVal)) return exprVal;
-          parts.push(exprVal);
-        }
-      }
-      const allLiteral = parts.every(
-        (p) => p.kind === "literal" && (typeof p.value === "string" || typeof p.value === "number")
-      );
-      if (allLiteral) {
-        return T2.literal(
-          parts.map((p) => p.kind === "literal" ? String(p.value) : "").join("")
-        );
-      }
-      return T2.string;
-    }
-    case "BinaryExpression": {
-      const leftVal = evaluate(node.left, env);
-      if (isReturn(leftVal) || isBranch(leftVal) || isThrow(leftVal)) return leftVal;
-      const rightVal = evaluate(node.right, env);
-      if (isReturn(rightVal) || isBranch(rightVal) || isThrow(rightVal)) return rightVal;
-      if (node.operator === "instanceof") {
-        return evaluateInstanceof(leftVal, rightVal, node.right, env);
-      }
-      return distributeBinaryOverUnion(
-        leftVal,
-        rightVal,
-        (l, r) => applyBinaryOp(node.operator, l, r)
-      );
-    }
-    case "UnaryExpression": {
-      const argVal = evaluate(node.argument, env);
-      if (isReturn(argVal) || isBranch(argVal) || isThrow(argVal)) return argVal;
-      if (node.operator === "typeof") {
-        return distributeOverUnion(argVal, (v) => Ops.typeof_(v));
-      }
-      if (node.operator === "!") {
-        return distributeOverUnion(argVal, (v) => Ops.not(v));
-      }
-      if (node.operator === "-") {
-        return distributeOverUnion(argVal, (v) => Ops.neg(v));
-      }
-      return T2.unknown;
-    }
-    case "LogicalExpression": {
-      const leftVal = evaluate(node.left, env);
-      if (isReturn(leftVal) || isBranch(leftVal) || isThrow(leftVal)) return leftVal;
-      if (node.operator === "&&") {
-        if (leftVal.kind === "literal" && !leftVal.value) return leftVal;
-        if (leftVal.kind === "literal" && leftVal.value) {
-          const rv2 = evaluate(node.right, env);
-          return isReturn(rv2) || isBranch(rv2) || isThrow(rv2) ? rv2 : rv2;
-        }
-        const rv = evaluate(node.right, env);
-        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T2.unknown : rv;
-        return simplifyUnion([leftVal, rightTV]);
-      }
-      if (node.operator === "||") {
-        if (leftVal.kind === "literal" && leftVal.value) return leftVal;
-        if (leftVal.kind === "literal" && !leftVal.value) {
-          const rv2 = evaluate(node.right, env);
-          return isReturn(rv2) || isBranch(rv2) || isThrow(rv2) ? rv2 : rv2;
-        }
-        const rv = evaluate(node.right, env);
-        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T2.unknown : rv;
-        return simplifyUnion([leftVal, rightTV]);
-      }
-      if (node.operator === "??") {
-        if (leftVal.kind === "literal" && leftVal.value !== null && leftVal.value !== void 0) {
-          return leftVal;
-        }
-        if (leftVal.kind === "literal" && (leftVal.value === null || leftVal.value === void 0)) {
-          const rv2 = evaluate(node.right, env);
-          return isReturn(rv2) || isBranch(rv2) || isThrow(rv2) ? rv2 : rv2;
-        }
-        const rv = evaluate(node.right, env);
-        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T2.unknown : rv;
-        return simplifyUnion([leftVal, rightTV]);
-      }
-      return T2.unknown;
-    }
-    case "ConditionalExpression": {
-      const test = node.test;
-      const [trueEnv, falseEnv] = narrow(test, env);
-      const testVal = evaluate(test, env);
-      if (isReturn(testVal) || isBranch(testVal) || isThrow(testVal)) return testVal;
-      if (testVal.kind === "literal") {
-        return testVal.value ? evaluate(node.consequent, trueEnv) : evaluate(node.alternate, falseEnv);
-      }
-      const cResult = evaluate(node.consequent, trueEnv);
-      const aResult = evaluate(node.alternate, falseEnv);
-      const cVal = isReturn(cResult) ? cResult.value : isBranch(cResult) ? cResult.returnedValue : cResult;
-      const aVal = isReturn(aResult) ? aResult.value : isBranch(aResult) ? aResult.returnedValue : aResult;
-      return simplifyUnion([cVal, aVal]);
-    }
-    case "IfStatement": {
-      const test = node.test;
-      const [trueEnv, falseEnv] = narrow(test, env);
-      const testVal = evaluate(test, env);
-      if (isReturn(testVal) || isBranch(testVal) || isThrow(testVal)) return testVal;
-      if (testVal.kind === "literal") {
-        if (testVal.value) {
-          if (node.alternate?.loc) {
-            _unreachableRanges.push({
-              start: { line: node.alternate.loc.start.line, column: node.alternate.loc.start.column },
-              end: { line: node.alternate.loc.end.line, column: node.alternate.loc.end.column }
-            });
-          }
-          return evaluate(node.consequent, trueEnv);
-        }
-        if (node.consequent.loc) {
-          _unreachableRanges.push({
-            start: { line: node.consequent.loc.start.line, column: node.consequent.loc.start.column },
-            end: { line: node.consequent.loc.end.line, column: node.consequent.loc.end.column }
-          });
-        }
-        return node.alternate ? evaluate(node.alternate, falseEnv) : T2.undefined;
-      }
-      const consequentResult = evaluate(node.consequent, trueEnv);
-      const alternateResult = node.alternate ? evaluate(node.alternate, falseEnv) : null;
-      const cReturns = isReturn(consequentResult);
-      const cBranches = isBranch(consequentResult);
-      const cThrows = isThrow(consequentResult);
-      const aReturns = alternateResult !== null && isReturn(alternateResult);
-      const aBranches = alternateResult !== null && isBranch(alternateResult);
-      const aThrows = alternateResult !== null && isThrow(alternateResult);
-      if (cThrows && aThrows) {
-        return consequentResult;
-      }
-      if (cThrows && !node.alternate) {
-        return makeBranch(T2.never, falseEnv);
-      }
-      if (cThrows) {
-        const aVal2 = aReturns ? alternateResult.value : aBranches ? alternateResult.returnedValue : alternateResult;
-        return makeBranch(aVal2, falseEnv);
-      }
-      if (aThrows) {
-        const cVal2 = cReturns ? consequentResult.value : cBranches ? consequentResult.returnedValue : consequentResult;
-        return makeBranch(cVal2, trueEnv);
-      }
-      const cVal = cReturns ? consequentResult.value : cBranches ? consequentResult.returnedValue : consequentResult;
-      const aVal = aReturns ? alternateResult.value : aBranches ? alternateResult.returnedValue : alternateResult;
-      if (cReturns && aReturns) {
-        return makeReturn(simplifyUnion([cVal, aVal]));
-      }
-      if (cReturns && !node.alternate) {
-        return makeBranch(cVal, falseEnv);
-      }
-      if (cReturns && node.alternate) {
-        if (aReturns) {
-          return makeReturn(simplifyUnion([cVal, aVal]));
-        }
-        return makeBranch(cVal, falseEnv);
-      }
-      if (aReturns) {
-        return makeBranch(aVal, trueEnv);
-      }
-      const allVals = [cVal];
-      if (aVal !== null) allVals.push(aVal);
-      else allVals.push(T2.undefined);
-      return simplifyUnion(allVals);
-    }
-    case "BlockStatement": {
-      const blockEnv = env.extend({});
-      const result = evaluateStatements(node.body, blockEnv);
-      return result;
-    }
-    case "ReturnStatement": {
-      const arg = node.argument;
-      if (!arg) return makeReturn(T2.undefined);
-      const val = evaluate(arg, env);
-      if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
-      return makeReturn(val);
-    }
-    case "VariableDeclaration": {
-      for (const decl of node.declarations) {
-        const init = decl.init ? evaluate(decl.init, env) : T2.undefined;
-        if (isReturn(init) || isBranch(init) || isThrow(init)) return init;
-        bindPattern(decl.id, init, env);
-        if (decl.id.type === "Identifier") {
-          recordNodeType(decl.id, init);
-        }
-      }
-      return T2.undefined;
-    }
-    case "AssignmentExpression": {
-      if (node.left.type === "Identifier") {
-        const val = evaluate(node.right, env);
-        if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
-        if (!env.update(node.left.name, val)) {
-          env.bind(node.left.name, val);
-        }
-        return val;
-      }
-      if (node.left.type === "MemberExpression") {
-        const val = evaluate(node.right, env);
-        if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
-        const objVal = evaluate(node.left.object, env);
-        if (isReturn(objVal) || isBranch(objVal) || isThrow(objVal)) return val;
-        if (objVal.kind === "object") {
-          const propName = getMemberKey(node.left, env);
-          if (propName !== null) {
-            objVal.properties[propName] = val;
-          }
-        }
-        if (objVal.kind === "tuple" || objVal.kind === "array") {
-          const propVal = node.left.computed ? evaluate(node.left.property, env) : null;
-          if (objVal.kind === "tuple" && propVal && !isReturn(propVal) && !isBranch(propVal) && propVal.kind === "literal" && typeof propVal.value === "number") {
-            objVal.elements[propVal.value] = val;
-          }
-        }
-        return val;
-      }
-      if (node.left.type === "ObjectPattern" || node.left.type === "ArrayPattern") {
-        const val = evaluate(node.right, env);
-        if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
-        bindPattern(node.left, val, env);
-        return val;
-      }
-      return T2.unknown;
-    }
-    case "ForOfStatement": {
-      const rightVal = evaluate(node.right, env);
-      if (isReturn(rightVal) || isBranch(rightVal) || isThrow(rightVal)) return rightVal;
-      return evaluateForOf(node, rightVal, env);
-    }
-    case "ForInStatement": {
-      const rightVal = evaluate(node.right, env);
-      if (isReturn(rightVal) || isBranch(rightVal) || isThrow(rightVal)) return rightVal;
-      return evaluateForIn(node, rightVal, env);
-    }
-    case "ForStatement": {
-      if (node.init) {
-        const initResult = evaluate(node.init, env);
-        if (isReturn(initResult) || isBranch(initResult) || isThrow(initResult)) return initResult;
-      }
-      return T2.undefined;
-    }
-    case "WhileStatement":
-      return T2.undefined;
-    case "FunctionDeclaration": {
-      if (!node.id) return T2.undefined;
-      const paramNames = node.params.map(describeParam);
-      const fnType = T2.fn(paramNames, node.body, env);
-      fnType._paramPatterns = node.params;
-      if (node.async) fnType._async = true;
-      env.bind(node.id.name, fnType);
-      return T2.undefined;
-    }
-    case "FunctionExpression":
-    case "ArrowFunctionExpression": {
-      const paramNames = node.params.map(describeParam);
-      const body = node.body;
-      const fnType = T2.fn(paramNames, body, env);
-      fnType._paramPatterns = node.params;
-      if (node.async) fnType._async = true;
-      return fnType;
-    }
-    case "AwaitExpression": {
-      const argVal = evaluate(node.argument, env);
-      if (isReturn(argVal) || isBranch(argVal) || isThrow(argVal)) return argVal;
-      return distributeOverUnion(
-        argVal,
-        (v) => v.kind === "promise" ? v.value : v
-      );
-    }
-    case "ClassDeclaration": {
-      return evaluateClassDeclaration(node, env);
-    }
-    case "ImportDeclaration": {
-      return evaluateImportDeclaration(node, env);
-    }
-    case "ExportNamedDeclaration": {
-      if (node.declaration) {
-        const result = evaluate(node.declaration, env);
-        if (isReturn(result) || isBranch(result) || isThrow(result)) return result;
-        if (node.declaration.type === "VariableDeclaration") {
-          for (const decl of node.declaration.declarations) {
-            if (decl.id.type === "Identifier") {
-              const val = env.lookup(decl.id.name);
-              env.bind(`__export_${decl.id.name}`, val);
-            }
-          }
-        } else if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
-          const val = env.lookup(node.declaration.id.name);
-          env.bind(`__export_${node.declaration.id.name}`, val);
-        } else if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
-          const val = env.lookup(node.declaration.id.name);
-          env.bind(`__export_${node.declaration.id.name}`, val);
-        }
-      }
-      if (node.specifiers) {
-        for (const spec of node.specifiers) {
-          if (spec.type === "ExportSpecifier") {
-            const localName = spec.local.type === "Identifier" ? spec.local.name : null;
-            const exportedName = spec.exported.type === "Identifier" ? spec.exported.name : null;
-            if (localName && exportedName) {
-              env.bind(`__export_${exportedName}`, env.lookup(localName));
-            }
-          }
-        }
-      }
-      return T2.undefined;
-    }
-    case "ExportDefaultDeclaration": {
-      const decl = node.declaration;
-      const result = evaluate(decl, env);
-      if (isReturn(result) || isBranch(result) || isThrow(result)) return result;
-      if (decl.type === "FunctionDeclaration" && decl.id) {
-        env.bind(`__export_default`, env.lookup(decl.id.name));
-      } else if (decl.type === "ClassDeclaration" && decl.id) {
-        env.bind(`__export_default`, env.lookup(decl.id.name));
-      } else {
-        env.bind(`__export_default`, result);
-      }
-      return T2.undefined;
-    }
-    case "CallExpression": {
-      const callee = node.callee;
-      if (callee.type === "MemberExpression") {
-        const methodResult = evaluateMethodCall(callee, node.arguments, env);
-        if (methodResult !== null) return methodResult;
-      }
-      const calleeVal = evaluate(callee, env);
-      if (isReturn(calleeVal) || isBranch(calleeVal) || isThrow(calleeVal)) return calleeVal;
-      const argVals = evaluateArgs(node.arguments, env);
-      if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-      if (calleeVal.kind === "function") {
-        const full = callFunctionFull(calleeVal, argVals);
-        if (full.value.kind === "never" && full.throws.kind !== "never") {
-          const callLoc = node.loc ? {
-            start: { line: node.loc.start.line, column: node.loc.start.column },
-            end: { line: node.loc.end.line, column: node.loc.end.column }
-          } : full.throwLoc;
-          return makeThrow(full.throws, callLoc);
-        }
-        return full.value;
-      }
-      return distributeOverUnion(calleeVal, (fn) => {
-        if (fn.kind !== "function") return T2.unknown;
-        return callFunction(fn, argVals);
-      });
-    }
-    case "MemberExpression": {
-      const objVal = evaluate(node.object, env);
-      if (isReturn(objVal) || isBranch(objVal) || isThrow(objVal)) return objVal;
-      if (node.computed) {
-        const propVal = evaluate(node.property, env);
-        if (isReturn(propVal) || isBranch(propVal) || isThrow(propVal)) return propVal;
-        return distributeOverUnion(objVal, (obj) => {
-          if (obj.kind === "object" && propVal.kind === "literal" && typeof propVal.value === "string") {
-            return obj.properties[propVal.value] ?? T2.undefined;
-          }
-          if ((obj.kind === "array" || obj.kind === "tuple") && propVal.kind === "literal" && typeof propVal.value === "number") {
-            if (obj.kind === "tuple") return obj.elements[propVal.value] ?? T2.undefined;
-            return obj.element;
-          }
-          return T2.unknown;
-        });
-      }
-      if (node.property.type === "Identifier") {
-        const propName = node.property.name;
-        return distributeOverUnion(objVal, (obj) => {
-          if (obj.kind === "object") return obj.properties[propName] ?? T2.undefined;
-          if (obj.kind === "instance") return obj.properties[propName] ?? T2.undefined;
-          if (propName === "length" && (obj.kind === "array" || obj.kind === "tuple")) {
-            return obj.kind === "tuple" ? T2.literal(obj.elements.length) : T2.number;
-          }
-          return T2.unknown;
-        });
-      }
-      return T2.unknown;
-    }
-    case "ObjectExpression": {
-      const props = {};
-      for (const prop of node.properties) {
-        if (prop.type === "ObjectProperty") {
-          const key = prop.computed ? (() => {
-            const kv = evaluate(prop.key, env);
-            return !isReturn(kv) && !isBranch(kv) && !isThrow(kv) && kv.kind === "literal" && typeof kv.value === "string" ? kv.value : null;
-          })() : prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
-          if (key) {
-            const val = evaluate(prop.value, env);
-            if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
-            props[key] = val;
-          }
-        } else if (prop.type === "SpreadElement") {
-          const spreadVal = evaluate(prop.argument, env);
-          if (isReturn(spreadVal) || isBranch(spreadVal) || isThrow(spreadVal)) return spreadVal;
-          if (spreadVal.kind === "object") {
-            Object.assign(props, spreadVal.properties);
-          }
-        }
-      }
-      return T2.object(props);
-    }
-    case "ArrayExpression": {
-      const elements = [];
-      for (const elem of node.elements) {
-        if (!elem) {
-          elements.push(T2.undefined);
-          continue;
-        }
-        if (elem.type === "SpreadElement") {
-          const spreadVal = evaluate(elem.argument, env);
-          if (isReturn(spreadVal) || isBranch(spreadVal) || isThrow(spreadVal)) return spreadVal;
-          if (spreadVal.kind === "tuple") {
-            elements.push(...spreadVal.elements);
-          } else if (spreadVal.kind === "array") {
-            return T2.array(simplifyUnion([...elements, spreadVal.element]));
-          } else {
-            elements.push(T2.unknown);
-          }
-          continue;
-        }
-        const val = evaluate(elem, env);
-        if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
-        elements.push(val);
-      }
-      return T2.tuple(elements);
-    }
-    case "ThrowStatement": {
-      const argVal = node.argument ? evaluate(node.argument, env) : T2.undefined;
-      if (isReturn(argVal) || isBranch(argVal) || isThrow(argVal)) return argVal;
-      const throwLoc = node.loc ? {
-        start: { line: node.loc.start.line, column: node.loc.start.column },
-        end: { line: node.loc.end.line, column: node.loc.end.column }
-      } : void 0;
-      return makeThrow(argVal, throwLoc);
-    }
-    case "TryStatement": {
-      return evaluateTryStatement(node, env);
-    }
-    case "NewExpression": {
-      return evaluateNewExpression(node, env);
-    }
-    case "SwitchStatement": {
-      return evaluateSwitchStatement(node, env);
-    }
-    case "UpdateExpression": {
-      if (node.argument.type === "Identifier") {
-        const current = env.lookup(node.argument.name);
-        if (current.kind === "literal" && typeof current.value === "number") {
-          const newVal = node.operator === "++" ? T2.literal(current.value + 1) : T2.literal(current.value - 1);
-          if (!env.update(node.argument.name, newVal)) {
-            env.bind(node.argument.name, newVal);
-          }
-          return node.prefix ? newVal : current;
-        }
-        if (!env.update(node.argument.name, T2.number)) {
-          env.bind(node.argument.name, T2.number);
-        }
-        return T2.number;
-      }
-      return T2.number;
-    }
-    default:
-      return T2.unknown;
-  }
-}
-function getMemberKey(node, env) {
-  if (!node.computed && node.property.type === "Identifier") {
-    return node.property.name;
-  }
-  if (node.computed) {
-    const propVal = evaluate(node.property, env);
-    if (!isReturn(propVal) && !isBranch(propVal) && !isThrow(propVal) && propVal.kind === "literal") {
-      return String(propVal.value);
-    }
-  }
-  return null;
-}
-function bindPattern(pattern, value, env) {
-  if (pattern.type === "Identifier") {
-    env.bind(pattern.name, value);
-    return;
-  }
-  if (pattern.type === "AssignmentPattern") {
-    const defaultVal = evaluate(pattern.right, env);
-    const resolved = value.kind === "literal" && value.value === void 0 ? !isReturn(defaultVal) && !isBranch(defaultVal) ? defaultVal : T2.unknown : value;
-    bindPattern(pattern.left, resolved, env);
-    return;
-  }
-  if (pattern.type === "ObjectPattern") {
-    const restKeys = [];
-    for (const prop of pattern.properties) {
-      if (prop.type === "RestElement") {
-        if (value.kind === "object") {
-          const remaining = {};
-          for (const [k, v] of Object.entries(value.properties)) {
-            if (!restKeys.includes(k)) remaining[k] = v;
-          }
-          bindPattern(prop.argument, T2.object(remaining), env);
-        } else {
-          bindPattern(prop.argument, T2.object({}), env);
-        }
-        continue;
-      }
-      if (prop.type !== "ObjectProperty") continue;
-      const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
-      if (!key) continue;
-      restKeys.push(key);
-      const propVal = value.kind === "object" ? value.properties[key] ?? T2.undefined : T2.unknown;
-      bindPattern(prop.value, propVal, env);
-    }
-    return;
-  }
-  if (pattern.type === "ArrayPattern") {
-    for (let i = 0; i < pattern.elements.length; i++) {
-      const elem = pattern.elements[i];
-      if (!elem) continue;
-      if (elem.type === "RestElement") {
-        if (value.kind === "tuple") {
-          bindPattern(elem.argument, T2.tuple(value.elements.slice(i)), env);
-        } else if (value.kind === "array") {
-          bindPattern(elem.argument, value, env);
-        } else {
-          bindPattern(elem.argument, T2.tuple([]), env);
-        }
-        continue;
-      }
-      const elemVal = value.kind === "tuple" ? value.elements[i] ?? T2.undefined : value.kind === "array" ? value.element : T2.unknown;
-      bindPattern(elem, elemVal, env);
-    }
-    return;
-  }
-}
-function evaluateArgs(args, env) {
-  const result = [];
-  for (const arg of args) {
-    if (arg.type === "SpreadElement") {
-      const spreadVal = evaluate(arg.argument, env);
-      if (isReturn(spreadVal) || isBranch(spreadVal) || isThrow(spreadVal)) return spreadVal;
-      if (spreadVal.kind === "tuple") {
-        result.push(...spreadVal.elements);
-      } else if (spreadVal.kind === "array") {
-        result.push(spreadVal.element);
-      } else {
-        result.push(T2.unknown);
-      }
-      continue;
-    }
-    const v = evaluate(arg, env);
-    if (isReturn(v) || isBranch(v) || isThrow(v)) return v;
-    result.push(v);
-  }
-  return result;
-}
-function evaluateMethodCall(callee, args, env) {
-  const objVal = evaluate(callee.object, env);
-  if (isReturn(objVal) || isBranch(objVal) || isThrow(objVal)) return objVal;
-  const methodName = !callee.computed && callee.property.type === "Identifier" ? callee.property.name : null;
-  if (!methodName) return null;
-  if (callee.object.type === "Identifier" && callee.object.name === "Object" && args.length >= 1) {
-    const argVal = evaluate(args[0], env);
-    if (isReturn(argVal) || isBranch(argVal) || isThrow(argVal)) return argVal;
-    return evaluateObjectStaticMethod(methodName, argVal);
-  }
-  if (objVal.kind === "array" || objVal.kind === "tuple") {
-    return evaluateArrayMethod(objVal, methodName, args, env);
-  }
-  return null;
-}
-function evaluateObjectStaticMethod(method, obj) {
-  if (obj.kind !== "object") {
-    if (method === "keys") return T2.array(T2.string);
-    if (method === "values") return T2.array(T2.unknown);
-    if (method === "entries") return T2.array(T2.tuple([T2.string, T2.unknown]));
-    return null;
-  }
-  const keys = Object.keys(obj.properties);
-  const values = Object.values(obj.properties);
-  if (method === "keys") {
-    return T2.tuple(keys.map((k) => T2.literal(k)));
-  }
-  if (method === "values") {
-    return T2.tuple(values);
-  }
-  if (method === "entries") {
-    return T2.tuple(
-      keys.map((k) => T2.tuple([T2.literal(k), obj.properties[k]]))
-    );
-  }
-  return null;
-}
-function evaluateArrayMethod(arr, method, args, env) {
-  const argVals = evaluateArgs(args, env);
-  if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-  const callbackFn = argVals[0];
-  if (method === "push") {
-    if (arr.kind === "tuple") {
-      arr.elements.push(...argVals);
-      return T2.literal(arr.elements.length);
-    }
-    return T2.number;
-  }
-  if (method === "length") {
-    return arr.kind === "tuple" ? T2.literal(arr.elements.length) : T2.number;
-  }
-  if (method === "indexOf" || method === "lastIndexOf") {
-    return T2.number;
-  }
-  if (method === "includes") {
-    if (arr.kind === "tuple" && argVals[0]?.kind === "literal") {
-      const searchVal = argVals[0];
-      const found = arr.elements.some((e) => typeValueEquals2(e, searchVal));
-      return T2.literal(found);
-    }
-    return T2.boolean;
-  }
-  if (method === "join") {
-    return T2.string;
-  }
-  if (method === "concat") {
-    if (arr.kind === "tuple") {
-      const otherElements = [];
-      for (const a of argVals) {
-        if (a.kind === "tuple") otherElements.push(...a.elements);
-        else if (a.kind === "array") return T2.array(simplifyUnion([...arr.elements, a.element]));
-        else otherElements.push(a);
-      }
-      return T2.tuple([...arr.elements, ...otherElements]);
-    }
-    return T2.array(arr.element);
-  }
-  if (method === "slice") {
-    if (arr.kind === "tuple") {
-      const start = argVals[0];
-      const end = argVals[1];
-      const startIdx = start?.kind === "literal" && typeof start.value === "number" ? start.value : 0;
-      const endIdx = end?.kind === "literal" && typeof end.value === "number" ? end.value : arr.elements.length;
-      return T2.tuple(arr.elements.slice(startIdx, endIdx));
-    }
-    return T2.array(arr.element);
-  }
-  if (!callbackFn || callbackFn.kind !== "function") {
-    if (method === "map") return arr.kind === "tuple" ? T2.tuple(arr.elements.map(() => T2.unknown)) : T2.array(T2.unknown);
-    if (method === "filter") return arr.kind === "tuple" ? T2.array(simplifyUnion(arr.elements)) : arr;
-    if (method === "find") return arr.kind === "tuple" ? simplifyUnion([...arr.elements, T2.undefined]) : simplifyUnion([arr.element, T2.undefined]);
-    if (method === "some" || method === "every") return T2.boolean;
-    if (method === "reduce") return argVals[1] ?? T2.unknown;
-    if (method === "forEach") return T2.undefined;
-    if (method === "flatMap") return T2.array(T2.unknown);
-    return null;
-  }
-  const fn = callbackFn;
-  if (method === "map") {
-    if (arr.kind === "tuple") {
-      const mapped = arr.elements.map(
-        (el, i) => callFunction(fn, [el, T2.literal(i), arr])
-      );
-      return T2.tuple(mapped);
-    }
-    return T2.array(callFunction(fn, [arr.element, T2.number, arr]));
-  }
-  if (method === "filter") {
-    if (arr.kind === "tuple") {
-      const kept = [];
-      for (let i = 0; i < arr.elements.length; i++) {
-        const result = callFunction(fn, [arr.elements[i], T2.literal(i), arr]);
-        if (result.kind === "literal" && !result.value) continue;
-        kept.push(arr.elements[i]);
-      }
-      if (kept.length === 0) return T2.tuple([]);
-      return T2.array(simplifyUnion(kept));
-    }
-    return T2.array(arr.element);
-  }
-  if (method === "reduce") {
-    const init = argVals[1];
-    if (arr.kind === "tuple") {
-      let acc2 = init ?? arr.elements[0] ?? T2.unknown;
-      const startIdx = init ? 0 : 1;
-      for (let i = startIdx; i < arr.elements.length; i++) {
-        acc2 = callFunction(fn, [acc2, arr.elements[i], T2.literal(i), arr]);
-      }
-      return acc2;
-    }
-    const acc = init ?? arr.element;
-    return callFunction(fn, [acc, arr.element, T2.number, arr]);
-  }
-  if (method === "find") {
-    const elementType = arr.kind === "tuple" ? simplifyUnion(arr.elements) : arr.element;
-    return simplifyUnion([elementType, T2.undefined]);
-  }
-  if (method === "some" || method === "every") {
-    if (arr.kind === "tuple") {
-      const results = arr.elements.map(
-        (el, i) => callFunction(fn, [el, T2.literal(i), arr])
-      );
-      const allLiteral = results.every((r) => r.kind === "literal");
-      if (allLiteral) {
-        const boolVals = results.map((r) => !!r.value);
-        return T2.literal(method === "some" ? boolVals.some(Boolean) : boolVals.every(Boolean));
-      }
-    }
-    return T2.boolean;
-  }
-  if (method === "forEach") {
-    if (arr.kind === "tuple") {
-      arr.elements.forEach((el, i) => callFunction(fn, [el, T2.literal(i), arr]));
-    } else {
-      callFunction(fn, [arr.element, T2.number, arr]);
-    }
-    return T2.undefined;
-  }
-  if (method === "flatMap") {
-    if (arr.kind === "tuple") {
-      const results = [];
-      for (let i = 0; i < arr.elements.length; i++) {
-        const r2 = callFunction(fn, [arr.elements[i], T2.literal(i), arr]);
-        if (r2.kind === "tuple") results.push(...r2.elements);
-        else if (r2.kind === "array") return T2.array(r2.element);
-        else results.push(r2);
-      }
-      return T2.tuple(results);
-    }
-    const r = callFunction(fn, [arr.element, T2.number, arr]);
-    if (r.kind === "tuple") return T2.array(simplifyUnion(r.elements));
-    if (r.kind === "array") return T2.array(r.element);
-    return T2.array(r);
-  }
-  return null;
-}
-function evaluateForOf(node, iterable, env) {
-  if (iterable.kind === "tuple") {
-    const returnValues = [];
-    let currentEnv = env;
-    for (const element of iterable.elements) {
-      const loopEnv = currentEnv.extend({});
-      bindForLoopVar(node.left, element, loopEnv);
-      const result = evaluate(node.body, loopEnv);
-      if (isReturn(result)) {
-        returnValues.push(result.value);
-        return makeReturn(simplifyUnion(returnValues));
-      }
-      if (isBranch(result)) {
-        returnValues.push(result.returnedValue);
-        currentEnv = result.fallthroughEnv;
-      }
-    }
-    if (returnValues.length > 0) {
-      return makeBranch(simplifyUnion(returnValues), currentEnv);
-    }
-    return T2.undefined;
-  }
-  if (iterable.kind === "array") {
-    const loopEnv = env.extend({});
-    bindForLoopVar(node.left, iterable.element, loopEnv);
-    const result = evaluate(node.body, loopEnv);
-    if (isReturn(result)) return makeBranch(result.value, env);
-    return T2.undefined;
-  }
-  return T2.undefined;
-}
-function evaluateForIn(node, obj, env) {
-  if (obj.kind === "object") {
-    const keys = Object.keys(obj.properties);
-    if (keys.length > 0) {
-      const returnValues = [];
-      let currentEnv = env;
-      for (const key of keys) {
-        const loopEnv2 = currentEnv.extend({});
-        bindForLoopVar(node.left, T2.literal(key), loopEnv2);
-        const result = evaluate(node.body, loopEnv2);
-        if (isReturn(result)) {
-          returnValues.push(result.value);
-          return makeReturn(simplifyUnion(returnValues));
-        }
-        if (isBranch(result)) {
-          returnValues.push(result.returnedValue);
-          currentEnv = result.fallthroughEnv;
-        }
-      }
-      if (returnValues.length > 0) {
-        return makeBranch(simplifyUnion(returnValues), currentEnv);
-      }
-      return T2.undefined;
-    }
-  }
-  const loopEnv = env.extend({});
-  bindForLoopVar(node.left, T2.string, loopEnv);
-  evaluate(node.body, loopEnv);
-  return T2.undefined;
-}
-function bindForLoopVar(left, value, env) {
-  if (left.type === "VariableDeclaration") {
-    const decl = left.declarations[0];
-    if (decl) bindPattern(decl.id, value, env);
-  } else if (left.type === "Identifier") {
-    env.bind(left.name, value);
-  }
-}
-function evaluateImportDeclaration(node, env) {
-  const source = node.source.value;
-  if (!currentModuleResolver) return T2.undefined;
-  const resolved = currentModuleResolver(source, currentFileDir);
-  if (!resolved) return T2.undefined;
-  let moduleEnv = moduleCache.get(resolved.filePath);
-  if (!moduleEnv) {
-    moduleEnv = createEnvironment();
-    moduleCache.set(resolved.filePath, moduleEnv);
-    const savedDir = currentFileDir;
-    currentFileDir = resolved.filePath.replace(/\/[^/]+$/, "");
-    evaluateProgram(resolved.ast, moduleEnv);
-    currentFileDir = savedDir;
-  }
-  for (const spec of node.specifiers) {
-    if (spec.type === "ImportDefaultSpecifier") {
-      const val = moduleEnv.has(`__export_default`) ? moduleEnv.lookup(`__export_default`) : T2.unknown;
-      env.bind(spec.local.name, val);
-    } else if (spec.type === "ImportSpecifier") {
-      const importedName = spec.imported.type === "Identifier" ? spec.imported.name : null;
-      if (importedName) {
-        const val = moduleEnv.has(`__export_${importedName}`) ? moduleEnv.lookup(`__export_${importedName}`) : T2.unknown;
-        env.bind(spec.local.name, val);
-      }
-    } else if (spec.type === "ImportNamespaceSpecifier") {
-      const exports = {};
-      const bindings = moduleEnv.getOwnBindings();
-      for (const [k, v] of Object.entries(bindings)) {
-        if (k.startsWith("__export_") && k !== "__export_default") {
-          exports[k.slice("__export_".length)] = v;
-        }
-      }
-      env.bind(spec.local.name, T2.object(exports));
-    }
-  }
-  return T2.undefined;
-}
-function evaluateClassDeclaration(node, env) {
-  const className = node.id?.name ?? "<anonymous>";
-  const methods = {};
-  let constructorFn = null;
-  for (const member of node.body.body) {
-    if (member.type !== "ClassMethod") continue;
-    const methodName = member.key.type === "Identifier" ? member.key.name : null;
-    if (!methodName) continue;
-    const paramNames = member.params.map(
-      (p) => p.type === "Identifier" ? p.name : `_p${Math.random().toString(36).slice(2, 6)}`
-    );
-    const fnType = T2.fn(paramNames, member.body, env);
-    fnType._paramPatterns = member.params;
-    if (member.async) fnType._async = true;
-    if (member.kind === "constructor") {
-      constructorFn = fnType;
-    } else {
-      methods[methodName] = fnType;
-    }
-  }
-  const ctorFn = constructorFn ?? T2.fn([], { type: "BlockStatement", body: [], directives: [] }, env);
-  ctorFn._classInfo = { className, methods };
-  if (node.id) {
-    env.bind(className, ctorFn);
-  }
-  return T2.undefined;
-}
-function evaluateInstanceof(left, _right, rightNode, _env) {
-  const className = rightNode.type === "Identifier" ? rightNode.name : null;
-  if (!className) return T2.boolean;
-  return distributeOverUnion(left, (lv) => {
-    if (lv.kind === "instance") {
-      const matches = lv.className === className || isSubtypeOf(lv, T2.instanceOf(className));
-      return T2.literal(matches);
-    }
-    return T2.boolean;
-  });
-}
-var BUILTIN_ERROR_CLASSES = /* @__PURE__ */ new Set([
-  "Error",
-  "TypeError",
-  "SyntaxError",
-  "RangeError",
-  "ReferenceError",
-  "URIError",
-  "EvalError"
-]);
-function evaluateNewExpression(node, env) {
-  const callee = node.callee;
-  if (callee.type === "Identifier" && BUILTIN_ERROR_CLASSES.has(callee.name)) {
-    const argVals = evaluateArgs(node.arguments, env);
-    if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    const msgVal = argVals[0] ?? T2.undefined;
-    return T2.instanceOf(callee.name, { message: msgVal });
-  }
-  const calleeVal = evaluate(callee, env);
-  if (isReturn(calleeVal) || isBranch(calleeVal) || isThrow(calleeVal)) return calleeVal;
-  if (calleeVal.kind === "function") {
-    const argVals = evaluateArgs(node.arguments, env);
-    if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    const classInfo = calleeVal._classInfo;
-    if (classInfo) {
-      const instanceProps = {};
-      const constructEnv = calleeVal.closure.extend({});
-      const thisObj = T2.object(instanceProps);
-      constructEnv.bind("this", thisObj);
-      const paramPatterns = calleeVal._paramPatterns;
-      for (let i = 0; i < calleeVal.params.length; i++) {
-        const argVal = argVals[i] ?? T2.undefined;
-        if (paramPatterns?.[i]) {
-          bindPattern(paramPatterns[i], argVal, constructEnv);
-        } else {
-          constructEnv.bind(calleeVal.params[i], argVal);
-        }
-      }
-      const result = evaluate(calleeVal.body, constructEnv);
-      if (isThrow(result)) return result;
-      const finalThis = constructEnv.lookup("this");
-      const props = finalThis.kind === "object" ? { ...finalThis.properties } : instanceProps;
-      for (const [k, v] of Object.entries(classInfo.methods)) {
-        props[k] = v;
-      }
-      return T2.instanceOf(classInfo.className, props);
-    }
-    return callFunction(calleeVal, argVals);
-  }
-  return T2.unknown;
-}
-function evaluateTryStatement(node, env) {
-  const tryResult = evaluateStatements(node.block.body, env.extend({}));
-  const thrownType = isThrow(tryResult) ? tryResult.thrown : null;
-  const tryValue = isThrow(tryResult) ? null : isReturn(tryResult) ? tryResult : isBranch(tryResult) ? tryResult : tryResult;
-  let catchResult = null;
-  if (node.handler && thrownType) {
-    const catchEnv = env.extend({});
-    if (node.handler.param) {
-      bindPattern(node.handler.param, thrownType, catchEnv);
-    }
-    catchResult = evaluateStatements(node.handler.body.body, catchEnv);
-  }
-  if (node.finalizer) {
-    const finallyResult = evaluateStatements(node.finalizer.body, env.extend({}));
-    if (isThrow(finallyResult)) return finallyResult;
-    if (isReturn(finallyResult)) return finallyResult;
-  }
-  if (catchResult !== null) {
-    if (isThrow(catchResult)) return catchResult;
-    if (isReturn(catchResult)) {
-      if (tryValue !== null && isReturn(tryValue)) {
-        return makeReturn(simplifyUnion([tryValue.value, catchResult.value]));
-      }
-      return catchResult;
-    }
-    if (tryValue !== null && isReturn(tryValue)) {
-      return tryValue;
-    }
-    if (tryValue !== null && isBranch(tryValue)) {
-      return tryValue;
-    }
-    return catchResult;
-  }
-  if (thrownType && !node.handler) {
-    return makeThrow(thrownType);
-  }
-  if (tryValue !== null) return tryValue;
-  return T2.undefined;
-}
-function evaluateSwitchStatement(node, env) {
-  const discriminant = evaluate(node.discriminant, env);
-  if (isReturn(discriminant) || isBranch(discriminant) || isThrow(discriminant)) return discriminant;
-  const isConcreteDiscriminant = discriminant.kind === "literal";
-  if (isConcreteDiscriminant) {
-    let matched = false;
-    const returnValues2 = [];
-    for (const caseNode of node.cases) {
-      if (caseNode.test) {
-        const testVal = evaluate(caseNode.test, env);
-        if (isReturn(testVal) || isBranch(testVal) || isThrow(testVal)) return testVal;
-        if (testVal.kind === "literal" && discriminant.value === testVal.value) matched = true;
-      } else {
-        matched = true;
-      }
-      if (matched) {
-        const result = evaluateStatements(caseNode.consequent, env);
-        if (isThrow(result)) return result;
-        if (isReturn(result)) {
-          returnValues2.push(result.value);
-          break;
-        }
-        if (isBranch(result)) {
-          returnValues2.push(result.returnedValue);
-          continue;
-        }
-      }
-    }
-    if (returnValues2.length > 0) {
-      return makeBranch(simplifyUnion(returnValues2), env);
-    }
-    return T2.undefined;
-  }
-  const returnValues = [];
-  for (const caseNode of node.cases) {
-    const result = evaluateStatements(caseNode.consequent, env);
-    if (isThrow(result)) continue;
-    if (isReturn(result)) {
-      returnValues.push(result.value);
-      continue;
-    }
-    if (isBranch(result)) {
-      returnValues.push(result.returnedValue);
-      continue;
-    }
-  }
-  if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion(returnValues), env);
-  }
-  return T2.undefined;
-}
-function callFunctionFull(fn, args) {
-  const callEnv = fn.closure.extend({});
-  const paramPatterns = fn._paramPatterns;
-  const isAsync = !!fn._async;
-  for (let i = 0; i < fn.params.length; i++) {
-    const argVal = args[i] ?? T2.undefined;
-    if (paramPatterns && paramPatterns[i]) {
-      bindPattern(paramPatterns[i], argVal, callEnv);
-    } else {
-      callEnv.bind(fn.params[i], argVal);
-    }
-  }
-  const savedUnreachable = _unreachableRanges;
-  _unreachableRanges = [];
-  const memoKey = buildMemoKey(fn, args);
-  if (memoKey !== null) {
-    const cached = callMemo.get(memoKey);
-    if (cached !== void 0) {
-      _unreachableRanges = savedUnreachable;
-      if (cached === MEMO_IN_PROGRESS) {
-        return { value: T2.unknown, throws: T2.never };
-      }
-      return { value: cached, throws: T2.never };
-    }
-    callMemo.set(memoKey, MEMO_IN_PROGRESS);
-    const result2 = evaluate(fn.body, callEnv);
-    _unreachableRanges = savedUnreachable;
-    const value2 = isReturn(result2) ? result2.value : isBranch(result2) ? result2.returnedValue : isThrow(result2) ? T2.never : result2;
-    const throws = isThrow(result2) ? result2.thrown : T2.never;
-    const throwLoc = isThrow(result2) ? result2.loc : void 0;
-    const wrapped2 = isAsync ? T2.promise(value2) : value2;
-    callMemo.set(memoKey, wrapped2);
-    return { value: wrapped2, throws, throwLoc };
-  }
-  const result = evaluate(fn.body, callEnv);
-  _unreachableRanges = savedUnreachable;
-  if (isThrow(result)) {
-    return { value: T2.never, throws: result.thrown, throwLoc: result.loc };
-  }
-  const value = isReturn(result) ? result.value : isBranch(result) ? result.returnedValue : result;
-  const wrapped = isAsync ? T2.promise(value) : value;
-  return { value: wrapped, throws: T2.never };
-}
-function callFunction(fn, args) {
-  return callFunctionFull(fn, args).value;
-}
-function evaluateFunction(fnNode, args, env) {
-  return evaluateFunctionFull(fnNode, args, env).value;
-}
-function evaluateFunctionFull(fnNode, args, env) {
-  if (fnNode.type === "FunctionDeclaration" || fnNode.type === "FunctionExpression") {
-    const callEnv = env.extend({});
-    const isAsync = !!fnNode.async;
-    for (let i = 0; i < fnNode.params.length; i++) {
-      bindPattern(fnNode.params[i], args[i] ?? T2.undefined, callEnv);
-    }
-    const result = evaluate(fnNode.body, callEnv);
-    if (isThrow(result)) return { value: T2.never, throws: result.thrown, throwLoc: result.loc };
-    const value = isReturn(result) ? result.value : isBranch(result) ? result.returnedValue : result;
-    const wrapped = isAsync ? T2.promise(value) : value;
-    return { value: wrapped, throws: T2.never };
-  }
-  return { value: T2.unknown, throws: T2.never };
-}
-function evaluateProgram(node, env) {
-  const result = evaluate(node, env);
-  if (isReturn(result)) return result.value;
-  if (isBranch(result)) return result.returnedValue;
-  if (isThrow(result)) return T2.never;
-  return result;
-}
-function getUnreachableRanges() {
-  return _unreachableRanges;
-}
-function resetUnreachableRanges() {
-  _unreachableRanges = [];
-}
-function setCurrentFileDir(dir) {
-  currentFileDir = dir;
-}
-
-export {
-  __require,
-  __commonJS,
-  __toESM,
-  narrow,
-  resetMemo,
-  setModuleResolver,
-  setNodeTypeCollector,
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  evaluateProgram,
-  getUnreachableRanges,
-  resetUnreachableRanges,
-  setCurrentFileDir
-};