npm - @chenglou/freerange - Versions diffs - 0.0.2 → 0.0.4 - Mend

@chenglou/freerange 0.0.2 → 0.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/CHANGELOG.md +14 -0
package/README.md +232 -66
package/dist/fr.js +627 -480
package/package.json +1 -1
package/src/audit.ts +2 -3
package/src/domain/value-identity.ts +56 -0
package/src/engine/analyze.ts +19 -12
package/src/engine/state.ts +23 -11
package/src/engine/transfer.ts +78 -29
package/src/ir/instructions.ts +7 -1
package/src/ir/program.ts +7 -3
package/src/lower/accept.ts +6 -2
package/src/lower/context.ts +14 -5
package/src/lower/expression.ts +106 -88
package/src/lower/function-unit.ts +64 -0
package/src/lower/module.ts +28 -9
package/src/lower/numeric-intersection.ts +15 -0
package/src/lower/platform.ts +28 -12
package/src/lower/program.ts +66 -41
package/src/lower/statements.ts +5 -18
package/src/lower/static-intrinsics.ts +9 -8
package/src/project.ts +3 -3
package/src/report/index.ts +2 -2
package/src/requirements/infer.ts +76 -25
package/src/typescript/check.ts +2 -2

package/dist/fr.js CHANGED Viewed

@@ -3,7 +3,7 @@
 // src/project.ts
 import { existsSync, realpathSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
-import * as ts12 from "typescript";
+import * as ts14 from "typescript";
 // src/domain/number.ts
 var float64Scratch = new Float64Array(1);
@@ -663,6 +663,7 @@ function declaredKindOf(category) {
     case "kind":
       return category.declaredKind;
     case "importedConstant":
+    case "function":
     case "import":
     case "opaque":
       return null;
@@ -775,20 +776,61 @@ function siteLocation(program, site) {
   return { line: low + 1, column: span.start - lineStarts[low] + 1 };
 }
-// src/requirements/infer.ts
-function createExpressionContext(fn, parameterExpressions, parameterIdentityKeys, identityNamespace = `${fn.name}/`) {
-  const identityKeys = parameterIdentityKeys ?? fn.parameters.map((_, index) => `p${index}`);
-  if (identityKeys.length !== fn.parameters.length) {
-    throw new Error(`Expected ${fn.parameters.length} parameter identity keys for ${fn.name}`);
+// src/domain/value-identity.ts
+function createValueIdentityOwner(parent = null) {
+  return { kind: "valueIdentityOwner", parent };
+}
+function sameValueIdentity(left, right) {
+  if (left === right)
+    return true;
+  if (left.kind !== right.kind)
+    return false;
+  switch (left.kind) {
+    case "local":
+      return right.kind === "local" && left.owner === right.owner && left.value === right.value;
+    case "property":
+      return right.kind === "property" && left.property === right.property && sameValueIdentity(left.object, right.object);
+    case "arrayIndex":
+      return right.kind === "arrayIndex" && sameValueIdentity(left.array, right.array) && sameValueIdentity(left.index, right.index);
   }
+}
+function valueIdentityUsesOwner(identity, owner) {
+  switch (identity.kind) {
+    case "local": {
+      let current = identity.owner;
+      while (current != null) {
+        if (current === owner)
+          return true;
+        current = current.parent;
+      }
+      return false;
+    }
+    case "property":
+      return valueIdentityUsesOwner(identity.object, owner);
+    case "arrayIndex":
+      return valueIdentityUsesOwner(identity.array, owner) || valueIdentityUsesOwner(identity.index, owner);
+  }
+}
+// src/requirements/infer.ts
+function createExpressionContext(fn, parameterExpressions, parameterIdentities, identityOwner = createValueIdentityOwner()) {
   const context = {
     parameterExpressions,
-    parameterIdentityKeys: identityKeys,
-    identityNamespace,
+    parameterIdentities: [],
+    identityOwner,
+    identityByValue: [],
     parameterIndexByValue: [],
     instructionByValue: [],
     instructionCount: 0
   };
+  context.parameterIdentities = parameterIdentities ?? fn.parameters.map((parameter) => ({
+    kind: "local",
+    owner: identityOwner,
+    value: parameter.value
+  }));
+  if (context.parameterIdentities.length !== fn.parameters.length) {
+    throw new Error(`Expected ${fn.parameters.length} parameter identities for ${fn.name}`);
+  }
   for (let index = 0;index < fn.parameters.length; index++) {
     context.parameterIndexByValue[fn.parameters[index].value] = index;
   }
@@ -891,28 +933,58 @@ function staticRequirement(instruction, site, context, purpose) {
   }
   return null;
 }
-function canonicalValueKey(value, context) {
+function canonicalValueIdentity(value, context) {
+  const cached = context.identityByValue[value];
+  if (cached != null)
+    return cached;
   const stored = resolveStoredValue(value, context);
-  if (stored !== value)
-    return canonicalValueKey(stored, context);
+  if (stored !== value) {
+    const identity2 = canonicalValueIdentity(stored, context);
+    context.identityByValue[value] = identity2;
+    return identity2;
+  }
   const parameterIndex = context.parameterIndexByValue[value];
-  if (parameterIndex != null)
-    return context.parameterIdentityKeys[parameterIndex] ?? `p${parameterIndex}`;
+  if (parameterIndex != null) {
+    const identity2 = context.parameterIdentities[parameterIndex];
+    if (identity2 == null)
+      throw new Error(`Missing identity for parameter ${parameterIndex}`);
+    context.identityByValue[value] = identity2;
+    return identity2;
+  }
   const producer = context.instructionByValue[value];
+  let identity;
   if (producer?.kind === "property") {
-    return `${canonicalValueKey(producer.object, context)}.${JSON.stringify(producer.property)}`;
-  }
-  if (producer?.kind === "arrayLength")
-    return `${canonicalValueKey(producer.array, context)}.length`;
-  if (producer?.kind === "stringLength")
-    return `${canonicalValueKey(producer.value, context)}.length`;
-  if (producer?.kind === "arrayIndex") {
-    return `${canonicalValueKey(producer.array, context)}[${canonicalValueKey(producer.index, context)}]`;
+    identity = {
+      kind: "property",
+      object: canonicalValueIdentity(producer.object, context),
+      property: producer.property
+    };
+  } else if (producer?.kind === "arrayLength") {
+    identity = {
+      kind: "property",
+      object: canonicalValueIdentity(producer.array, context),
+      property: "length"
+    };
+  } else if (producer?.kind === "stringLength") {
+    identity = {
+      kind: "property",
+      object: canonicalValueIdentity(producer.value, context),
+      property: "length"
+    };
+  } else if (producer?.kind === "arrayIndex") {
+    identity = {
+      kind: "arrayIndex",
+      array: canonicalValueIdentity(producer.array, context),
+      index: canonicalValueIdentity(producer.index, context)
+    };
+  } else {
+    identity = { kind: "local", owner: context.identityOwner, value };
   }
-  return `v:${context.identityNamespace}${value}`;
+  context.identityByValue[value] = identity;
+  return identity;
 }
 function sameRuntimeValue(left, right, context) {
-  return left === right || canonicalValueKey(left, context) === canonicalValueKey(right, context);
+  return left === right || sameValueIdentity(canonicalValueIdentity(left, context), canonicalValueIdentity(right, context));
 }
 function addPrecondition(preconditions, candidate) {
   if (candidate.kind === "declaredNumberCheck") {
@@ -1078,10 +1150,10 @@ function completedEvaluation(evaluation) {
 // src/engine/state.ts
 function hasNonzeroFact(facts, value) {
-  return facts.some((fact) => fact.kind === "nonzero" && fact.value === value);
+  return facts.some((fact) => fact.kind === "nonzero" && sameValueIdentity(fact.value, value));
 }
 function hasIndexFact(facts, kind, index, array) {
-  return facts.some((fact) => fact.kind === kind && fact.index === index && fact.array === array);
+  return facts.some((fact) => fact.kind === kind && sameValueIdentity(fact.index, index) && sameValueIdentity(fact.array, array));
 }
 function addValueFact(facts, candidate) {
   if (!facts.some((fact) => sameValueFact(fact, candidate)))
@@ -1103,18 +1175,19 @@ function intersectValueFact(left, right) {
     return left;
   if (left.kind === "nonzero" || right.kind === "nonzero")
     return null;
-  if (left.index !== right.index || left.array !== right.array)
+  if (!sameValueIdentity(left.index, right.index) || !sameValueIdentity(left.array, right.array))
     return null;
   return { kind: "belowLength", index: left.index, array: left.array };
 }
 function sameValueFact(left, right) {
   if (left.kind !== right.kind)
     return false;
-  if (left.kind === "nonzero" && right.kind === "nonzero")
-    return left.value === right.value;
+  if (left.kind === "nonzero" && right.kind === "nonzero") {
+    return sameValueIdentity(left.value, right.value);
+  }
   if (left.kind === "nonzero" || right.kind === "nonzero")
     return false;
-  return left.index === right.index && left.array === right.array;
+  return sameValueIdentity(left.index, right.index) && sameValueIdentity(left.array, right.array);
 }
 function emptySharedState(moduleCount) {
   return Array.from({ length: moduleCount }, () => null);
@@ -1268,10 +1341,10 @@ function evaluateInstructionKinded(instruction, state, context) {
       const index = requiredNumberWithFacts(state, instruction.index, context.expressionContext);
       const element = sequence.kind === "tuple" ? tupleElement(sequence, index) : sequence.element;
       const length = sequence.kind === "tuple" ? constantNumber(sequence.elements.length) : sequence.length;
-      const indexKey = canonicalValueKey(instruction.index, context.expressionContext);
-      const arrayKey = canonicalValueKey(instruction.array, context.expressionContext);
-      const assumedValid = hasIndexFact(state.valueFacts, "validIndex", indexKey, arrayKey);
-      const inBounds = assumedValid || index.integer && !index.mayBeNaN && index.lower >= 0 && index.upper < length.lower || index.integer && !index.mayBeNaN && index.lower >= 0 && hasIndexFact(state.valueFacts, "belowLength", indexKey, arrayKey);
+      const indexIdentity = canonicalValueIdentity(instruction.index, context.expressionContext);
+      const arrayIdentity = canonicalValueIdentity(instruction.array, context.expressionContext);
+      const assumedValid = hasIndexFact(state.valueFacts, "validIndex", indexIdentity, arrayIdentity);
+      const inBounds = assumedValid || index.integer && !index.mayBeNaN && index.lower >= 0 && index.upper < length.lower || index.integer && !index.mayBeNaN && index.lower >= 0 && hasIndexFact(state.valueFacts, "belowLength", indexIdentity, arrayIdentity);
       const firstPossibleIndex = Math.ceil(Math.max(index.lower, 0));
       const lastPossibleIndex = Math.floor(Math.min(index.upper, length.upper - 1));
       const provablyOut = element == null || firstPossibleIndex > lastPossibleIndex;
@@ -1298,7 +1371,11 @@ function evaluateInstructionKinded(instruction, state, context) {
           addBoundsAssumption(context.boundsAssumptions, { site: instruction.site, kind: "elementInBounds" });
         }
         writeThroughProducers(state, instruction.index, validIndexNumber(index), context.expressionContext.instructionByValue);
-        addValueFact(state.valueFacts, { kind: "validIndex", index: indexKey, array: arrayKey });
+        addValueFact(state.valueFacts, {
+          kind: "validIndex",
+          index: indexIdentity,
+          array: arrayIdentity
+        });
       }
       return passthroughValue(element);
     }
@@ -1507,6 +1584,15 @@ function evaluateInstructionKinded(instruction, state, context) {
       return computedNumber(maximumNumbers(operands), operands, instruction.site);
     }
     case "call": {
+      if (instruction.binding != null && state.shared[instruction.binding] == null) {
+        return {
+          kind: "stop",
+          stop: {
+            site: instruction.site,
+            reason: { kind: "moduleRead", binding: instruction.binding }
+          }
+        };
+      }
       const callee = context.program.functions[instruction.function];
       if (callee == null)
         throw new Error(`Unknown function ${instruction.function}`);
@@ -1518,9 +1604,9 @@ function evaluateInstructionKinded(instruction, state, context) {
       }
       const arguments_ = instruction.arguments.map((id) => requiredValue(state, id));
       const argumentExpressions = instruction.arguments.map((id) => numericExpression(id, context.expressionContext));
-      const argumentKeys = instruction.arguments.map((id) => canonicalValueKey(id, context.expressionContext));
-      const calleeNamespace = `${context.expressionContext.identityNamespace}call:${instruction.function}:${instruction.site}/`;
-      const evaluation = context.evaluateFunction(instruction.function, arguments_, argumentExpressions, state.shared, context.callStack, state.valueFacts, argumentKeys, calleeNamespace);
+      const argumentIdentities = instruction.arguments.map((id) => canonicalValueIdentity(id, context.expressionContext));
+      const calleeOwner = createValueIdentityOwner(context.expressionContext.identityOwner);
+      const evaluation = context.evaluateFunction(instruction.function, arguments_, argumentExpressions, state.shared, context.callStack, state.valueFacts, argumentIdentities, calleeOwner);
       const completed = completedEvaluation(evaluation);
       if (completed == null) {
         if (evaluation.stops.length === 0 && evaluation.normal == null) {
@@ -1541,7 +1627,7 @@ function evaluateInstructionKinded(instruction, state, context) {
         return { kind: "stop", stop: { site: instruction.site, reason: { kind: "calleeStopped", callee: instruction.function } } };
       }
       state.shared = completed.sharedState;
-      state.valueFacts = completed.valueFacts.filter((fact) => !valueFactUsesNamespace(fact, calleeNamespace));
+      state.valueFacts = completed.valueFacts.filter((fact) => !valueFactUsesOwner(fact, calleeOwner));
       for (let index = 0;index < callee.parameters.length; index++) {
         refineFiniteCallArgument(state, instruction.arguments[index], callee.parameters[index].type, context.expressionContext);
       }
@@ -1583,11 +1669,10 @@ function addBoundsAssumption(assumptions, candidate) {
     assumptions.push(candidate);
   }
 }
-function valueFactUsesNamespace(fact, namespace) {
-  const marker = `v:${namespace}`;
+function valueFactUsesOwner(fact, owner) {
   if (fact.kind === "nonzero")
-    return fact.value.includes(marker);
-  return fact.index.includes(marker) || fact.array.includes(marker);
+    return valueIdentityUsesOwner(fact.value, owner);
+  return valueIdentityUsesOwner(fact.index, owner) || valueIdentityUsesOwner(fact.array, owner);
 }
 function sentinelsAdmit(sentinels, sentinel) {
   return sentinels === "both" || sentinels === sentinel;
@@ -1947,8 +2032,8 @@ function refineComparison(state, comparison, truth, expressionContext) {
     if (rightProducer?.kind === "arrayLength") {
       addValueFact(result.valueFacts, {
         kind: "belowLength",
-        index: canonicalValueKey(comparison.left, expressionContext),
-        array: canonicalValueKey(rightProducer.array, expressionContext)
+        index: canonicalValueIdentity(comparison.left, expressionContext),
+        array: canonicalValueIdentity(rightProducer.array, expressionContext)
       });
     }
   }
@@ -1957,8 +2042,8 @@ function refineComparison(state, comparison, truth, expressionContext) {
     if (leftProducer?.kind === "arrayLength") {
       addValueFact(result.valueFacts, {
         kind: "belowLength",
-        index: canonicalValueKey(comparison.right, expressionContext),
-        array: canonicalValueKey(leftProducer.array, expressionContext)
+        index: canonicalValueIdentity(comparison.right, expressionContext),
+        array: canonicalValueIdentity(leftProducer.array, expressionContext)
       });
     }
   }
@@ -2013,12 +2098,13 @@ function numberWithFacts(state, id, expressionContext) {
   if (held?.kind !== "number")
     return null;
   let result = held;
-  const key = canonicalValueKey(id, expressionContext);
-  if (state.valueFacts.some((fact) => fact.kind === "validIndex" && fact.index === key)) {
+  const identity = canonicalValueIdentity(id, expressionContext);
+  if (state.valueFacts.some((fact) => fact.kind === "validIndex" && sameValueIdentity(fact.index, identity))) {
     result = validIndexNumber(result);
   }
-  if (hasNonzeroFact(state.valueFacts, key))
+  if (hasNonzeroFact(state.valueFacts, identity)) {
     result = excludePointFrom(result, constantNumber(0));
+  }
   return result;
 }
 function validIndexNumber(value2) {
@@ -2040,7 +2126,10 @@ function recordNonzeroComparisonFacts(state, check, expressionContext) {
   }
 }
 function recordNonzeroValueFact(state, value2, expressionContext) {
-  addValueFact(state.valueFacts, { kind: "nonzero", value: canonicalValueKey(value2, expressionContext) });
+  addValueFact(state.valueFacts, {
+    kind: "nonzero",
+    value: canonicalValueIdentity(value2, expressionContext)
+  });
 }
 function requiredBoolean(state, id) {
   const value2 = requiredValue(state, id);
@@ -2431,7 +2520,7 @@ function analyzeProgram(program) {
       initializerState[binding] = constantNumber(category.value);
     }
   }
-  const initializer = runEvaluation(program.initializer, null, [], [], initializerState, program, [], { identityNamespace: "module/" });
+  const initializer = runEvaluation(program.initializer, null, [], [], initializerState, program, []);
   const moduleValues = publishedModuleValues(program, initializer.run, initializer.evaluation);
   const functionEntrySharedState = seedModuleSlots(program, moduleValues);
   const moduleReads = transitiveModuleBindings(functionUsage(program));
@@ -2452,8 +2541,7 @@ function analyzeProgram(program) {
       argumentExpressions.push({ kind: "parameter", index });
     }
     const { evaluation } = runEvaluation(fn, functionID, arguments_, argumentExpressions, sharedState, program, [], {
-      boundsAssumptions: moduleReads[functionID].size > 0 ? initializerBounds : [],
-      identityNamespace: `function:${functionID}/`
+      boundsAssumptions: moduleReads[functionID].size > 0 ? initializerBounds : []
     });
     functions.push(publishedAnalysis(fn, evaluation));
   }
@@ -2567,9 +2655,9 @@ function publishedModuleValues(program, run, evaluation) {
   }
   const fullyAnalyzed = evaluation.stops.length === 0 && program.initializerSkips.length === 0 && program.functions.every((lowered) => lowered.kind === "lowered");
   return program.moduleBindings.map((binding, index) => {
-    if (binding.category.kind !== "value" || demoted.has(index))
+    if (binding.category.kind !== "value" && binding.category.kind !== "function" || demoted.has(index))
       return null;
-    if (holdsMutableStructure(binding.category.declaredKind) && !fullyAnalyzed)
+    if (binding.category.kind === "value" && holdsMutableStructure(binding.category.declaredKind) && !fullyAnalyzed)
       return null;
     const slot = end?.[index];
     return slot ?? null;
@@ -2588,7 +2676,7 @@ function runEvaluation(fn, functionID, arguments_, argumentExpressions, sharedSt
   for (let index = 0;index < fn.parameters.length; index++) {
     initial.values[fn.parameters[index].value] = arguments_[index];
   }
-  const expressionContext = createExpressionContext(fn, argumentExpressions, seed.parameterIdentityKeys, seed.identityNamespace ?? fn.name);
+  const expressionContext = createExpressionContext(fn, argumentExpressions, seed.parameterIdentities, seed.identityOwner);
   const preconditions = [];
   const boundsAssumptions = [...seed.boundsAssumptions ?? []];
   const successors = blockSuccessors(fn);
@@ -2607,13 +2695,13 @@ function runEvaluation(fn, functionID, arguments_, argumentExpressions, sharedSt
     expressionContext,
     preconditions,
     boundsAssumptions,
-    evaluateFunction: (callee, values, expressions, calleeState, stack, valueFacts, parameterIdentityKeys, identityNamespace) => {
+    evaluateFunction: (callee, values, expressions, calleeState, stack, valueFacts, parameterIdentities, identityOwner) => {
       const calleeFn = program.functions[callee];
       if (calleeFn == null)
         throw new Error(`Unknown function ${callee}`);
       if (calleeFn.kind !== "lowered")
         throw new Error(`Analysis reached unlowered function ${calleeFn.name}`);
-      return runEvaluation(calleeFn, callee, values, expressions, calleeState, program, stack, { valueFacts, parameterIdentityKeys, identityNamespace }).evaluation;
+      return runEvaluation(calleeFn, callee, values, expressions, calleeState, program, stack, { valueFacts, parameterIdentities, identityOwner }).evaluation;
     }
   };
   let queueIndex = 0;
@@ -2887,17 +2975,18 @@ function reachableFrom(successors, start) {
 }
 // src/lower/program.ts
-import * as ts8 from "typescript";
+import * as ts10 from "typescript";
 // src/lower/accept.ts
 import * as ts from "typescript";
 // src/lower/context.ts
-function createFunctionContext(sourceFile, checker, functionsBySymbol, moduleBindingsBySymbol, sites, staticAnnotations = []) {
+function createFunctionContext(sourceFile, checker, program, functionsBySymbol, moduleBindingsBySymbol, sites, staticAnnotations = [], returnsVoid = true) {
   const entry = { loopHeader: null, parameters: [], instructions: [], terminator: null };
   return {
     sourceFile,
     checker,
+    program,
     functionsBySymbol,
     moduleBindingsBySymbol,
     staticAnnotations: new Map(staticAnnotations.map((annotation) => [annotation.call, annotation])),
@@ -2908,6 +2997,7 @@ function createFunctionContext(sourceFile, checker, functionsBySymbol, moduleBin
     bindings: new Map,
     parameters: [],
     assertions: [],
+    returnsVoid,
     loops: []
   };
 }
@@ -3025,8 +3115,10 @@ function unsupported(node, reason) {
 }
 // src/lower/accept.ts
-function assertAccepted(root) {
+function assertAccepted(root, deferFunctionBodies = false) {
   const visit = (node) => {
+    if (deferFunctionBodies && node !== root && ts.isFunctionLike(node))
+      return;
     if (ts.isTypeNode(node))
       return;
     if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) {
@@ -3101,11 +3193,29 @@ function evalMention(sourceFile) {
 }
 // src/lower/expression.ts
-import * as ts4 from "typescript";
+import * as ts5 from "typescript";
-// src/lower/platform.ts
+// src/lower/numeric-intersection.ts
 import * as ts2 from "typescript";
+function numberConstituent(type) {
+  if ((type.flags & ts2.TypeFlags.NumberLike) !== 0)
+    return type;
+  if (!type.isIntersection())
+    return null;
+  const numberTypes = type.types.filter((member) => (member.flags & ts2.TypeFlags.NumberLike) !== 0);
+  if (numberTypes.length !== 1)
+    return null;
+  for (const member of type.types) {
+    if (member !== numberTypes[0] && (member.flags & ts2.TypeFlags.Object) === 0)
+      return null;
+  }
+  return numberTypes[0];
+}
+// src/lower/platform.ts
+import * as ts3 from "typescript";
 var anyFinite = { lower: -Number.MAX_VALUE, upper: Number.MAX_VALUE };
+var maximumDateTime = 8640000000000000;
 var catalog = [
   { path: ["document", "documentElement", "clientWidth"], call: false, fact: { lower: 0, upper: Number.MAX_VALUE, integer: true } },
   { path: ["document", "documentElement", "clientHeight"], call: false, fact: { lower: 0, upper: Number.MAX_VALUE, integer: true } },
@@ -3116,25 +3226,32 @@ var catalog = [
   { path: ["document", "body", "scrollTop"], call: false, fact: { ...anyFinite, integer: false } },
   { path: ["document", "body", "scrollLeft"], call: false, fact: { ...anyFinite, integer: false } },
   { path: ["performance", "now"], call: true, fact: { lower: 0, upper: Number.MAX_VALUE, integer: false } },
-  { path: ["Date", "now"], call: true, fact: { lower: 0, upper: Number.MAX_VALUE, integer: true } }
+  { path: ["Date", "now"], call: true, fact: { lower: -maximumDateTime, upper: maximumDateTime, integer: true } },
+  { path: ["Math", "random"], call: true, fact: { lower: 0, upper: 0.9999999999999999, integer: false } }
 ];
-function platformFact(expression, call, checker) {
+function platformFact(expression, call, checker, program) {
   const parts = [];
   let current = expression;
-  while (ts2.isPropertyAccessExpression(current)) {
+  while (ts3.isPropertyAccessExpression(current)) {
     parts.unshift(current.name.text);
     current = current.expression;
   }
-  if (!ts2.isIdentifier(current))
+  if (!ts3.isIdentifier(current))
     return null;
   parts.unshift(current.text);
   const entry = catalog.find((candidate) => candidate.call === call && candidate.path.length === parts.length && candidate.path.every((segment, index) => segment === parts[index]));
   if (entry == null)
     return null;
-  if (!declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(current)))
+  if (!hasDefaultLibraryDeclaration(checker.getSymbolAtLocation(current), program))
     return null;
   return entry.fact;
 }
+function hasDefaultLibraryDeclaration(symbol, program) {
+  const declarations = symbol?.declarations;
+  if (declarations == null || declarations.length === 0)
+    return false;
+  return declarations.some((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+}
 function declaredOnlyInDeclarationFiles(symbol) {
   const declarations = symbol?.declarations;
   if (declarations == null || declarations.length === 0)
@@ -3143,16 +3260,16 @@ function declaredOnlyInDeclarationFiles(symbol) {
 }
 // src/lower/literals.ts
-import * as ts3 from "typescript";
+import * as ts4 from "typescript";
 function numericLiteralValue(expression) {
   const current = unwrapLiteral(expression);
-  if (ts3.isNumericLiteral(current))
+  if (ts4.isNumericLiteral(current))
     return Number(current.text);
-  if (ts3.isPrefixUnaryExpression(current) && (current.operator === ts3.SyntaxKind.PlusToken || current.operator === ts3.SyntaxKind.MinusToken)) {
+  if (ts4.isPrefixUnaryExpression(current) && (current.operator === ts4.SyntaxKind.PlusToken || current.operator === ts4.SyntaxKind.MinusToken)) {
     const operand = unwrapLiteral(current.operand);
-    if (!ts3.isNumericLiteral(operand))
+    if (!ts4.isNumericLiteral(operand))
       return null;
-    return Number(operand.text) * (current.operator === ts3.SyntaxKind.MinusToken ? -1 : 1);
+    return Number(operand.text) * (current.operator === ts4.SyntaxKind.MinusToken ? -1 : 1);
   }
   return null;
 }
@@ -3161,13 +3278,13 @@ function parameterDefaultLiteral(initializer, checker) {
   const number = numericLiteralValue(current);
   if (number != null)
     return Number.isFinite(number) ? { kind: "number", value: number } : null;
-  if (current.kind === ts3.SyntaxKind.TrueKeyword || current.kind === ts3.SyntaxKind.FalseKeyword) {
-    return { kind: "boolean", value: current.kind === ts3.SyntaxKind.TrueKeyword };
+  if (current.kind === ts4.SyntaxKind.TrueKeyword || current.kind === ts4.SyntaxKind.FalseKeyword) {
+    return { kind: "boolean", value: current.kind === ts4.SyntaxKind.TrueKeyword };
   }
-  if (ts3.isStringLiteral(current) || ts3.isNoSubstitutionTemplateLiteral(current)) {
+  if (ts4.isStringLiteral(current) || ts4.isNoSubstitutionTemplateLiteral(current)) {
     return { kind: "opaque", content: current.text };
   }
-  if (current.kind === ts3.SyntaxKind.NullKeyword)
+  if (current.kind === ts4.SyntaxKind.NullKeyword)
     return { kind: "nullish", sentinel: "null" };
   if (isUndefinedGlobal(current, checker)) {
     return { kind: "nullish", sentinel: "undefined" };
@@ -3175,10 +3292,10 @@ function parameterDefaultLiteral(initializer, checker) {
   return null;
 }
 function isUndefinedGlobal(expression, checker) {
-  if (!ts3.isIdentifier(expression) || expression.text !== "undefined")
+  if (!ts4.isIdentifier(expression) || expression.text !== "undefined")
     return false;
   const symbol = checker.getSymbolAtLocation(expression);
-  const global = checker.resolveName("undefined", undefined, ts3.SymbolFlags.Value, false);
+  const global = checker.resolveName("undefined", undefined, ts4.SymbolFlags.Value, false);
   return symbol != null && symbol === global;
 }
 function parameterDefaultFits(default_, declared) {
@@ -3207,7 +3324,7 @@ function parameterDefaultFits(default_, declared) {
 }
 function unwrapLiteral(expression) {
   let current = expression;
-  while (ts3.isParenthesizedExpression(current) || ts3.isAsExpression(current) || ts3.isTypeAssertionExpression(current))
+  while (ts4.isParenthesizedExpression(current) || ts4.isAsExpression(current) || ts4.isTypeAssertionExpression(current))
     current = current.expression;
   return current;
 }
@@ -3257,7 +3374,7 @@ function lowerStatementExpression(expression, context) {
         return;
       }
       case "compound": {
-        if (assignment.operator === "add" && (context.checker.getTypeAtLocation(current).flags & ts4.TypeFlags.StringLike) !== 0) {
+        if (assignment.operator === "add" && (context.checker.getTypeAtLocation(current).flags & ts5.TypeFlags.StringLike) !== 0) {
           lowerExpression(assignment.node.right, context);
           const concatenated = addInstruction(context, current, { kind: "opaqueConstant" });
           assignIdentifier(symbol, assignment.target, concatenated, current, context);
@@ -3276,7 +3393,7 @@ function lowerStatementExpression(expression, context) {
         const one = addInstruction(context, current, { kind: "constant", value: 1 });
         const value2 = addInstruction(context, current, {
           kind: "binary",
-          operator: assignment.node.operator === ts4.SyntaxKind.PlusPlusToken ? "add" : "subtract",
+          operator: assignment.node.operator === ts5.SyntaxKind.PlusPlusToken ? "add" : "subtract",
           left: previous,
           right: one
         });
@@ -3289,43 +3406,43 @@ function lowerStatementExpression(expression, context) {
 }
 function lowerExpression(expression, context) {
   const current = unwrap(expression, context.checker);
-  if (ts4.isNumericLiteral(current)) {
+  if (ts5.isNumericLiteral(current)) {
     return addInstruction(context, current, { kind: "constant", value: Number(current.text) });
   }
-  if (current.kind === ts4.SyntaxKind.TrueKeyword || current.kind === ts4.SyntaxKind.FalseKeyword) {
-    return addInstruction(context, current, { kind: "booleanConstant", value: current.kind === ts4.SyntaxKind.TrueKeyword });
+  if (current.kind === ts5.SyntaxKind.TrueKeyword || current.kind === ts5.SyntaxKind.FalseKeyword) {
+    return addInstruction(context, current, { kind: "booleanConstant", value: current.kind === ts5.SyntaxKind.TrueKeyword });
   }
-  if (ts4.isPrefixUnaryExpression(current) && current.operator === ts4.SyntaxKind.PlusToken) {
+  if (ts5.isPrefixUnaryExpression(current) && current.operator === ts5.SyntaxKind.PlusToken) {
     const positive = unwrap(current.operand, context.checker);
-    if (ts4.isNumericLiteral(positive)) {
+    if (ts5.isNumericLiteral(positive)) {
       return addInstruction(context, current, { kind: "constant", value: Number(positive.text) });
     }
-    throw unsupported(current, { kind: "expressionForm", syntax: ts4.SyntaxKind[current.kind] });
+    throw unsupported(current, { kind: "expressionForm", syntax: ts5.SyntaxKind[current.kind] });
   }
-  if (ts4.isPrefixUnaryExpression(current) && current.operator === ts4.SyntaxKind.MinusToken) {
+  if (ts5.isPrefixUnaryExpression(current) && current.operator === ts5.SyntaxKind.MinusToken) {
     const negated = unwrap(current.operand, context.checker);
-    if (ts4.isNumericLiteral(negated)) {
+    if (ts5.isNumericLiteral(negated)) {
       return addInstruction(context, current, { kind: "constant", value: -Number(negated.text) });
     }
-    if (isGlobalInfinity(negated, context.checker)) {
+    if (isStandardGlobal(negated, "Infinity", context)) {
       return addInstruction(context, current, { kind: "constant", value: Number.NEGATIVE_INFINITY });
     }
     const zero = addInstruction(context, current, { kind: "constant", value: 0 });
     const value2 = lowerExpression(current.operand, context);
     return addInstruction(context, current, { kind: "binary", operator: "subtract", left: zero, right: value2 });
   }
-  if (ts4.isPrefixUnaryExpression(current) && current.operator === ts4.SyntaxKind.ExclamationToken) {
+  if (ts5.isPrefixUnaryExpression(current) && current.operator === ts5.SyntaxKind.ExclamationToken) {
     requireBooleanCondition(current.operand, context.checker);
     const value2 = lowerExpression(current.operand, context);
     return addInstruction(context, current, { kind: "not", value: value2 });
   }
-  if (ts4.isConditionalExpression(current)) {
+  if (ts5.isConditionalExpression(current)) {
     return lowerConditionalExpression(current, context);
   }
-  if (ts4.isIdentifier(current)) {
+  if (ts5.isIdentifier(current)) {
     return identifierValue(requiredSymbol(current, context.checker), current, context);
   }
-  if (ts4.isArrayLiteralExpression(current)) {
+  if (ts5.isArrayLiteralExpression(current)) {
     const literalType = context.checker.getTypeAtLocation(current);
     const literalKind = valueKind(literalType, context.checker);
     if (literalKind !== "array" && literalKind !== "tuple" && current.elements.length > 0) {
@@ -3333,23 +3450,23 @@ function lowerExpression(expression, context) {
     }
     const elements = [];
     for (const element of current.elements) {
-      if (ts4.isSpreadElement(element) || ts4.isOmittedExpression(element)) {
-        throw unsupported(element, { kind: "expressionForm", syntax: ts4.SyntaxKind[element.kind] });
+      if (ts5.isSpreadElement(element) || ts5.isOmittedExpression(element)) {
+        throw unsupported(element, { kind: "expressionForm", syntax: ts5.SyntaxKind[element.kind] });
       }
       elements.push(lowerExpression(element, context));
     }
     return addInstruction(context, current, { kind: "arrayLiteral", elements, form: literalKind === "tuple" ? "tuple" : "array" });
   }
-  if (ts4.isNonNullExpression(current) && ts4.isElementAccessExpression(current.expression)) {
+  if (ts5.isNonNullExpression(current) && ts5.isElementAccessExpression(current.expression)) {
     return lowerElementAccess(current.expression, true, context);
   }
-  if (ts4.isElementAccessExpression(current)) {
+  if (ts5.isElementAccessExpression(current)) {
     return lowerElementAccess(current, false, context);
   }
-  if (ts4.isObjectLiteralExpression(current)) {
+  if (ts5.isObjectLiteralExpression(current)) {
     const properties = new Map;
     for (const property of current.properties) {
-      if (ts4.isShorthandPropertyAssignment(property)) {
+      if (ts5.isShorthandPropertyAssignment(property)) {
         const symbol = context.checker.getShorthandAssignmentValueSymbol(property);
         if (symbol == null)
           throw unsupported(property, { kind: "missingSymbol" });
@@ -3359,21 +3476,21 @@ function lowerExpression(expression, context) {
         });
         continue;
       }
-      if (ts4.isPropertyAssignment(property)) {
+      if (ts5.isPropertyAssignment(property)) {
         const name = propertyName(property.name);
         if (name === "__proto__")
           throw unsupported(property, { kind: "protoProperty" });
         properties.set(name, { name, value: lowerExpression(property.initializer, context) });
         continue;
       }
-      if (ts4.isSpreadAssignment(property))
+      if (ts5.isSpreadAssignment(property))
         throw unsupported(property, { kind: "objectSpread" });
       throw unsupported(property, { kind: "objectPropertyForm" });
     }
     const contextual = context.checker.getContextualType(current);
     const fillOptionalsFrom = (recordType) => {
       for (const member of context.checker.getPropertiesOfType(recordType)) {
-        if ((member.flags & ts4.SymbolFlags.Optional) === 0 || properties.has(member.name))
+        if ((member.flags & ts5.SymbolFlags.Optional) === 0 || properties.has(member.name))
           continue;
         const absent = addInstruction(context, current, { kind: "nullishConstant", sentinel: "undefined" });
         properties.set(member.name, { name: member.name, value: absent });
@@ -3406,25 +3523,25 @@ function lowerExpression(expression, context) {
   if (identifierAssignment(current) != null) {
     throw unsupported(current, { kind: "assignmentInValuePosition" });
   }
-  if (ts4.isBinaryExpression(current) && (current.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken || current.operatorToken.kind === ts4.SyntaxKind.BarBarToken)) {
+  if (ts5.isBinaryExpression(current) && (current.operatorToken.kind === ts5.SyntaxKind.AmpersandAmpersandToken || current.operatorToken.kind === ts5.SyntaxKind.BarBarToken)) {
     return lowerLogicalExpression(current, context);
   }
-  if (current.kind === ts4.SyntaxKind.NullKeyword) {
+  if (current.kind === ts5.SyntaxKind.NullKeyword) {
     return addInstruction(context, current, { kind: "nullishConstant", sentinel: "null" });
   }
-  if (ts4.isStringLiteral(current) || ts4.isNoSubstitutionTemplateLiteral(current)) {
+  if (ts5.isStringLiteral(current) || ts5.isNoSubstitutionTemplateLiteral(current)) {
     return addInstruction(context, current, { kind: "opaqueConstant", content: current.text });
   }
-  if (ts4.isAsExpression(current) || ts4.isTypeAssertionExpression(current)) {
+  if (ts5.isAsExpression(current) || ts5.isTypeAssertionExpression(current)) {
     lowerExpression(current.expression, context);
     return addInstruction(context, current, { kind: "opaqueConstant" });
   }
-  if (ts4.isTemplateExpression(current)) {
+  if (ts5.isTemplateExpression(current)) {
     for (const span of current.templateSpans)
       lowerExpression(span.expression, context);
     return addInstruction(context, current, { kind: "opaqueConstant" });
   }
-  if (ts4.isBinaryExpression(current) && current.operatorToken.kind === ts4.SyntaxKind.QuestionQuestionToken) {
+  if (ts5.isBinaryExpression(current) && current.operatorToken.kind === ts5.SyntaxKind.QuestionQuestionToken) {
     const resultType = context.checker.getTypeAtLocation(current);
     if (valueKind(resultType, context.checker) == null) {
       throw unsupported(current, { kind: "valueType", typeText: context.checker.typeToString(resultType) });
@@ -3433,11 +3550,11 @@ function lowerExpression(expression, context) {
     const notMissing = addInstruction(context, current, { kind: "nullishCheck", value: left, sentinel: "nullish", negated: true });
     return lowerValueBranch(current, notMissing, () => left, () => lowerExpression(current.right, context), context);
   }
-  if (ts4.isBinaryExpression(current)) {
+  if (ts5.isBinaryExpression(current)) {
     const missingCheck = missingSentinelCheck(current, context);
     if (missingCheck != null)
       return missingCheck;
-    if (current.operatorToken.kind === ts4.SyntaxKind.InstanceOfKeyword && ts4.isIdentifier(current.right) && declaredOnlyInDeclarationFiles(context.checker.getSymbolAtLocation(current.right))) {
+    if (current.operatorToken.kind === ts5.SyntaxKind.InstanceOfKeyword && ts5.isIdentifier(current.right) && declaredOnlyInDeclarationFiles(context.checker.getSymbolAtLocation(current.right))) {
       lowerExpression(current.left, context);
       return addInstruction(context, current, { kind: "unknownBoolean" });
     }
@@ -3447,7 +3564,7 @@ function lowerExpression(expression, context) {
     const opaqueComparison = opaqueEqualityCheck(current, context);
     if (opaqueComparison != null)
       return opaqueComparison;
-    if (current.operatorToken.kind === ts4.SyntaxKind.PlusToken && (context.checker.getTypeAtLocation(current).flags & ts4.TypeFlags.StringLike) !== 0) {
+    if (current.operatorToken.kind === ts5.SyntaxKind.PlusToken && (context.checker.getTypeAtLocation(current).flags & ts5.TypeFlags.StringLike) !== 0) {
       lowerExpression(current.left, context);
       lowerExpression(current.right, context);
       return addInstruction(context, current, { kind: "opaqueConstant" });
@@ -3468,13 +3585,13 @@ function lowerExpression(expression, context) {
     const right = lowerExpression(current.right, context);
     return arithmetic != null ? addInstruction(context, current, { kind: "binary", operator: arithmetic, left, right }) : addInstruction(context, current, { kind: "compare", operator: comparison, left, right });
   }
-  if (ts4.isCallExpression(current)) {
+  if (ts5.isCallExpression(current)) {
     const staticAnnotation = context.staticAnnotations.get(current);
     if (staticAnnotation != null)
       return lowerStaticAnnotation(staticAnnotation, context);
-    if (ts4.isIdentifier(current.expression)) {
+    if (ts5.isIdentifier(current.expression)) {
       const globalName = current.expression.text;
-      if ((globalName === "parseFloat" || globalName === "parseInt" || globalName === "Number") && declaredOnlyInDeclarationFiles(context.checker.getSymbolAtLocation(current.expression))) {
+      if ((globalName === "parseFloat" || globalName === "parseInt" || globalName === "Number") && isStandardGlobal(current.expression, globalName, context)) {
         for (const argument of current.arguments)
           lowerExpression(argument, context);
         return addInstruction(context, current, { kind: "parsedNumber", integer: globalName === "parseInt" });
@@ -3499,7 +3616,8 @@ function lowerExpression(expression, context) {
             arguments_.push(lowerParameterDefault(default_2, parameter.initializer, context));
             continue;
           }
-          if (parameter.questionToken != null) {
+          const callableParameter = callee.signature?.declaration?.parameters[index];
+          if (callableParameter != null && ts5.isParameter(callableParameter) && callableParameter.questionToken != null) {
             arguments_.push(addInstruction(context, parameter, { kind: "nullishConstant", sentinel: "undefined" }));
             continue;
           }
@@ -3519,15 +3637,20 @@ function lowerExpression(expression, context) {
         });
         arguments_.push(lowerValueBranch(argument, supplied, () => value2, () => lowerParameterDefault(default_, parameter.initializer, context), context));
       }
-      return addInstruction(context, current, { kind: "call", function: callee.id, arguments: arguments_ });
+      return addInstruction(context, current, {
+        kind: "call",
+        function: callee.id,
+        arguments: arguments_,
+        binding: callee.binding
+      });
     }
-    if (ts4.isPropertyAccessExpression(current.expression)) {
-      const platformCall = current.arguments.length === 0 ? platformFact(current.expression, true, context.checker) : null;
+    if (ts5.isPropertyAccessExpression(current.expression)) {
+      const platformCall = current.arguments.length === 0 ? platformFact(current.expression, true, context.checker, context.program) : null;
       if (platformCall != null) {
         return addInstruction(context, current, { kind: "platformValue", ...platformCall });
       }
       const method = current.expression.name.text;
-      const standardMath = isStandardMathObject(current.expression.expression, context.checker);
+      const standardMath = isStandardGlobal(current.expression.expression, "Math", context);
       if (standardMath && method === "floor" && current.arguments.length === 1) {
         requireNumberType(current.arguments[0], context.checker);
         const value2 = lowerExpression(current.arguments[0], context);
@@ -3549,7 +3672,7 @@ function lowerExpression(expression, context) {
         const values = current.arguments.map((argument) => lowerExpression(argument, context));
         return addInstruction(context, current, { kind: method === "min" ? "minimum" : "maximum", values });
       }
-      const standardNumber = isStandardNumberObject(current.expression.expression, context.checker);
+      const standardNumber = isStandardGlobal(current.expression.expression, "Number", context);
       if (standardNumber && (method === "parseFloat" || method === "parseInt") && current.arguments.length >= 1) {
         for (const argument of current.arguments)
           lowerExpression(argument, context);
@@ -3564,7 +3687,7 @@ function lowerExpression(expression, context) {
           value: value2
         });
       }
-      const arrayMethod = ts4.isPropertyAccessExpression(current.expression) && context.checker.isArrayType(context.checker.getTypeAtLocation(current.expression.expression)) ? current.expression.name.text === "reduce" ? "reduce" : "other" : null;
+      const arrayMethod = ts5.isPropertyAccessExpression(current.expression) && context.checker.isArrayType(context.checker.getTypeAtLocation(current.expression.expression)) ? current.expression.name.text === "reduce" ? "reduce" : "other" : null;
       throw unsupported(current, {
         kind: "call",
         callee: calleeDisplayName(current.expression, context.sourceFile),
@@ -3572,8 +3695,8 @@ function lowerExpression(expression, context) {
       });
     }
   }
-  if (ts4.isPropertyAccessExpression(current)) {
-    const platform = platformFact(current, false, context.checker);
+  if (ts5.isPropertyAccessExpression(current)) {
+    const platform = platformFact(current, false, context.checker, context.program);
     if (platform != null) {
       return addInstruction(context, current, { kind: "platformValue", ...platform });
     }
@@ -3591,12 +3714,12 @@ function lowerExpression(expression, context) {
       const array = lowerExpression(current.expression, context);
       return addInstruction(context, current, { kind: "arrayLength", array });
     }
-    if (receiverKind === "opaque" && current.name.text === "length" && (objectType.flags & ts4.TypeFlags.StringLike) !== 0) {
+    if (receiverKind === "opaque" && current.name.text === "length" && (objectType.flags & ts5.TypeFlags.StringLike) !== 0) {
       const value2 = lowerExpression(current.expression, context);
       return addInstruction(context, current, { kind: "stringLength", value: value2 });
     }
-    const receiverSymbol = ts4.isIdentifier(current.expression) ? context.checker.getSymbolAtLocation(current.expression) : undefined;
-    if (receiverSymbol != null && (receiverSymbol.flags & (ts4.SymbolFlags.RegularEnum | ts4.SymbolFlags.ConstEnum)) !== 0) {
+    const receiverSymbol = ts5.isIdentifier(current.expression) ? context.checker.getSymbolAtLocation(current.expression) : undefined;
+    if (receiverSymbol != null && (receiverSymbol.flags & (ts5.SymbolFlags.RegularEnum | ts5.SymbolFlags.ConstEnum)) !== 0) {
       throw unsupported(current, { kind: "enumMemberRead" });
     }
     if (receiverKind !== "object" && receiverKind !== "taggedUnion") {
@@ -3606,7 +3729,7 @@ function lowerExpression(expression, context) {
     const object = lowerExpression(current.expression, context);
     return addInstruction(context, current, { kind: "property", object, property: current.name.text });
   }
-  throw unsupported(current, { kind: "expressionForm", syntax: ts4.SyntaxKind[current.kind] });
+  throw unsupported(current, { kind: "expressionForm", syntax: ts5.SyntaxKind[current.kind] });
 }
 function lowerStaticAnnotation(annotation, context) {
   if (annotation.kind === "invalid") {
@@ -3623,15 +3746,15 @@ function lowerStaticAnnotation(annotation, context) {
     if (requirement == null) {
       throw unsupported(condition, {
         kind: "staticAssertionForm",
-        problem: staticAssertionProblem(condition, context.checker, "callerRequirement")
+        problem: staticAssertionProblem(condition, context, "callerRequirement")
       });
     }
     value2 = lowerWrittenRequirement(requirement, condition, context);
   } else {
-    if (!supportedWrittenAssertion(condition, context.checker)) {
+    if (!supportedWrittenAssertion(condition, context)) {
       throw unsupported(condition, {
         kind: "staticAssertionForm",
-        problem: staticAssertionProblem(condition, context.checker, "directCheck")
+        problem: staticAssertionProblem(condition, context, "directCheck")
       });
     }
     value2 = lowerExpression(condition, context);
@@ -3653,7 +3776,7 @@ function lowerStaticAnnotation(annotation, context) {
 }
 function writtenRequirement(condition, context) {
   const current = unwrapParentheses(condition);
-  if (ts4.isCallExpression(current) && current.questionDotToken == null && current.arguments.length === 1 && ts4.isPropertyAccessExpression(current.expression) && current.expression.questionDotToken == null && isStandardNumberObject(current.expression.expression, context.checker) && (current.expression.name.text === "isInteger" || current.expression.name.text === "isFinite")) {
+  if (ts5.isCallExpression(current) && current.questionDotToken == null && current.arguments.length === 1 && ts5.isPropertyAccessExpression(current.expression) && current.expression.questionDotToken == null && isStandardGlobal(current.expression.expression, "Number", context) && (current.expression.name.text === "isInteger" || current.expression.name.text === "isFinite")) {
     const argument = current.arguments[0];
     const value2 = staticRequirementParameterPathValue(argument, context);
     return value2 == null ? null : {
@@ -3662,7 +3785,7 @@ function writtenRequirement(condition, context) {
       value: value2
     };
   }
-  if (!ts4.isBinaryExpression(current) || !staticAssertionComparison(current.operatorToken.kind))
+  if (!ts5.isBinaryExpression(current) || !staticAssertionComparison(current.operatorToken.kind))
     return null;
   const leftParameter = staticRequirementParameterPathValue(current.left, context);
   const rightParameter = staticRequirementParameterPathValue(current.right, context);
@@ -3678,10 +3801,10 @@ function writtenRequirement(condition, context) {
 function staticRequirementParameterPathValue(expression, context) {
   requireNumberType(expression, context.checker);
   let root = unwrapParentheses(expression);
-  while (ts4.isPropertyAccessExpression(root) && root.questionDotToken == null) {
+  while (ts5.isPropertyAccessExpression(root) && root.questionDotToken == null) {
     root = unwrapParentheses(root.expression);
   }
-  if (!ts4.isIdentifier(root))
+  if (!ts5.isIdentifier(root))
     return null;
   const symbol = context.checker.getSymbolAtLocation(root);
   const rootValue = symbol == null ? null : context.bindings.get(symbol);
@@ -3708,14 +3831,14 @@ function staticFiniteValue(expression, context) {
     if (literal != null)
       return Number.isFinite(literal) ? literal : null;
     const unwrapped = unwrapParentheses(current);
-    if (!ts4.isIdentifier(unwrapped))
+    if (!ts5.isIdentifier(unwrapped))
       return null;
     const symbol = resolvedSymbol(context.checker.getSymbolAtLocation(unwrapped), context.checker);
     if (symbol == null || seen.has(symbol))
       return null;
     seen.add(symbol);
     const declaration = symbol.valueDeclaration;
-    if (declaration == null || !ts4.isVariableDeclaration(declaration) || (ts4.getCombinedNodeFlags(declaration) & ts4.NodeFlags.Const) === 0 || declaration.getSourceFile().isDeclarationFile || declaration.initializer == null)
+    if (declaration == null || !ts5.isVariableDeclaration(declaration) || (ts5.getCombinedNodeFlags(declaration) & ts5.NodeFlags.Const) === 0 || declaration.getSourceFile().isDeclarationFile || declaration.initializer == null)
       return null;
     current = declaration.initializer;
   }
@@ -3740,25 +3863,25 @@ function lowerWrittenRequirement(requirement, condition, context) {
     right: lowerOperand(requirement.right)
   });
 }
-function supportedWrittenAssertion(condition, checker) {
+function supportedWrittenAssertion(condition, context) {
   const current = unwrapParentheses(condition);
-  if (ts4.isBinaryExpression(current) && staticAssertionComparison(current.operatorToken.kind)) {
-    return staticAssertionNumericAtom(current.left, checker) && staticAssertionNumericAtom(current.right, checker);
+  if (ts5.isBinaryExpression(current) && staticAssertionComparison(current.operatorToken.kind)) {
+    return staticAssertionNumericAtom(current.left, context.checker) && staticAssertionNumericAtom(current.right, context.checker);
   }
-  const operand = staticNumberCheckOperand(current, checker);
-  return operand != null && staticAssertionNumericAtom(operand, checker);
+  const operand = staticNumberCheckOperand(current, context);
+  return operand != null && staticAssertionNumericAtom(operand, context.checker);
 }
 function staticAssertionNumericAtom(expression, checker) {
   return staticAssertionAtom(expression) && valueKind(checker.getTypeAtLocation(expression), checker) === "number";
 }
 function staticAssertionComparison(kind) {
   switch (kind) {
-    case ts4.SyntaxKind.LessThanToken:
-    case ts4.SyntaxKind.LessThanEqualsToken:
-    case ts4.SyntaxKind.GreaterThanToken:
-    case ts4.SyntaxKind.GreaterThanEqualsToken:
-    case ts4.SyntaxKind.EqualsEqualsEqualsToken:
-    case ts4.SyntaxKind.ExclamationEqualsEqualsToken:
+    case ts5.SyntaxKind.LessThanToken:
+    case ts5.SyntaxKind.LessThanEqualsToken:
+    case ts5.SyntaxKind.GreaterThanToken:
+    case ts5.SyntaxKind.GreaterThanEqualsToken:
+    case ts5.SyntaxKind.EqualsEqualsEqualsToken:
+    case ts5.SyntaxKind.ExclamationEqualsEqualsToken:
       return true;
     default:
       return false;
@@ -3766,54 +3889,54 @@ function staticAssertionComparison(kind) {
 }
 function staticAssertionAtomProblem(expression) {
   const current = unwrapParentheses(expression);
-  if (ts4.isIdentifier(current) || ts4.isNumericLiteral(current))
+  if (ts5.isIdentifier(current) || ts5.isNumericLiteral(current))
     return null;
-  if (ts4.isPrefixUnaryExpression(current) && (current.operator === ts4.SyntaxKind.PlusToken || current.operator === ts4.SyntaxKind.MinusToken)) {
-    return ts4.isNumericLiteral(unwrapParentheses(current.operand)) ? null : "bindValueFirst";
+  if (ts5.isPrefixUnaryExpression(current) && (current.operator === ts5.SyntaxKind.PlusToken || current.operator === ts5.SyntaxKind.MinusToken)) {
+    return ts5.isNumericLiteral(unwrapParentheses(current.operand)) ? null : "bindValueFirst";
   }
-  if (ts4.isElementAccessExpression(current))
+  if (ts5.isElementAccessExpression(current))
     return "bindValueFirst";
-  if (ts4.isNonNullExpression(current))
+  if (ts5.isNonNullExpression(current))
     return staticAssertionAtomProblem(current.expression);
-  if (ts4.isCallExpression(current))
+  if (ts5.isCallExpression(current))
     return "functionCall";
-  if (ts4.isBinaryExpression(current))
+  if (ts5.isBinaryExpression(current))
     return "bindValueFirst";
-  if (ts4.isPropertyAccessExpression(current)) {
+  if (ts5.isPropertyAccessExpression(current)) {
     return current.questionDotToken == null ? staticAssertionAtomProblem(current.expression) : "directCheck";
   }
   return "directCheck";
 }
 function staticAssertionAtom(expression) {
   const current = unwrapParentheses(expression);
-  if (ts4.isIdentifier(current) || ts4.isNumericLiteral(current))
+  if (ts5.isIdentifier(current) || ts5.isNumericLiteral(current))
     return true;
-  if (ts4.isPrefixUnaryExpression(current) && (current.operator === ts4.SyntaxKind.PlusToken || current.operator === ts4.SyntaxKind.MinusToken)) {
-    return ts4.isNumericLiteral(unwrapParentheses(current.operand));
+  if (ts5.isPrefixUnaryExpression(current) && (current.operator === ts5.SyntaxKind.PlusToken || current.operator === ts5.SyntaxKind.MinusToken)) {
+    return ts5.isNumericLiteral(unwrapParentheses(current.operand));
   }
-  return ts4.isPropertyAccessExpression(current) && current.questionDotToken == null && staticAssertionAtom(current.expression);
+  return ts5.isPropertyAccessExpression(current) && current.questionDotToken == null && staticAssertionAtom(current.expression);
 }
-function staticAssertionProblem(condition, checker, fallback) {
+function staticAssertionProblem(condition, context, fallback) {
   const current = unwrapParentheses(condition);
-  if (ts4.isBinaryExpression(current) && staticAssertionComparison(current.operatorToken.kind)) {
+  if (ts5.isBinaryExpression(current) && staticAssertionComparison(current.operatorToken.kind)) {
     return staticAssertionAtomProblem(current.left) ?? staticAssertionAtomProblem(current.right) ?? fallback;
   }
-  const operand = staticNumberCheckOperand(current, checker);
+  const operand = staticNumberCheckOperand(current, context);
   if (operand != null)
     return staticAssertionAtomProblem(operand) ?? fallback;
-  if (ts4.isCallExpression(current))
+  if (ts5.isCallExpression(current))
     return "functionCall";
   return "directCheck";
 }
-function staticNumberCheckOperand(expression, checker) {
-  if (!ts4.isCallExpression(expression) || expression.questionDotToken != null || expression.arguments.length !== 1 || !ts4.isPropertyAccessExpression(expression.expression) || expression.expression.questionDotToken != null)
+function staticNumberCheckOperand(expression, context) {
+  if (!ts5.isCallExpression(expression) || expression.questionDotToken != null || expression.arguments.length !== 1 || !ts5.isPropertyAccessExpression(expression.expression) || expression.expression.questionDotToken != null)
     return null;
   const callee = expression.expression;
-  return isStandardNumberObject(callee.expression, checker) && (callee.name.text === "isInteger" || callee.name.text === "isFinite" || callee.name.text === "isNaN") ? expression.arguments[0] : null;
+  return isStandardGlobal(callee.expression, "Number", context) && (callee.name.text === "isInteger" || callee.name.text === "isFinite" || callee.name.text === "isNaN") ? expression.arguments[0] : null;
 }
 function unwrapParentheses(expression) {
   let current = expression;
-  while (ts4.isParenthesizedExpression(current))
+  while (ts5.isParenthesizedExpression(current))
     current = current.expression;
   return current;
 }
@@ -3832,30 +3955,30 @@ function removableStaticConditionInstruction(instruction) {
   }
 }
 function identifierAssignment(node) {
-  if (ts4.isBinaryExpression(node) && ts4.isIdentifier(node.left)) {
-    if (node.operatorToken.kind === ts4.SyntaxKind.EqualsToken)
+  if (ts5.isBinaryExpression(node) && ts5.isIdentifier(node.left)) {
+    if (node.operatorToken.kind === ts5.SyntaxKind.EqualsToken)
       return { form: "assign", target: node.left, node };
     const operator = compoundAssignmentOperator(node.operatorToken.kind);
     if (operator != null)
       return { form: "compound", target: node.left, node, operator };
-    const logical = node.operatorToken.kind === ts4.SyntaxKind.QuestionQuestionEqualsToken ? "nullish" : node.operatorToken.kind === ts4.SyntaxKind.BarBarEqualsToken ? "or" : node.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandEqualsToken ? "and" : null;
+    const logical = node.operatorToken.kind === ts5.SyntaxKind.QuestionQuestionEqualsToken ? "nullish" : node.operatorToken.kind === ts5.SyntaxKind.BarBarEqualsToken ? "or" : node.operatorToken.kind === ts5.SyntaxKind.AmpersandAmpersandEqualsToken ? "and" : null;
     if (logical != null)
       return { form: "logical", target: node.left, node, logical };
   }
-  if ((ts4.isPrefixUnaryExpression(node) || ts4.isPostfixUnaryExpression(node)) && (node.operator === ts4.SyntaxKind.PlusPlusToken || node.operator === ts4.SyntaxKind.MinusMinusToken) && ts4.isIdentifier(node.operand)) {
+  if ((ts5.isPrefixUnaryExpression(node) || ts5.isPostfixUnaryExpression(node)) && (node.operator === ts5.SyntaxKind.PlusPlusToken || node.operator === ts5.SyntaxKind.MinusMinusToken) && ts5.isIdentifier(node.operand)) {
     return { form: "update", target: node.operand, node };
   }
   return null;
 }
 function compoundAssignmentOperator(kind) {
   switch (kind) {
-    case ts4.SyntaxKind.PlusEqualsToken:
+    case ts5.SyntaxKind.PlusEqualsToken:
       return "add";
-    case ts4.SyntaxKind.MinusEqualsToken:
+    case ts5.SyntaxKind.MinusEqualsToken:
       return "subtract";
-    case ts4.SyntaxKind.AsteriskEqualsToken:
+    case ts5.SyntaxKind.AsteriskEqualsToken:
       return "multiply";
-    case ts4.SyntaxKind.SlashEqualsToken:
+    case ts5.SyntaxKind.SlashEqualsToken:
       return "divide";
     default:
       return null;
@@ -3871,6 +3994,15 @@ function lowerValueBranch(node, condition, lowerTrueArm, lowerFalseArm, context)
     whenFalse: { block: whenFalse, arguments: [] },
     site: addSite(context, node)
   });
+  return joinValueBranches(node, whenTrue, whenFalse, lowerTrueArm, lowerFalseArm, context);
+}
+function lowerBranchingValue(node, condition, lowerTrueArm, lowerFalseArm, context) {
+  const whenTrue = createBlock(context);
+  const whenFalse = createBlock(context);
+  lowerBranchingCondition(condition, whenTrue, whenFalse, context);
+  return joinValueBranches(node, whenTrue, whenFalse, lowerTrueArm, lowerFalseArm, context);
+}
+function joinValueBranches(node, whenTrue, whenFalse, lowerTrueArm, lowerFalseArm, context) {
   context.currentBlock = context.blocks[whenTrue];
   const trueValue = lowerTrueArm();
   const trueBlock = context.currentBlock;
@@ -3897,33 +4029,12 @@ function lowerConditionalExpression(expression, context) {
   if (valueKind(resultType, context.checker) == null) {
     throw unsupported(expression, { kind: "valueType", typeText: context.checker.typeToString(resultType) });
   }
-  const whenTrue = createBlock(context);
-  const whenFalse = createBlock(context);
-  lowerBranchingCondition(expression.condition, whenTrue, whenFalse, context);
-  context.currentBlock = context.blocks[whenTrue];
-  const trueValue = lowerExpression(expression.whenTrue, context);
-  const trueBlock = context.currentBlock;
-  context.currentBlock = context.blocks[whenFalse];
-  const falseValue = lowerExpression(expression.whenFalse, context);
-  const falseBlock = context.currentBlock;
-  const continuation = createBlock(context, 1);
-  terminate(trueBlock, {
-    kind: "jump",
-    target: { block: continuation, arguments: [trueValue] },
-    site: addSite(context, expression)
-  });
-  terminate(falseBlock, {
-    kind: "jump",
-    target: { block: continuation, arguments: [falseValue] },
-    site: addSite(context, expression)
-  });
-  context.currentBlock = context.blocks[continuation];
-  return context.currentBlock.parameters[0];
+  return lowerBranchingValue(expression, expression.condition, () => lowerExpression(expression.whenTrue, context), () => lowerExpression(expression.whenFalse, context), context);
 }
 function lowerBranchingCondition(expression, whenTrue, whenFalse, context) {
   const current = unwrap(expression, context.checker);
-  if (ts4.isBinaryExpression(current) && (current.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken || current.operatorToken.kind === ts4.SyntaxKind.BarBarToken)) {
-    const isAnd = current.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken;
+  if (ts5.isBinaryExpression(current) && (current.operatorToken.kind === ts5.SyntaxKind.AmpersandAmpersandToken || current.operatorToken.kind === ts5.SyntaxKind.BarBarToken)) {
+    const isAnd = current.operatorToken.kind === ts5.SyntaxKind.AmpersandAmpersandToken;
     const middle = createBlock(context);
     if (isAnd) {
       lowerBranchingCondition(current.left, middle, whenFalse, context);
@@ -3934,7 +4045,7 @@ function lowerBranchingCondition(expression, whenTrue, whenFalse, context) {
     lowerBranchingCondition(current.right, whenTrue, whenFalse, context);
     return;
   }
-  if (ts4.isPrefixUnaryExpression(current) && current.operator === ts4.SyntaxKind.ExclamationToken) {
+  if (ts5.isPrefixUnaryExpression(current) && current.operator === ts5.SyntaxKind.ExclamationToken) {
     lowerBranchingCondition(current.operand, whenFalse, whenTrue, context);
     return;
   }
@@ -3952,21 +4063,20 @@ function lowerBranchingCondition(expression, whenTrue, whenFalse, context) {
 function lowerLogicalExpression(expression, context) {
   requireBooleanCondition(expression.left, context.checker);
   requireBooleanCondition(expression.right, context.checker);
-  const isAnd = expression.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken;
-  const condition = lowerExpression(expression.left, context);
-  return lowerValueBranch(expression, condition, () => isAnd ? lowerExpression(expression.right, context) : addInstruction(context, expression, { kind: "booleanConstant", value: true }), () => isAnd ? addInstruction(context, expression, { kind: "booleanConstant", value: false }) : lowerExpression(expression.right, context), context);
+  const isAnd = expression.operatorToken.kind === ts5.SyntaxKind.AmpersandAmpersandToken;
+  return lowerBranchingValue(expression, expression.left, () => isAnd ? lowerExpression(expression.right, context) : addInstruction(context, expression, { kind: "booleanConstant", value: true }), () => isAnd ? addInstruction(context, expression, { kind: "booleanConstant", value: false }) : lowerExpression(expression.right, context), context);
 }
 function arithmeticOperator(kind) {
   switch (kind) {
-    case ts4.SyntaxKind.PlusToken:
+    case ts5.SyntaxKind.PlusToken:
       return "add";
-    case ts4.SyntaxKind.MinusToken:
+    case ts5.SyntaxKind.MinusToken:
       return "subtract";
-    case ts4.SyntaxKind.AsteriskToken:
+    case ts5.SyntaxKind.AsteriskToken:
       return "multiply";
-    case ts4.SyntaxKind.SlashToken:
+    case ts5.SyntaxKind.SlashToken:
       return "divide";
-    case ts4.SyntaxKind.PercentToken:
+    case ts5.SyntaxKind.PercentToken:
       return "remainder";
     default:
       return null;
@@ -3974,19 +4084,19 @@ function arithmeticOperator(kind) {
 }
 function comparisonOperator(kind) {
   switch (kind) {
-    case ts4.SyntaxKind.LessThanToken:
+    case ts5.SyntaxKind.LessThanToken:
       return "lessThan";
-    case ts4.SyntaxKind.LessThanEqualsToken:
+    case ts5.SyntaxKind.LessThanEqualsToken:
       return "lessThanOrEqual";
-    case ts4.SyntaxKind.GreaterThanToken:
+    case ts5.SyntaxKind.GreaterThanToken:
       return "greaterThan";
-    case ts4.SyntaxKind.GreaterThanEqualsToken:
+    case ts5.SyntaxKind.GreaterThanEqualsToken:
       return "greaterThanOrEqual";
-    case ts4.SyntaxKind.EqualsEqualsToken:
-    case ts4.SyntaxKind.EqualsEqualsEqualsToken:
+    case ts5.SyntaxKind.EqualsEqualsToken:
+    case ts5.SyntaxKind.EqualsEqualsEqualsToken:
       return "equal";
-    case ts4.SyntaxKind.ExclamationEqualsToken:
-    case ts4.SyntaxKind.ExclamationEqualsEqualsToken:
+    case ts5.SyntaxKind.ExclamationEqualsToken:
+    case ts5.SyntaxKind.ExclamationEqualsEqualsToken:
       return "notEqual";
     default:
       return null;
@@ -3994,12 +4104,12 @@ function comparisonOperator(kind) {
 }
 function requireNumberType(node, checker) {
   const type = checker.getTypeAtLocation(node);
-  if (valueKind(type, checker) !== "number" && (type.flags & ts4.TypeFlags.Any) === 0) {
+  if (valueKind(type, checker) !== "number" && (type.flags & ts5.TypeFlags.Any) === 0) {
     throw unsupported(node, { kind: "nonNumberOperand", typeText: checker.typeToString(type) });
   }
 }
 function typeCanIncludeUndefined(type) {
-  if ((type.flags & (ts4.TypeFlags.Undefined | ts4.TypeFlags.Any | ts4.TypeFlags.Unknown)) !== 0)
+  if ((type.flags & (ts5.TypeFlags.Undefined | ts5.TypeFlags.Any | ts5.TypeFlags.Unknown)) !== 0)
     return true;
   return type.isUnion() && type.types.some(typeCanIncludeUndefined);
 }
@@ -4032,19 +4142,19 @@ function valueKind(type, checker, depth = 0) {
   return result;
 }
 function valueKindUncached(type, checker, depth) {
-  if ((type.flags & ts4.TypeFlags.NumberLike) !== 0)
+  if (numberConstituent(type) != null)
     return "number";
-  if ((type.flags & ts4.TypeFlags.BooleanLike) !== 0)
+  if ((type.flags & ts5.TypeFlags.BooleanLike) !== 0)
     return "boolean";
-  if ((type.flags & ts4.TypeFlags.StringLike) !== 0)
+  if ((type.flags & ts5.TypeFlags.StringLike) !== 0)
     return "opaque";
   if (checker.isTupleType(type))
     return "tuple";
   if (checker.isArrayType(type)) {
-    const element = checker.getIndexTypeOfType(type, ts4.IndexKind.Number);
+    const element = checker.getIndexTypeOfType(type, ts5.IndexKind.Number);
     return element != null && valueKind(element, checker, depth + 1) != null ? "array" : null;
   }
-  const objectLike = (type.flags & ts4.TypeFlags.Object) !== 0 || type.isIntersection() && type.types.every((member) => valueKind(member, checker, depth + 1) === "object");
+  const objectLike = (type.flags & ts5.TypeFlags.Object) !== 0 || type.isIntersection() && type.types.every((member) => valueKind(member, checker, depth + 1) === "object");
   if (objectLike) {
     if (checker.getIndexInfosOfType(type).length > 0)
       return null;
@@ -4055,10 +4165,10 @@ function valueKindUncached(type, checker, depth) {
     const anchored = checker.getPropertiesOfType(type).some((property) => checker.getTypeOfSymbol(property).getCallSignatures().length === 0);
     return anchored ? "object" : null;
   }
-  if ((type.flags & (ts4.TypeFlags.Unknown | ts4.TypeFlags.Any)) !== 0)
+  if ((type.flags & (ts5.TypeFlags.Unknown | ts5.TypeFlags.Any)) !== 0)
     return "opaque";
   if (type.isUnion()) {
-    const missingFlags = ts4.TypeFlags.Null | ts4.TypeFlags.Undefined;
+    const missingFlags = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
     if (type.types.some((member) => (member.flags & missingFlags) !== 0)) {
       const rest = nonMissingUnionMembers(type);
       const restKind = classifyUnionMembers(rest, checker, depth + 1);
@@ -4077,7 +4187,7 @@ function nonMissingUnionMembers(type) {
   const cached = nonMissingUnionMembersCache.get(type);
   if (cached != null)
     return cached;
-  const missingFlags = ts4.TypeFlags.Null | ts4.TypeFlags.Undefined;
+  const missingFlags = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
   const members = type.types.filter((member) => (member.flags & missingFlags) === 0);
   nonMissingUnionMembersCache.set(type, members);
   return members;
@@ -4107,7 +4217,7 @@ function taggedUnionPropertyUncached(members, checker, depth) {
   const qualifies = (candidateName, singleLiteralOnly) => {
     for (const member of members) {
       const property = checker.getPropertyOfType(member, candidateName);
-      if (property == null || (property.flags & ts4.SymbolFlags.Optional) !== 0)
+      if (property == null || (property.flags & ts5.SymbolFlags.Optional) !== 0)
         return false;
       const literals = tagLiteralValues(checker.getTypeOfSymbol(property));
       if (literals == null || singleLiteralOnly && literals.length !== 1)
@@ -4117,7 +4227,7 @@ function taggedUnionPropertyUncached(members, checker, depth) {
   };
   for (const singleLiteralOnly of [true, false]) {
     for (const candidate of checker.getPropertiesOfType(first)) {
-      if ((candidate.flags & ts4.SymbolFlags.Optional) !== 0)
+      if ((candidate.flags & ts5.SymbolFlags.Optional) !== 0)
         continue;
       if (qualifies(candidate.name, singleLiteralOnly))
         return candidate.name;
@@ -4126,28 +4236,28 @@ function taggedUnionPropertyUncached(members, checker, depth) {
   return null;
 }
 function calleeDisplayName(expression, sourceFile) {
-  if (ts4.isPropertyAccessExpression(expression)) {
+  if (ts5.isPropertyAccessExpression(expression)) {
     const receiver = expression.expression;
-    const receiverName = ts4.isIdentifier(receiver) ? receiver.text : ts4.isPropertyAccessExpression(receiver) && ts4.isIdentifier(receiver.expression) ? `${receiver.expression.text}.${receiver.name.text}` : "(…)";
+    const receiverName = ts5.isIdentifier(receiver) ? receiver.text : ts5.isPropertyAccessExpression(receiver) && ts5.isIdentifier(receiver.expression) ? `${receiver.expression.text}.${receiver.name.text}` : "(…)";
     return `${receiverName}.${expression.name.text}`;
   }
   return expression.getText(sourceFile).replace(/\s+/g, " ").slice(0, 60);
 }
 function writtenTagLiteral(literal, tagProperty, context) {
-  if (!ts4.isObjectLiteralExpression(literal))
+  if (!ts5.isObjectLiteralExpression(literal))
     return null;
   for (const property of literal.properties) {
-    if (!ts4.isPropertyAssignment(property))
+    if (!ts5.isPropertyAssignment(property))
       continue;
-    const name = ts4.isIdentifier(property.name) || ts4.isStringLiteral(property.name) ? property.name.text : null;
+    const name = ts5.isIdentifier(property.name) || ts5.isStringLiteral(property.name) ? property.name.text : null;
     if (name !== tagProperty)
       continue;
     const initializer = unwrap(property.initializer, context.checker);
-    if (ts4.isStringLiteral(initializer) || ts4.isNoSubstitutionTemplateLiteral(initializer))
+    if (ts5.isStringLiteral(initializer) || ts5.isNoSubstitutionTemplateLiteral(initializer))
       return initializer.text;
-    if (initializer.kind === ts4.SyntaxKind.TrueKeyword)
+    if (initializer.kind === ts5.SyntaxKind.TrueKeyword)
       return true;
-    if (initializer.kind === ts4.SyntaxKind.FalseKeyword)
+    if (initializer.kind === ts5.SyntaxKind.FalseKeyword)
       return false;
     return null;
   }
@@ -4157,7 +4267,7 @@ function tagLiteralValues(type) {
   const single = (member) => {
     if (member.isStringLiteral())
       return member.value;
-    if ((member.flags & ts4.TypeFlags.BooleanLiteral) !== 0) {
+    if ((member.flags & ts5.TypeFlags.BooleanLiteral) !== 0) {
       return member.intrinsicName === "true";
     }
     return null;
@@ -4204,10 +4314,10 @@ function structuralTypeWalkCompletes(type, checker, seen) {
   if (checker.isArrayType(type)) {
     if (seen.length >= 8 || seen.includes(type))
       return false;
-    const element = checker.getIndexTypeOfType(type, ts4.IndexKind.Number);
+    const element = checker.getIndexTypeOfType(type, ts5.IndexKind.Number);
     return element == null || structuralTypeWalkCompletes(element, checker, [...seen, type]);
   }
-  if ((type.flags & ts4.TypeFlags.Object) === 0)
+  if ((type.flags & ts5.TypeFlags.Object) === 0)
     return true;
   if (seen.length >= 8 || seen.includes(type))
     return false;
@@ -4222,7 +4332,7 @@ function structuralTypeWalkCompletes(type, checker, seen) {
 function structuralPropertiesComplete(type, checker, seen) {
   const nextSeen = [...seen, type];
   for (const property of checker.getPropertiesOfType(type)) {
-    if ((property.flags & ts4.SymbolFlags.Optional) !== 0)
+    if ((property.flags & ts5.SymbolFlags.Optional) !== 0)
       continue;
     if (!structuralTypeWalkCompletes(checker.getTypeOfSymbol(property), checker, nextSeen))
       return false;
@@ -4241,12 +4351,6 @@ function requireBooleanCondition(node, checker) {
   });
 }
 function requireAccessedPropertyKind(access, checker) {
-  const receiverType = checker.getTypeAtLocation(access.expression);
-  const presentType = access.questionDotToken != null ? checker.getNonNullableType(receiverType) : receiverType;
-  const property = checker.getPropertyOfType(presentType, access.name.text);
-  if (valueKind(presentType, checker) === "object" && property != null && declaredOnlyInDeclarationFiles(property)) {
-    throw unsupported(access, { kind: "prototypeMemberRead", property: access.name.text });
-  }
   const type = checker.getTypeAtLocation(access);
   if (valueKind(type, checker) != null)
     return;
@@ -4255,17 +4359,12 @@ function requireAccessedPropertyKind(access, checker) {
 function resolvedSymbol(symbol, checker) {
   if (symbol == null)
     return null;
-  return (symbol.flags & ts4.SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);
-}
-function isStandardMathObject(expression, checker) {
-  if (!ts4.isIdentifier(expression) || expression.text !== "Math")
-    return false;
-  return declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(expression));
+  return (symbol.flags & ts5.SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);
 }
-function isStandardNumberObject(expression, checker) {
-  if (!ts4.isIdentifier(expression) || expression.text !== "Number")
+function isStandardGlobal(expression, name, context) {
+  if (!ts5.isIdentifier(expression) || expression.text !== name)
     return false;
-  return declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(expression));
+  return hasDefaultLibraryDeclaration(context.checker.getSymbolAtLocation(expression), context.program);
 }
 function lowerElementAccess(access, asserted, context) {
   const receiverType = context.checker.getTypeAtLocation(access.expression);
@@ -4280,7 +4379,7 @@ function lowerElementAccess(access, asserted, context) {
   requireNumberType(access.argumentExpression, context.checker);
   const array = lowerExpression(access.expression, context);
   const index = lowerExpression(access.argumentExpression, context);
-  const missingFlag = ts4.TypeFlags.Undefined;
+  const missingFlag = ts5.TypeFlags.Undefined;
   const staticTypeAllowsUndefined = (resultType.flags & missingFlag) !== 0 || resultType.isUnion() && resultType.types.some((member) => (member.flags & missingFlag) !== 0);
   return addInstruction(context, access, {
     kind: "arrayIndex",
@@ -4291,7 +4390,7 @@ function lowerElementAccess(access, asserted, context) {
 }
 function taggedUnionTagRead(expression, context) {
   const unwrapped = unwrap(expression, context.checker);
-  if (!ts4.isPropertyAccessExpression(unwrapped))
+  if (!ts5.isPropertyAccessExpression(unwrapped))
     return null;
   const objectType = context.checker.getTypeAtLocation(unwrapped.expression);
   if (valueKind(objectType, context.checker) !== "taggedUnion" || !objectType.isUnion())
@@ -4301,17 +4400,17 @@ function taggedUnionTagRead(expression, context) {
 }
 function tagCheckComparison(expression, context) {
   const operator = expression.operatorToken.kind;
-  const equals = operator === ts4.SyntaxKind.EqualsEqualsEqualsToken || operator === ts4.SyntaxKind.EqualsEqualsToken;
-  const notEquals = operator === ts4.SyntaxKind.ExclamationEqualsEqualsToken || operator === ts4.SyntaxKind.ExclamationEqualsToken;
+  const equals = operator === ts5.SyntaxKind.EqualsEqualsEqualsToken || operator === ts5.SyntaxKind.EqualsEqualsToken;
+  const notEquals = operator === ts5.SyntaxKind.ExclamationEqualsEqualsToken || operator === ts5.SyntaxKind.ExclamationEqualsToken;
   if (!equals && !notEquals)
     return null;
   const literalOf = (side) => {
     const unwrapped = unwrap(side, context.checker);
-    if (ts4.isStringLiteral(unwrapped) || ts4.isNoSubstitutionTemplateLiteral(unwrapped))
+    if (ts5.isStringLiteral(unwrapped) || ts5.isNoSubstitutionTemplateLiteral(unwrapped))
       return unwrapped.text;
-    if (unwrapped.kind === ts4.SyntaxKind.TrueKeyword)
+    if (unwrapped.kind === ts5.SyntaxKind.TrueKeyword)
       return true;
-    if (unwrapped.kind === ts4.SyntaxKind.FalseKeyword)
+    if (unwrapped.kind === ts5.SyntaxKind.FalseKeyword)
       return false;
     return null;
   };
@@ -4329,7 +4428,7 @@ function tagCheckComparison(expression, context) {
 }
 function opaqueEqualityCheck(expression, context) {
   const operator = expression.operatorToken.kind;
-  const isEquality = operator === ts4.SyntaxKind.EqualsEqualsEqualsToken || operator === ts4.SyntaxKind.ExclamationEqualsEqualsToken || operator === ts4.SyntaxKind.EqualsEqualsToken || operator === ts4.SyntaxKind.ExclamationEqualsToken;
+  const isEquality = operator === ts5.SyntaxKind.EqualsEqualsEqualsToken || operator === ts5.SyntaxKind.ExclamationEqualsEqualsToken || operator === ts5.SyntaxKind.EqualsEqualsToken || operator === ts5.SyntaxKind.ExclamationEqualsToken;
   if (!isEquality)
     return null;
   const opaqueOrMissingOpaque = (side) => {
@@ -4338,7 +4437,7 @@ function opaqueEqualityCheck(expression, context) {
     if (kind === "opaque")
       return true;
     if (kind === "nullable" && type.isUnion()) {
-      const missing = ts4.TypeFlags.Null | ts4.TypeFlags.Undefined;
+      const missing = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
       const rest = type.types.filter((member) => (member.flags & missing) === 0);
       return rest.length >= 1 && rest.every((member) => valueKind(member, context.checker) === "opaque");
     }
@@ -4352,14 +4451,14 @@ function opaqueEqualityCheck(expression, context) {
 }
 function missingSentinelCheck(expression, context) {
   const operator = expression.operatorToken.kind;
-  const strict = operator === ts4.SyntaxKind.EqualsEqualsEqualsToken || operator === ts4.SyntaxKind.ExclamationEqualsEqualsToken;
-  const loose = operator === ts4.SyntaxKind.EqualsEqualsToken || operator === ts4.SyntaxKind.ExclamationEqualsToken;
+  const strict = operator === ts5.SyntaxKind.EqualsEqualsEqualsToken || operator === ts5.SyntaxKind.ExclamationEqualsEqualsToken;
+  const loose = operator === ts5.SyntaxKind.EqualsEqualsToken || operator === ts5.SyntaxKind.ExclamationEqualsToken;
   if (!strict && !loose)
     return null;
-  const negated = operator === ts4.SyntaxKind.ExclamationEqualsEqualsToken || operator === ts4.SyntaxKind.ExclamationEqualsToken;
+  const negated = operator === ts5.SyntaxKind.ExclamationEqualsEqualsToken || operator === ts5.SyntaxKind.ExclamationEqualsToken;
   const sentinelOf = (side) => {
     const unwrapped = unwrap(side, context.checker);
-    if (unwrapped.kind === ts4.SyntaxKind.NullKeyword)
+    if (unwrapped.kind === ts5.SyntaxKind.NullKeyword)
       return "null";
     if (isUndefinedGlobal(unwrapped, context.checker))
       return "undefined";
@@ -4367,39 +4466,39 @@ function missingSentinelCheck(expression, context) {
   };
   const isUndefinedString = (side) => {
     const unwrapped = unwrap(side, context.checker);
-    return ts4.isStringLiteral(unwrapped) && unwrapped.text === "undefined";
+    return ts5.isStringLiteral(unwrapped) && unwrapped.text === "undefined";
   };
-  if (ts4.isTypeOfExpression(expression.left) && isUndefinedString(expression.right)) {
+  if (ts5.isTypeOfExpression(expression.left) && isUndefinedString(expression.right)) {
     const value3 = lowerExpression(expression.left.expression, context);
     return addInstruction(context, expression, { kind: "nullishCheck", value: value3, sentinel: "undefined", negated });
   }
-  if (ts4.isTypeOfExpression(expression.right) && isUndefinedString(expression.left)) {
+  if (ts5.isTypeOfExpression(expression.right) && isUndefinedString(expression.left)) {
     const value3 = lowerExpression(expression.right.expression, context);
     return addInstruction(context, expression, { kind: "nullishCheck", value: value3, sentinel: "undefined", negated });
   }
   const primitiveTypeofFlags = (side) => {
     const unwrapped = unwrap(side, context.checker);
-    if (!ts4.isStringLiteral(unwrapped))
+    if (!ts5.isStringLiteral(unwrapped))
       return null;
     switch (unwrapped.text) {
       case "number":
-        return ts4.TypeFlags.NumberLike;
+        return ts5.TypeFlags.NumberLike;
       case "string":
-        return ts4.TypeFlags.StringLike;
+        return ts5.TypeFlags.StringLike;
       case "boolean":
-        return ts4.TypeFlags.BooleanLike;
+        return ts5.TypeFlags.BooleanLike;
       default:
         return null;
     }
   };
   const rightFlags = primitiveTypeofFlags(expression.right);
   const leftFlags = primitiveTypeofFlags(expression.left);
-  const typeofSide = ts4.isTypeOfExpression(expression.left) && rightFlags != null ? { operand: expression.left, flags: rightFlags } : ts4.isTypeOfExpression(expression.right) && leftFlags != null ? { operand: expression.right, flags: leftFlags } : null;
+  const typeofSide = ts5.isTypeOfExpression(expression.left) && rightFlags != null ? { operand: expression.left, flags: rightFlags } : ts5.isTypeOfExpression(expression.right) && leftFlags != null ? { operand: expression.right, flags: leftFlags } : null;
   if (typeofSide != null) {
     const operandType = context.checker.getTypeAtLocation(typeofSide.operand.expression);
-    const missing = ts4.TypeFlags.Null | ts4.TypeFlags.Undefined;
+    const missing = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
     const members = operandType.isUnion() ? operandType.types : [operandType];
-    const restMatches = members.every((member) => (member.flags & missing) !== 0 || (member.flags & typeofSide.flags) !== 0) && members.some((member) => (member.flags & missing) === 0);
+    const restMatches = members.every((member) => (member.flags & missing) !== 0 || (typeofSide.flags === ts5.TypeFlags.NumberLike ? valueKind(member, context.checker) === "number" : (member.flags & typeofSide.flags) !== 0)) && members.some((member) => (member.flags & missing) === 0);
     const value3 = lowerExpression(typeofSide.operand.expression, context);
     if (restMatches) {
       return addInstruction(context, expression, { kind: "nullishCheck", value: value3, sentinel: "nullish", negated: !negated });
@@ -4413,7 +4512,7 @@ function missingSentinelCheck(expression, context) {
     return null;
   const checked = leftSentinel == null ? expression.left : expression.right;
   const checkedType = context.checker.getTypeAtLocation(checked);
-  const missingFlags = ts4.TypeFlags.Null | ts4.TypeFlags.Undefined;
+  const missingFlags = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
   const pureSentinel = (checkedType.flags & missingFlags) !== 0 || checkedType.isUnion() && checkedType.types.every((member) => (member.flags & missingFlags) !== 0);
   if (!pureSentinel && valueKind(checkedType, context.checker) == null) {
     throw unsupported(checked, { kind: "valueType", typeText: context.checker.typeToString(checkedType) });
@@ -4426,11 +4525,6 @@ function missingSentinelCheck(expression, context) {
     negated
   });
 }
-function isGlobalInfinity(expression, checker) {
-  if (!ts4.isIdentifier(expression) || expression.text !== "Infinity")
-    return false;
-  return declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(expression));
-}
 function identifierValue(symbol, node, context) {
   const local = context.bindings.get(symbol);
   if (local != null)
@@ -4438,7 +4532,7 @@ function identifierValue(symbol, node, context) {
   const binding = context.moduleBindingsBySymbol.get(symbol);
   if (binding != null)
     return addInstruction(context, node, { kind: "moduleRead", binding });
-  if (isGlobalInfinity(node, context.checker)) {
+  if (isStandardGlobal(node, "Infinity", context)) {
     return addInstruction(context, node, { kind: "constant", value: Number.POSITIVE_INFINITY });
   }
   if (isUndefinedGlobal(node, context.checker)) {
@@ -4457,25 +4551,25 @@ function assignIdentifier(symbol, node, value2, wholeExpression, context) {
   throw unsupported(node, { kind: "unknownIdentifier", name: node.text });
 }
 function propertyName(name) {
-  if (ts4.isIdentifier(name) || ts4.isStringLiteral(name) || ts4.isNumericLiteral(name))
+  if (ts5.isIdentifier(name) || ts5.isStringLiteral(name) || ts5.isNumericLiteral(name))
     return name.text;
   throw unsupported(name, { kind: "computedPropertyName" });
 }
 function unwrap(expression, checker) {
   let current = expression;
   while (true) {
-    if (ts4.isParenthesizedExpression(current) || ts4.isSatisfiesExpression(current)) {
+    if (ts5.isParenthesizedExpression(current) || ts5.isSatisfiesExpression(current)) {
       current = current.expression;
       continue;
     }
-    if ((ts4.isAsExpression(current) || ts4.isTypeAssertionExpression(current)) && ts4.isConstTypeReference(current.type)) {
+    if ((ts5.isAsExpression(current) || ts5.isTypeAssertionExpression(current)) && ts5.isConstTypeReference(current.type)) {
       current = current.expression;
       continue;
     }
-    if (ts4.isNonNullExpression(current)) {
+    if (ts5.isNonNullExpression(current)) {
       const assertedType = checker.getTypeAtLocation(current);
       const operandType = checker.getTypeAtLocation(current.expression);
-      if (ts4.isElementAccessExpression(current.expression) && valueKind(assertedType, checker) != null) {
+      if (ts5.isElementAccessExpression(current.expression) && valueKind(assertedType, checker) != null) {
         return current;
       }
       if (valueKind(assertedType, checker) !== valueKind(operandType, checker)) {
@@ -4492,11 +4586,51 @@ function unwrap(expression, checker) {
   }
 }
-// src/lower/module.ts
+// src/lower/function-unit.ts
 import * as ts6 from "typescript";
+function callableSignature(unit, checker) {
+  if (unit.initializer == null) {
+    return checker.getSignatureFromDeclaration(unit.declaration) ?? null;
+  }
+  const signatures = checker.getSignaturesOfType(checker.getTypeAtLocation(unit.name), ts6.SignatureKind.Call);
+  if (signatures.length !== 1)
+    return null;
+  const signature = signatures[0];
+  const signatureDeclaration = signature.declaration;
+  if (signatureDeclaration == null || signature.thisParameter != null || signature.parameters.length !== unit.declaration.parameters.length || signatureDeclaration.parameters.some((parameter) => !ts6.isParameter(parameter) || parameter.dotDotDotToken != null)) {
+    return null;
+  }
+  return signature;
+}
+function topLevelFunctionUnits(sourceFile) {
+  const units = [];
+  for (const statement of sourceFile.statements) {
+    if (ts6.isFunctionDeclaration(statement) && statement.name != null) {
+      units.push({ name: statement.name, declaration: statement, initializer: null });
+      continue;
+    }
+    if (!ts6.isVariableStatement(statement) || (statement.declarationList.flags & ts6.NodeFlags.Const) === 0)
+      continue;
+    for (const initializer of statement.declarationList.declarations) {
+      if (!ts6.isIdentifier(initializer.name) || initializer.initializer == null)
+        continue;
+      const declaration = directFunctionExpression(initializer.initializer);
+      if (declaration != null) {
+        units.push({ name: initializer.name, declaration, initializer });
+      }
+    }
+  }
+  return units;
+}
+function directFunctionExpression(expression) {
+  return ts6.isArrowFunction(expression) || ts6.isFunctionExpression(expression) ? expression : null;
+}
+// src/lower/module.ts
+import * as ts8 from "typescript";
 // src/lower/statements.ts
-import * as ts5 from "typescript";
+import * as ts7 from "typescript";
 function lowerStatements(statements, context) {
   for (const statement of statements) {
     if (context.currentBlock.terminator != null)
@@ -4505,61 +4639,57 @@ function lowerStatements(statements, context) {
   }
 }
 function lowerStatement(statement, context) {
-  if (ts5.isVariableStatement(statement)) {
+  if (ts7.isVariableStatement(statement)) {
     lowerVariableDeclarationList(statement.declarationList, context);
     return;
   }
-  if (ts5.isReturnStatement(statement)) {
+  if (ts7.isReturnStatement(statement)) {
     let value2 = statement.expression == null ? null : lowerExpression(statement.expression, context);
-    if (value2 == null) {
-      const enclosing = ts5.findAncestor(statement, ts5.isFunctionDeclaration);
-      const signature = enclosing == null ? undefined : context.checker.getSignatureFromDeclaration(enclosing);
-      const returnType = signature == null ? null : context.checker.getReturnTypeOfSignature(signature);
-      const returnsVoid = returnType == null || (returnType.flags & (ts5.TypeFlags.Void | ts5.TypeFlags.Undefined)) !== 0;
-      if (!returnsVoid) {
-        value2 = addInstruction(context, statement, { kind: "nullishConstant", sentinel: "undefined" });
-      }
+    if (context.returnsVoid)
+      value2 = null;
+    if (value2 == null && !context.returnsVoid) {
+      value2 = addInstruction(context, statement, { kind: "nullishConstant", sentinel: "undefined" });
     }
     terminate(context.currentBlock, { kind: "return", value: value2, site: addSite(context, statement) });
     return;
   }
-  if (ts5.isExpressionStatement(statement)) {
+  if (ts7.isExpressionStatement(statement)) {
     lowerStatementExpression(statement.expression, context);
     return;
   }
-  if (ts5.isIfStatement(statement)) {
+  if (ts7.isIfStatement(statement)) {
     lowerIfStatement(statement, context);
     return;
   }
-  if (ts5.isForOfStatement(statement)) {
+  if (ts7.isForOfStatement(statement)) {
     lowerForOfStatement(statement, context);
     return;
   }
-  if (ts5.isForStatement(statement)) {
+  if (ts7.isForStatement(statement)) {
     lowerForStatement(statement, context);
     return;
   }
-  if (ts5.isWhileStatement(statement)) {
+  if (ts7.isWhileStatement(statement)) {
     lowerWhileStatement(statement, context);
     return;
   }
-  if (ts5.isContinueStatement(statement)) {
+  if (ts7.isContinueStatement(statement)) {
     lowerContinueStatement(statement, context);
     return;
   }
-  if (ts5.isBlock(statement)) {
+  if (ts7.isBlock(statement)) {
     lowerStatements(statement.statements, context);
     return;
   }
-  if (ts5.isSwitchStatement(statement)) {
+  if (ts7.isSwitchStatement(statement)) {
     lowerSwitchStatement(statement, context);
     return;
   }
-  if (ts5.isThrowStatement(statement)) {
+  if (ts7.isThrowStatement(statement)) {
     terminate(context.currentBlock, { kind: "thrown", site: addSite(context, statement) });
     return;
   }
-  throw unsupported(statement, { kind: "statementForm", syntax: ts5.SyntaxKind[statement.kind] });
+  throw unsupported(statement, { kind: "statementForm", syntax: ts7.SyntaxKind[statement.kind] });
 }
 function lowerIfStatement(statement, context) {
   const bindingsBeforeBranch = new Map(context.bindings);
@@ -4586,7 +4716,7 @@ function lowerSwitchStatement(statement, context) {
   const subjectType = context.checker.getTypeAtLocation(statement.expression);
   const subjectKind = valueKind(subjectType, context.checker);
   const tagUnionExpression = taggedUnionTagRead(statement.expression, context);
-  const missingFlags = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
+  const missingFlags = ts7.TypeFlags.Null | ts7.TypeFlags.Undefined;
   const nullableOpaqueSubject = subjectKind === "nullable" && subjectType.isUnion() && subjectType.types.every((member) => (member.flags & missingFlags) !== 0 || valueKind(member, context.checker) === "opaque");
   if (tagUnionExpression == null && subjectKind !== "number" && subjectKind !== "opaque" && !nullableOpaqueSubject) {
     throw unsupported(statement.expression, { kind: "switchSubject", typeText: context.checker.typeToString(subjectType) });
@@ -4598,7 +4728,7 @@ function lowerSwitchStatement(statement, context) {
   const clauses = statement.caseBlock.clauses;
   for (let index = 0;index < clauses.length; index++) {
     const clause = clauses[index];
-    if (ts5.isDefaultClause(clause)) {
+    if (ts7.isDefaultClause(clause)) {
       if (index !== clauses.length - 1 || pendingLabels.length > 0) {
         throw unsupported(clause, { kind: "switchDefaultNotLast" });
       }
@@ -4619,7 +4749,7 @@ function lowerSwitchStatement(statement, context) {
   const lowerBody = (group) => {
     const body = group.statements;
     const last = body[body.length - 1];
-    const endsWithBreak = last != null && ts5.isBreakStatement(last);
+    const endsWithBreak = last != null && ts7.isBreakStatement(last);
     lowerStatements(endsWithBreak ? body.slice(0, -1) : body, context);
     if (context.currentBlock.terminator == null) {
       if (!endsWithBreak)
@@ -4638,7 +4768,7 @@ function lowerSwitchStatement(statement, context) {
       let condition;
       if (tagUnionExpression != null) {
         const unwrappedLabel = label;
-        if (!ts5.isStringLiteral(unwrappedLabel) && !ts5.isNoSubstitutionTemplateLiteral(unwrappedLabel)) {
+        if (!ts7.isStringLiteral(unwrappedLabel) && !ts7.isNoSubstitutionTemplateLiteral(unwrappedLabel)) {
           throw unsupported(label, { kind: "switchLabel", typeText: context.checker.typeToString(context.checker.getTypeAtLocation(label)) });
         }
         condition = addInstruction(context, label, { kind: "tagCheck", union: subject, tagValue: unwrappedLabel.text, negated: false });
@@ -4680,7 +4810,7 @@ function lowerSwitchStatement(statement, context) {
   mergeAtContinuation(exits, bindingsBefore, statement, context);
 }
 function lowerForOfStatement(statement, context) {
-  if (!ts5.isVariableDeclarationList(statement.initializer) || statement.initializer.declarations.length !== 1 || !ts5.isIdentifier(statement.initializer.declarations[0].name)) {
+  if (!ts7.isVariableDeclarationList(statement.initializer) || statement.initializer.declarations.length !== 1 || !ts7.isIdentifier(statement.initializer.declarations[0].name)) {
     throw unsupported(statement.initializer, { kind: "variableDeclarationShape" });
   }
   const elementName = statement.initializer.declarations[0].name;
@@ -4757,7 +4887,7 @@ function lowerForOfStatement(statement, context) {
 }
 function lowerForStatement(statement, context) {
   if (statement.initializer != null) {
-    if (ts5.isVariableDeclarationList(statement.initializer)) {
+    if (ts7.isVariableDeclarationList(statement.initializer)) {
       lowerVariableDeclarationList(statement.initializer, context);
     } else {
       lowerStatementExpression(statement.initializer, context);
@@ -4866,21 +4996,16 @@ function lowerBranch(statement, block, bindings, context) {
 }
 function lowerVariableDeclarationList(declarations, context) {
   for (const declaration of declarations.declarations) {
-    if (ts5.isObjectBindingPattern(declaration.name) && declaration.initializer != null) {
+    if (ts7.isObjectBindingPattern(declaration.name) && declaration.initializer != null) {
       const source = lowerExpression(declaration.initializer, context);
       for (const element of declaration.name.elements) {
-        if (!ts5.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
+        if (!ts7.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
           throw unsupported(element, { kind: "variableDeclarationShape" });
         }
-        const property = element.propertyName == null ? element.name.text : ts5.isIdentifier(element.propertyName) ? element.propertyName.text : null;
+        const property = element.propertyName == null ? element.name.text : ts7.isIdentifier(element.propertyName) ? element.propertyName.text : null;
         if (property == null)
           throw unsupported(element, { kind: "variableDeclarationShape" });
         const elementType = context.checker.getTypeAtLocation(element.name);
-        const sourceType = context.checker.getTypeAtLocation(declaration.initializer);
-        const propertySymbol = context.checker.getPropertyOfType(sourceType, property);
-        if (propertySymbol != null && declaredOnlyInDeclarationFiles(propertySymbol)) {
-          throw unsupported(element, { kind: "prototypeMemberRead", property });
-        }
         if (valueKind(elementType, context.checker) == null) {
           throw unsupported(element, { kind: "valueType", typeText: context.checker.typeToString(elementType) });
         }
@@ -4889,7 +5014,7 @@ function lowerVariableDeclarationList(declarations, context) {
       }
       continue;
     }
-    if (!ts5.isIdentifier(declaration.name) || declaration.initializer == null) {
+    if (!ts7.isIdentifier(declaration.name) || declaration.initializer == null) {
       throw unsupported(declaration, { kind: "variableDeclarationShape" });
     }
     const value2 = lowerExpression(declaration.initializer, context);
@@ -4908,12 +5033,12 @@ function lowerVariableDeclarationList(declarations, context) {
 function assignedSymbols(nodes, checker) {
   const symbols = new Set;
   const visit = (node) => {
-    if (ts5.isFunctionLike(node))
+    if (ts7.isFunctionLike(node))
       return;
     const assignment = identifierAssignment(node);
     if (assignment != null)
       symbols.add(requiredSymbol(assignment.target, checker));
-    ts5.forEachChild(node, visit);
+    ts7.forEachChild(node, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -4932,45 +5057,46 @@ function scanModuleBindings(sourceFile, checker) {
     bindings.push({ name: name.text, category });
   };
   for (const statement of sourceFile.statements) {
-    if (ts6.isVariableStatement(statement)) {
-      if ((statement.declarationList.flags & (ts6.NodeFlags.Let | ts6.NodeFlags.Const)) === 0)
+    if (ts8.isVariableStatement(statement)) {
+      if ((statement.declarationList.flags & (ts8.NodeFlags.Let | ts8.NodeFlags.Const)) === 0)
         continue;
+      const isConst = (statement.declarationList.flags & ts8.NodeFlags.Const) !== 0;
       for (const declarator of statement.declarationList.declarations) {
-        if (ts6.isIdentifier(declarator.name)) {
-          register(declarator.name, declaredCategory(declarator.name, checker));
+        if (ts8.isIdentifier(declarator.name)) {
+          register(declarator.name, isConst && declarator.initializer != null && directFunctionExpression(declarator.initializer) != null ? { kind: "function" } : declaredCategory(declarator.name, checker));
           continue;
         }
-        if (ts6.isObjectBindingPattern(declarator.name)) {
+        if (ts8.isObjectBindingPattern(declarator.name)) {
           for (const element of declarator.name.elements) {
-            if (ts6.isIdentifier(element.name))
+            if (ts8.isIdentifier(element.name))
               register(element.name, declaredCategory(element.name, checker));
           }
         }
       }
       continue;
     }
-    if (ts6.isImportDeclaration(statement)) {
+    if (ts8.isImportDeclaration(statement)) {
       const clause = statement.importClause;
       if (clause == null || clause.isTypeOnly)
         continue;
       if (clause.name != null)
         register(clause.name, importedCategory(clause.name, checker));
       const named = clause.namedBindings;
-      if (named != null && ts6.isNamedImports(named)) {
+      if (named != null && ts8.isNamedImports(named)) {
         for (const element of named.elements) {
           if (!element.isTypeOnly)
             register(element.name, importedCategory(element.name, checker));
         }
       }
-      if (named != null && ts6.isNamespaceImport(named))
+      if (named != null && ts8.isNamespaceImport(named))
         register(named.name, { kind: "import" });
     }
   }
   const visit = (node, insideFunction) => {
     if (insideFunction)
       demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings);
-    const enteringFunction = insideFunction || ts6.isFunctionLike(node);
-    ts6.forEachChild(node, (child) => {
+    const enteringFunction = insideFunction || ts8.isFunctionLike(node);
+    ts8.forEachChild(node, (child) => {
       visit(child, enteringFunction);
     });
   };
@@ -4979,13 +5105,13 @@ function scanModuleBindings(sourceFile, checker) {
 }
 function importedCategory(name, checker) {
   const symbol = checker.getSymbolAtLocation(name);
-  if (symbol == null || (symbol.flags & ts6.SymbolFlags.Alias) === 0)
+  if (symbol == null || (symbol.flags & ts8.SymbolFlags.Alias) === 0)
     return { kind: "import" };
   const target = checker.getAliasedSymbol(symbol);
   const declaration = target.valueDeclaration;
-  if (declaration == null || !ts6.isVariableDeclaration(declaration))
+  if (declaration == null || !ts8.isVariableDeclaration(declaration))
     return { kind: "import" };
-  if ((ts6.getCombinedNodeFlags(declaration) & ts6.NodeFlags.Const) === 0)
+  if ((ts8.getCombinedNodeFlags(declaration) & ts8.NodeFlags.Const) === 0)
     return { kind: "import" };
   if (declaration.getSourceFile().isDeclarationFile)
     return { kind: "import" };
@@ -5001,7 +5127,7 @@ function demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, wri
       written[binding] = true;
   };
   const target = (expression) => {
-    if (ts6.isIdentifier(expression)) {
+    if (ts8.isIdentifier(expression)) {
       const symbol = checker.getSymbolAtLocation(expression);
       const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
       if (binding != null)
@@ -5009,39 +5135,39 @@ function demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, wri
       return;
     }
     const visitPattern = (child) => {
-      if (ts6.isShorthandPropertyAssignment(child)) {
+      if (ts8.isShorthandPropertyAssignment(child)) {
         const symbol = checker.getShorthandAssignmentValueSymbol(child);
         const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
         if (binding != null)
           record(binding);
-        ts6.forEachChild(child, visitPattern);
+        ts8.forEachChild(child, visitPattern);
         return;
       }
-      if (ts6.isIdentifier(child)) {
+      if (ts8.isIdentifier(child)) {
         const symbol = checker.getSymbolAtLocation(child);
         const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
         if (binding != null)
           record(binding);
         return;
       }
-      ts6.forEachChild(child, visitPattern);
+      ts8.forEachChild(child, visitPattern);
     };
-    ts6.forEachChild(expression, visitPattern);
+    ts8.forEachChild(expression, visitPattern);
   };
-  if (ts6.isBinaryExpression(node)) {
+  if (ts8.isBinaryExpression(node)) {
     const kind = node.operatorToken.kind;
-    if (kind >= ts6.SyntaxKind.FirstAssignment && kind <= ts6.SyntaxKind.LastAssignment)
+    if (kind >= ts8.SyntaxKind.FirstAssignment && kind <= ts8.SyntaxKind.LastAssignment)
       target(node.left);
   }
-  if ((ts6.isPrefixUnaryExpression(node) || ts6.isPostfixUnaryExpression(node)) && (node.operator === ts6.SyntaxKind.PlusPlusToken || node.operator === ts6.SyntaxKind.MinusMinusToken) && ts6.isExpression(node.operand)) {
+  if ((ts8.isPrefixUnaryExpression(node) || ts8.isPostfixUnaryExpression(node)) && (node.operator === ts8.SyntaxKind.PlusPlusToken || node.operator === ts8.SyntaxKind.MinusMinusToken) && ts8.isExpression(node.operand)) {
     target(node.operand);
   }
-  if ((ts6.isForOfStatement(node) || ts6.isForInStatement(node)) && ts6.isExpression(node.initializer)) {
+  if ((ts8.isForOfStatement(node) || ts8.isForInStatement(node)) && ts8.isExpression(node.initializer)) {
     target(node.initializer);
   }
 }
-function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, sites) {
-  const context = createFunctionContext(sourceFile, checker, functionsBySymbol, scan.bindingsBySymbol, sites);
+function lowerModuleInitializer(sourceFile, checker, program, functionsBySymbol, scan, sites) {
+  const context = createFunctionContext(sourceFile, checker, program, functionsBySymbol, scan.bindingsBySymbol, sites);
   const skips = [];
   const statements = sourceFile.statements;
   for (const statement of statements) {
@@ -5049,8 +5175,8 @@ function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, si
       continue;
     const recovery = snapshotLowering(context);
     try {
-      assertAccepted(statement);
-      if (ts6.isVariableStatement(statement)) {
+      assertAccepted(statement, true);
+      if (ts8.isVariableStatement(statement)) {
         lowerTopLevelDeclarations(statement, context, scan);
         continue;
       }
@@ -5088,31 +5214,31 @@ function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, si
   };
 }
 function containsArrayLiteral(root) {
-  if (ts6.isArrayLiteralExpression(root))
+  if (ts8.isArrayLiteralExpression(root))
     return true;
   let found = false;
-  ts6.forEachChild(root, (child) => {
+  ts8.forEachChild(root, (child) => {
     if (!found && containsArrayLiteral(child))
       found = true;
   });
   return found;
 }
 function forEachImmediatelyEvaluatedChild(node, visit) {
-  if (ts6.isFunctionLike(node)) {
-    if (node.name != null && ts6.isComputedPropertyName(node.name)) {
+  if (ts8.isFunctionLike(node)) {
+    if (node.name != null && ts8.isComputedPropertyName(node.name)) {
       visit(node.name.expression);
     }
     return;
   }
-  ts6.forEachChild(node, visit);
+  ts8.forEachChild(node, visit);
 }
 function lowerSupportedArgumentsOfSkippedTopLevelCall(statement, stop, context) {
-  if (!ts6.isExpressionStatement(statement))
+  if (!ts8.isExpressionStatement(statement))
     return;
   let expression = statement.expression;
-  while (ts6.isParenthesizedExpression(expression))
+  while (ts8.isParenthesizedExpression(expression))
     expression = expression.expression;
-  if (!ts6.isCallExpression(expression) || expression !== stop.node || expression.questionDotToken != null || !plainCallTarget(expression.expression))
+  if (!ts8.isCallExpression(expression) || expression !== stop.node || expression.questionDotToken != null || !plainCallTarget(expression.expression))
     return;
   for (const argument of expression.arguments) {
     const recovery = snapshotLowering(context);
@@ -5127,23 +5253,23 @@ function lowerSupportedArgumentsOfSkippedTopLevelCall(statement, stop, context)
   }
 }
 function plainCallTarget(expression) {
-  if (ts6.isIdentifier(expression))
+  if (ts8.isIdentifier(expression))
     return true;
-  if (ts6.isParenthesizedExpression(expression))
+  if (ts8.isParenthesizedExpression(expression))
     return plainCallTarget(expression.expression);
-  return ts6.isPropertyAccessExpression(expression) && expression.questionDotToken == null && plainCallTarget(expression.expression);
+  return ts8.isPropertyAccessExpression(expression) && expression.questionDotToken == null && plainCallTarget(expression.expression);
 }
 function lowerTopLevelDeclarations(statement, context, scan) {
   for (const declarator of statement.declarationList.declarations) {
     if (declarator.initializer == null)
       throw new LoweringStop(declarator, { kind: "variableDeclarationShape" });
-    if (ts6.isObjectBindingPattern(declarator.name)) {
+    if (ts8.isObjectBindingPattern(declarator.name)) {
       const source = lowerExpression(declarator.initializer, context);
       for (const element of declarator.name.elements) {
-        if (!ts6.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
+        if (!ts8.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
           throw new LoweringStop(element, { kind: "variableDeclarationShape" });
         }
-        const property = element.propertyName == null ? element.name.text : ts6.isIdentifier(element.propertyName) ? element.propertyName.text : null;
+        const property = element.propertyName == null ? element.name.text : ts8.isIdentifier(element.propertyName) ? element.propertyName.text : null;
         if (property == null)
           throw new LoweringStop(element, { kind: "variableDeclarationShape" });
         const elementType = context.checker.getTypeAtLocation(element.name);
@@ -5159,27 +5285,32 @@ function lowerTopLevelDeclarations(statement, context, scan) {
       }
       continue;
     }
-    if (!ts6.isIdentifier(declarator.name)) {
+    if (!ts8.isIdentifier(declarator.name)) {
       throw new LoweringStop(declarator, { kind: "variableDeclarationShape" });
     }
     const symbol = context.checker.getSymbolAtLocation(declarator.name);
     const binding = symbol == null ? undefined : scan.bindingsBySymbol.get(symbol);
     if (binding == null)
       throw new LoweringStop(declarator, { kind: "variableDeclarationShape" });
+    if ((statement.declarationList.flags & ts8.NodeFlags.Const) !== 0 && directFunctionExpression(declarator.initializer) != null) {
+      const marker = addInstruction(context, declarator.initializer, { kind: "opaqueConstant" });
+      addInstruction(context, declarator, { kind: "moduleWrite", binding, value: marker });
+      continue;
+    }
     const value2 = lowerExpression(declarator.initializer, context);
     addInstruction(context, declarator, { kind: "moduleWrite", binding, value: value2 });
   }
 }
 function skippedAtTopLevel(statement) {
-  return ts6.isFunctionDeclaration(statement) && statement.name != null || ts6.isImportDeclaration(statement) || ts6.isTypeAliasDeclaration(statement) || ts6.isInterfaceDeclaration(statement) || ts6.isExportDeclaration(statement);
+  return ts8.isFunctionDeclaration(statement) && statement.name != null || ts8.isImportDeclaration(statement) || ts8.isTypeAliasDeclaration(statement) || ts8.isInterfaceDeclaration(statement) || ts8.isExportDeclaration(statement);
 }
 function scanSkippedModuleEffects(root, checker, bindingsBySymbol, bindings) {
   const directWrites = [];
   let invokesUnknownCode = false;
   const visit = (node) => {
     demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, directWrites);
-    invokesUnknownCode ||= ts6.isCallExpression(node) || ts6.isNewExpression(node) || ts6.isTaggedTemplateExpression(node) || ts6.isAwaitExpression(node) || ts6.isYieldExpression(node) || ts6.isForOfStatement(node) || ts6.isSpreadElement(node) || ts6.isArrayBindingPattern(node) || ts6.isVariableDeclarationList(node) && (node.flags & ts6.NodeFlags.Using) !== 0 || ts6.isBinaryExpression(node) && (node.operatorToken.kind === ts6.SyntaxKind.InstanceOfKeyword || node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && containsArrayLiteral(node.left)) || ts6.isJsxElement(node) || ts6.isJsxSelfClosingElement(node) || ts6.isJsxFragment(node) || ts6.isClassDeclaration(node) || ts6.isClassExpression(node);
-    if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name)) {
+    invokesUnknownCode ||= ts8.isCallExpression(node) || ts8.isNewExpression(node) || ts8.isTaggedTemplateExpression(node) || ts8.isAwaitExpression(node) || ts8.isYieldExpression(node) || ts8.isForOfStatement(node) || ts8.isSpreadElement(node) || ts8.isArrayBindingPattern(node) || ts8.isVariableDeclarationList(node) && (node.flags & ts8.NodeFlags.Using) !== 0 || ts8.isBinaryExpression(node) && (node.operatorToken.kind === ts8.SyntaxKind.InstanceOfKeyword || node.operatorToken.kind === ts8.SyntaxKind.EqualsToken && containsArrayLiteral(node.left)) || ts8.isJsxElement(node) || ts8.isJsxSelfClosingElement(node) || ts8.isJsxFragment(node) || ts8.isClassDeclaration(node) || ts8.isClassExpression(node);
+    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name)) {
       const symbol = checker.getSymbolAtLocation(node.name);
       const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
       if (binding != null) {
@@ -5201,7 +5332,7 @@ function declaredRecordProperties(type, checker, seen) {
     return null;
   const properties = [];
   for (const property of checker.getPropertiesOfType(type)) {
-    const optional = (property.flags & ts6.SymbolFlags.Optional) !== 0;
+    const optional = (property.flags & ts8.SymbolFlags.Optional) !== 0;
     const walked = declaredKind(checker.getTypeOfSymbol(property), checker, [...seen, type]);
     const opaqueLeaf = { kind: "opaque" };
     const propertyDeclared = declaredOnlyInDeclarationFiles(property) ? opaqueLeaf : walked ?? opaqueLeaf;
@@ -5307,14 +5438,14 @@ function declaredKindUncached(type, checker, seen) {
       }
       if (inner == null)
         return null;
-      const admitsNull = type.types.some((member) => (member.flags & ts6.TypeFlags.Null) !== 0);
-      const admitsUndefined = type.types.some((member) => (member.flags & ts6.TypeFlags.Undefined) !== 0);
+      const admitsNull = type.types.some((member) => (member.flags & ts8.TypeFlags.Null) !== 0);
+      const admitsUndefined = type.types.some((member) => (member.flags & ts8.TypeFlags.Undefined) !== 0);
       return { kind: "nullish", inner, sentinels: admitsNull && admitsUndefined ? "both" : admitsNull ? "null" : "undefined" };
     }
     case "opaque":
       return { kind: "opaque" };
     case "array": {
-      const element = checker.getIndexTypeOfType(type, ts6.IndexKind.Number);
+      const element = checker.getIndexTypeOfType(type, ts8.IndexKind.Number);
       if (element == null)
         return null;
       const elementKind = declaredKind(element, checker, [...seen, type]);
@@ -5366,13 +5497,14 @@ function declaredKindUncached(type, checker, seen) {
 }
 function numericLiteralInterval(type) {
   const members = type.isUnion() ? type.types : [type];
-  if (!members.every((member) => (member.flags & ts6.TypeFlags.NumberLiteral) !== 0 && (member.flags & ts6.TypeFlags.EnumLiteral) === 0))
-    return null;
   let lower = Infinity;
   let upper = -Infinity;
   let integer = true;
   for (const member of members) {
-    const value2 = member.value;
+    const number = numberConstituent(member);
+    if (number == null || (number.flags & ts8.TypeFlags.NumberLiteral) === 0 || (number.flags & ts8.TypeFlags.EnumLiteral) !== 0)
+      return null;
+    const value2 = number.value;
     if (!Number.isFinite(value2))
       return "nonFinite";
     lower = Math.min(lower, value2);
@@ -5419,7 +5551,7 @@ function joinScalarDeclaredKinds(members) {
 function tupleHasOptionalOrRestPositions(type, checker) {
   if (!checker.isTupleType(type))
     return false;
-  return type.target.elementFlags.some((flags) => (flags & ts6.ElementFlags.Required) === 0);
+  return type.target.elementFlags.some((flags) => (flags & ts8.ElementFlags.Required) === 0);
 }
 function demote(bindings, binding) {
   const category = bindings[binding].category;
@@ -5433,6 +5565,7 @@ function demote(bindings, binding) {
       break;
     }
     case "kind":
+    case "function":
     case "import":
     case "opaque":
       break;
@@ -5440,31 +5573,31 @@ function demote(bindings, binding) {
 }
 // src/lower/static-intrinsics.ts
-import * as ts7 from "typescript";
-function scanStaticAnnotations(sourceFile, declarations, checker) {
-  const ownerIndex = new Map(declarations.map((declaration, index) => [declaration, index]));
-  const callsByFunction = declarations.map(() => []);
+import * as ts9 from "typescript";
+function scanStaticAnnotations(sourceFile, functions, checker) {
+  const ownerIndex = new Map(functions.map((unit, index) => [unit.declaration, index]));
+  const callsByFunction = functions.map(() => []);
   const outsideTopLevelFunctions = [];
   const visit = (node) => {
-    if (ts7.isCallExpression(node) && isStaticIntent(node, checker)) {
-      const owner = ts7.findAncestor(node, ts7.isFunctionLike);
-      const index = owner != null && ts7.isFunctionDeclaration(owner) ? ownerIndex.get(owner) : undefined;
+    if (ts9.isCallExpression(node) && isStaticIntent(node, checker)) {
+      const owner = ts9.findAncestor(node, ts9.isFunctionLike);
+      const index = owner == null ? undefined : ownerIndex.get(owner);
       if (index == null)
         outsideTopLevelFunctions.push(node);
       else
         callsByFunction[index].push(node);
     }
-    ts7.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(sourceFile);
   return {
-    functions: declarations.map((declaration, index) => {
+    functions: functions.map((unit, index) => {
       const calls = callsByFunction[index];
       const callSet = new Set(calls);
       const leading = new Set;
-      if (declaration.body != null) {
-        for (const statement of declaration.body.statements) {
-          if (!ts7.isExpressionStatement(statement) || !ts7.isCallExpression(statement.expression) || !callSet.has(statement.expression))
+      if (unit.declaration.body != null && ts9.isBlock(unit.declaration.body)) {
+        for (const statement of unit.declaration.body.statements) {
+          if (!ts9.isExpressionStatement(statement) || !ts9.isCallExpression(statement.expression) || !callSet.has(statement.expression))
             break;
           leading.add(statement.expression);
         }
@@ -5478,34 +5611,31 @@ function annotationForCall(call, role) {
   if (call.arguments.length !== 1) {
     return { kind: "invalid", call, role, node: call, problem: "argumentCount" };
   }
-  if (!ts7.isExpressionStatement(call.parent) || call.parent.expression !== call) {
+  if (!ts9.isExpressionStatement(call.parent) || call.parent.expression !== call) {
     return { kind: "invalid", call, role, node: call, problem: "position" };
   }
   const callee = call.expression;
-  if (call.questionDotToken != null || ts7.isPropertyAccessExpression(callee) && callee.questionDotToken != null) {
+  if (call.questionDotToken != null || ts9.isPropertyAccessExpression(callee) && callee.questionDotToken != null) {
     return { kind: "invalid", call, role, node: call, problem: "optionalCall" };
   }
   return { kind: "valid", call, role, condition: call.arguments[0] };
 }
 function isStaticIntent(call, checker) {
-  if (!ts7.isPropertyAccessExpression(call.expression))
+  if (!ts9.isPropertyAccessExpression(call.expression))
     return false;
   const access = call.expression;
-  if (!ts7.isIdentifier(access.expression) || access.expression.text !== "console" || access.name.text !== "assert")
+  if (!ts9.isIdentifier(access.expression) || access.expression.text !== "console" || access.name.text !== "assert")
     return false;
   const resolved = checker.getSymbolAtLocation(access.expression);
-  const globalConsole = checker.resolveName("console", undefined, ts7.SymbolFlags.Value, false);
+  const globalConsole = checker.resolveName("console", undefined, ts9.SymbolFlags.Value, false);
   return resolved != null && resolved === globalConsole;
 }
 // src/lower/program.ts
 function lowerSource(checked, baseDirectory = process.cwd()) {
-  const { sourceFile, checker } = checked;
-  const declarations = [];
-  for (const statement of sourceFile.statements) {
-    if (ts8.isFunctionDeclaration(statement) && statement.name != null)
-      declarations.push(statement);
-  }
+  const { sourceFile, program } = checked;
+  const checker = program.getTypeChecker();
+  const declarations = topLevelFunctionUnits(sourceFile);
   const staticScan = scanStaticAnnotations(sourceFile, declarations, checker);
   const recordStaticAnnotationIssues = (sites2) => staticScan.outsideTopLevelFunctions.map((call) => {
     sites2.push(nodeSpan(sourceFile, call));
@@ -5519,9 +5649,9 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
       baseDirectory,
       lineStarts: [...sourceFile.getLineStarts()],
       sites: sites2,
-      functions: declarations.map((declaration, index) => ({
+      functions: declarations.map((unit, index) => ({
         kind: "unsupported",
-        name: declaration.name.text,
+        name: unit.name.text,
         hasStaticAnnotations: staticScan.functions[index].length > 0,
         site: 0,
         reason
@@ -5548,22 +5678,34 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
     return rejectFile(nodeSpan(sourceFile, evalNode), { kind: "evalInFile" });
   }
   const functionsBySymbol = new Map;
+  const scan = scanModuleBindings(sourceFile, checker);
+  const topLevelFunctions = [];
   for (let index = 0;index < declarations.length; index++) {
-    const declaration = declarations[index];
-    const symbol = checker.getSymbolAtLocation(declaration.name);
+    const unit = declarations[index];
+    const symbol = checker.getSymbolAtLocation(unit.name);
     if (symbol == null)
-      throw new Error(`Function declaration ${declaration.name.text} has no TypeScript symbol`);
-    functionsBySymbol.set(symbol, { id: index, declaration });
+      throw new Error(`Function ${unit.name.text} has no TypeScript symbol`);
+    const binding = scan.bindingsBySymbol.get(symbol);
+    if (unit.initializer != null && binding == null) {
+      throw new Error(`Const-bound function ${unit.name.text} has no module binding`);
+    }
+    const fn = {
+      ...unit,
+      id: index,
+      binding: unit.initializer == null ? null : binding,
+      signature: callableSignature(unit, checker)
+    };
+    topLevelFunctions.push(fn);
+    functionsBySymbol.set(symbol, fn);
   }
-  const scan = scanModuleBindings(sourceFile, checker);
   const sites = [];
   const staticAnnotationIssues = recordStaticAnnotationIssues(sites);
   const functions = [];
-  for (let index = 0;index < declarations.length; index++) {
-    const declaration = declarations[index];
+  for (let index = 0;index < topLevelFunctions.length; index++) {
+    const declaration = topLevelFunctions[index];
     const staticAnnotations = staticScan.functions[index];
     try {
-      functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites));
+      functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, program, functionsBySymbol, scan, sites));
     } catch (error) {
       if (!(error instanceof LoweringStop))
         throw error;
@@ -5577,7 +5719,7 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
       });
     }
   }
-  const { initializer, skips } = lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, sites);
+  const { initializer, skips } = lowerModuleInitializer(sourceFile, checker, program, functionsBySymbol, scan, sites);
   return {
     file: sourceFile.fileName,
     baseDirectory,
@@ -5590,7 +5732,8 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
     initializerSkips: skips
   };
 }
-function lowerFunction(declaration, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites) {
+function lowerFunction(unit, staticAnnotations, sourceFile, checker, program, functionsBySymbol, scan, sites) {
+  const { declaration } = unit;
   for (const annotation of staticAnnotations) {
     if (annotation.kind === "invalid") {
       throw unsupported(annotation.node, { kind: "staticAssertionForm", problem: annotation.problem });
@@ -5598,24 +5741,28 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
   }
   if (declaration.body == null)
     throw unsupported(declaration, { kind: "functionWithoutBody" });
-  if (declaration.asteriskToken != null || declaration.modifiers?.some((modifier) => modifier.kind === ts8.SyntaxKind.AsyncKeyword) === true) {
+  if (!ts10.isArrowFunction(declaration) && declaration.asteriskToken != null || declaration.modifiers?.some((modifier) => modifier.kind === ts10.SyntaxKind.AsyncKeyword) === true) {
     throw unsupported(declaration, { kind: "asyncOrGeneratorFunction" });
   }
   assertAccepted(declaration);
-  const signature = checker.getSignatureFromDeclaration(declaration);
-  if (signature != null && checker.getTypePredicateOfSignature(signature) != null) {
-    throw unsupported(declaration, { kind: "typePredicate" });
+  const signature = unit.signature;
+  if (signature == null) {
+    throw unsupported(unit.name, {
+      kind: unit.initializer == null ? "functionWithoutSignature" : "constFunctionSignature"
+    });
   }
-  const returnType = functionReturnType(declaration, checker);
-  const returnsVoid = (returnType.flags & (ts8.TypeFlags.Void | ts8.TypeFlags.Undefined | ts8.TypeFlags.Never)) !== 0;
+  const returnType = checker.getReturnTypeOfSignature(signature);
+  const returnsVoid = (returnType.flags & (ts10.TypeFlags.Void | ts10.TypeFlags.Undefined | ts10.TypeFlags.Never)) !== 0;
   if (!returnsVoid && valueKind(returnType, checker) == null) {
     throw unsupported(declaration.type ?? declaration, { kind: "valueType", typeText: checker.typeToString(returnType) });
   }
-  const context = createFunctionContext(sourceFile, checker, functionsBySymbol, scan.bindingsBySymbol, sites, staticAnnotations);
+  const context = createFunctionContext(sourceFile, checker, program, functionsBySymbol, scan.bindingsBySymbol, sites, staticAnnotations, returnsVoid);
   const entry = context.currentBlock;
-  for (const parameter of declaration.parameters) {
-    if (ts8.isObjectBindingPattern(parameter.name)) {
-      const type2 = lowerParameterType(parameter, checker);
+  for (let parameterIndex = 0;parameterIndex < declaration.parameters.length; parameterIndex++) {
+    const parameter = declaration.parameters[parameterIndex];
+    const parameterType = unit.initializer == null ? checker.getTypeAtLocation(parameter) : checker.getTypeOfSymbolAtLocation(signature.parameters[parameterIndex], signature.declaration);
+    if (ts10.isObjectBindingPattern(parameter.name)) {
+      const type2 = lowerParameterType(parameter, parameterType, checker);
       const patternName = parameter.name.getText(sourceFile).replace(/\s+/g, " ");
       if (parameter.initializer != null) {
         throw unsupported(parameter, { kind: "parameterDefaultValue", name: patternName });
@@ -5624,10 +5771,10 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
       const bindings = [];
       context.parameters.push({ value: value3, name: patternName, type: type2, site: addSite(context, parameter), bindings });
       for (const element of parameter.name.elements) {
-        if (!ts8.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
+        if (!ts10.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
           throw unsupported(element, { kind: "destructuredParameter" });
         }
-        const property = element.propertyName == null ? element.name.text : ts8.isIdentifier(element.propertyName) ? element.propertyName.text : null;
+        const property = element.propertyName == null ? element.name.text : ts10.isIdentifier(element.propertyName) ? element.propertyName.text : null;
         if (property == null)
           throw unsupported(element, { kind: "destructuredParameter" });
         bindings.push({ property, local: element.name.text });
@@ -5643,12 +5790,12 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
       }
       continue;
     }
-    if (!ts8.isIdentifier(parameter.name))
+    if (!ts10.isIdentifier(parameter.name))
       throw unsupported(parameter.name, { kind: "destructuredParameter" });
     if (parameter.dotDotDotToken != null) {
       throw unsupported(parameter, { kind: "parameterType", typeText: `...${checker.typeToString(checker.getTypeAtLocation(parameter))}`, optionalOrRestTuple: false });
     }
-    let type = lowerParameterType(parameter, checker);
+    let type = lowerParameterType(parameter, parameterType, checker);
     if (parameter.initializer != null) {
       const default_ = parameterDefaultLiteral(parameter.initializer, checker);
       if (default_ == null || !parameterDefaultFits(default_, type)) {
@@ -5661,7 +5808,16 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
     context.parameters.push({ value: value2, name: parameter.name.text, type, site: addSite(context, parameter), bindings: null });
   }
   lowerFiniteInputRequirements(context);
-  lowerStatements(declaration.body.statements, context);
+  if (ts10.isBlock(declaration.body)) {
+    lowerStatements(declaration.body.statements, context);
+  } else {
+    const value2 = lowerExpression(declaration.body, context);
+    terminate(context.currentBlock, {
+      kind: "return",
+      value: returnsVoid ? null : value2,
+      site: addSite(context, declaration.body)
+    });
+  }
   if (context.currentBlock.terminator == null) {
     if (!returnsVoid) {
       terminate(context.currentBlock, { kind: "stop", site: addSite(context, declaration), reason: { kind: "missingReturn" } });
@@ -5671,12 +5827,12 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
   }
   return {
     kind: "lowered",
-    name: declaration.name.text,
+    name: unit.name.text,
     assertions: context.assertions,
     parameters: context.parameters,
     returnPropertyNames: declaredRecordReturnNames(returnType, checker),
     entry: 0,
-    blocks: sealBlocks(context.blocks, declaration.name.text)
+    blocks: sealBlocks(context.blocks, unit.name.text)
   };
 }
 function lowerFiniteInputRequirements(context) {
@@ -5710,7 +5866,7 @@ function declaredRecordReturnNames(returnType, checker) {
   if (kind === "object")
     return checker.getPropertiesOfType(returnType).map((property) => property.name);
   if (kind === "nullable" && returnType.isUnion()) {
-    const missing = ts8.TypeFlags.Null | ts8.TypeFlags.Undefined;
+    const missing = ts10.TypeFlags.Null | ts10.TypeFlags.Undefined;
     const members = returnType.types.filter((member) => (member.flags & missing) === 0);
     if (members.length > 0 && members.every((member) => valueKind(member, checker) === "object")) {
       const names = new Set;
@@ -5723,8 +5879,7 @@ function declaredRecordReturnNames(returnType, checker) {
   }
   return null;
 }
-function lowerParameterType(parameter, checker) {
-  const type = checker.getTypeAtLocation(parameter);
+function lowerParameterType(parameter, type, checker) {
   const declared = declaredKind(type, checker, []);
   if (declared == null) {
     throw unsupported(parameter, {
@@ -5735,12 +5890,6 @@ function lowerParameterType(parameter, checker) {
   }
   return declared;
 }
-function functionReturnType(declaration, checker) {
-  const signature = checker.getSignatureFromDeclaration(declaration);
-  if (signature == null)
-    throw unsupported(declaration, { kind: "functionWithoutSignature" });
-  return checker.getReturnTypeOfSignature(signature);
-}
 // src/analyze.ts
 function analyzeCheckedSource(checked, baseDirectory) {
@@ -6505,6 +6654,7 @@ function formatStop(stop, program, analysis) {
           return `reads ${binding.name}, whose value the analysis does not track (read at ${formatSite(program, stop.site)})`;
         case "value":
         case "kind":
+        case "function":
           return `reads ${binding.name} before it is initialized (read at ${formatSite(program, stop.site)})`;
       }
     }
@@ -6563,6 +6713,8 @@ function formatUnsupportedReason(reason) {
       return "node without a TypeScript symbol";
     case "functionWithoutSignature":
       return "function without a TypeScript signature";
+    case "constFunctionSignature":
+      return "a top-level const function whose declared call shape differs from its implementation";
     case "functionWithoutBody":
       return "function declarations need bodies";
     case "destructuredParameter":
@@ -6581,14 +6733,10 @@ function formatUnsupportedReason(reason) {
       return "object spread (list every field explicitly, e.g. {gain: config.gain})";
     case "asyncOrGeneratorFunction":
       return "an async or generator function (the runtime result is a Promise or iterator, not the body's return value)";
-    case "typePredicate":
-      return "a type predicate (the checker takes the predicate on faith; return a plain boolean and check properties where they are read)";
     case "protoProperty":
       return "a property named __proto__ (prototype-setting syntax at runtime, not a data property)";
     case "enumMemberRead":
       return "an enum member read (replace the enum with plain module consts, e.g. const directionUp = 1)";
-    case "prototypeMemberRead":
-      return `read of the inherited prototype member ${reason.property} (records carry only their own data properties)`;
     case "binaryOperator":
       return reason.operator === "in" ? "the `in` operator (use a distinct string or boolean tag when property presence distinguishes union variants)" : `binary operator ${reason.operator} (supported: + - * / %, comparisons, and boolean && || !)`;
     case "call":
@@ -6788,7 +6936,7 @@ function formatNumber(value2) {
 }
 // src/typescript/diagnostics.ts
-import * as ts9 from "typescript";
+import * as ts11 from "typescript";
 class TypeScriptDiagnosticsError extends Error {
   diagnostics;
@@ -6805,10 +6953,10 @@ class TypeScriptDiagnosticsError extends Error {
 function formatTypeScriptDiagnostics(diagnostics, options, currentDirectory) {
   const host = {
     getCurrentDirectory: () => currentDirectory,
-    getCanonicalFileName: ts9.sys.useCaseSensitiveFileNames ? (file) => file : (file) => file.toLowerCase(),
-    getNewLine: () => ts9.sys.newLine
+    getCanonicalFileName: ts11.sys.useCaseSensitiveFileNames ? (file) => file : (file) => file.toLowerCase(),
+    getNewLine: () => ts11.sys.newLine
   };
-  return usePrettyOutput(options["pretty"]) ? ts9.formatDiagnosticsWithColorAndContext(diagnostics, host) : ts9.formatDiagnostics(diagnostics, host);
+  return usePrettyOutput(options["pretty"]) ? ts11.formatDiagnosticsWithColorAndContext(diagnostics, host) : ts11.formatDiagnostics(diagnostics, host);
 }
 function usePrettyOutput(configured) {
   if (typeof configured === "boolean")
@@ -6819,7 +6967,7 @@ function usePrettyOutput(configured) {
   const forceColor = process.env["FORCE_COLOR"];
   if (forceColor != null && forceColor !== "")
     return true;
-  return ts9.sys.writeOutputIsTTY?.() === true;
+  return ts11.sys.writeOutputIsTTY?.() === true;
 }
 function color(code, text) {
   return `\x1B[${code}m${text}\x1B[0m`;
@@ -7046,7 +7194,7 @@ function createFileAudit({ program, analysis }) {
   };
 }
 function formatAuditCoverage(coverage) {
-  const parts = coverage.functions === 0 ? ["no named function declarations"] : [`${coverage.analyzed}/${coverage.functions} functions fully analyzed`];
+  const parts = coverage.functions === 0 ? ["no named top-level functions"] : [`${coverage.analyzed}/${coverage.functions} functions fully analyzed`];
   if (coverage.partial > 0)
     parts.push(`${coverage.partial} partially supported`);
   if (coverage.unsupported > 0)
@@ -7141,6 +7289,7 @@ function guidesForUnsupportedReason(reason) {
     case "unknownIdentifier":
     case "missingSymbol":
     case "functionWithoutSignature":
+    case "constFunctionSignature":
     case "functionWithoutBody":
     case "destructuredParameter":
     case "parameterType":
@@ -7150,10 +7299,8 @@ function guidesForUnsupportedReason(reason) {
     case "computedPropertyName":
     case "objectSpread":
     case "asyncOrGeneratorFunction":
-    case "typePredicate":
     case "protoProperty":
     case "enumMemberRead":
-    case "prototypeMemberRead":
     case "binaryOperator":
     case "callWithFewerArguments":
     case "callWithMoreArguments":
@@ -7211,12 +7358,12 @@ function isCallerInput(expression) {
 // src/typescript/check.ts
 import { resolve } from "node:path";
-import * as ts10 from "typescript";
+import * as ts12 from "typescript";
 var fallbackOptions = {
-  target: ts10.ScriptTarget.ESNext,
-  module: ts10.ModuleKind.ESNext,
-  moduleResolution: ts10.ModuleResolutionKind.Bundler,
-  moduleDetection: ts10.ModuleDetectionKind.Force,
+  target: ts12.ScriptTarget.ESNext,
+  module: ts12.ModuleKind.ESNext,
+  moduleResolution: ts12.ModuleResolutionKind.Bundler,
+  moduleDetection: ts12.ModuleDetectionKind.Force,
   strict: true,
   noUncheckedIndexedAccess: true,
   exactOptionalPropertyTypes: true,
@@ -7226,25 +7373,25 @@ var fallbackOptions = {
 };
 function checkFile(file) {
   const absoluteFile = resolve(file);
-  const program = ts10.createProgram([absoluteFile], fallbackOptions);
+  const program = ts12.createProgram([absoluteFile], fallbackOptions);
   return checkedSource(program, absoluteFile, fallbackOptions);
 }
 function checkedSource(program, file, options) {
-  const diagnostics = ts10.getPreEmitDiagnostics(program);
+  const diagnostics = ts12.getPreEmitDiagnostics(program);
   if (diagnostics.length > 0) {
     throw new TypeScriptDiagnosticsError(diagnostics, options, process.cwd());
   }
   const sourceFile = program.getSourceFile(file);
   if (sourceFile == null)
     throw new Error(`TypeScript did not load ${file}`);
-  return { sourceFile, checker: program.getTypeChecker() };
+  return { sourceFile, program };
 }
 // src/typescript/project.ts
 import { dirname, isAbsolute, relative as relative2, resolve as resolve2, sep } from "node:path";
-import * as ts11 from "typescript";
+import * as ts13 from "typescript";
 function findTypeScriptConfig(searchFrom) {
-  return ts11.findConfigFile(resolve2(searchFrom), (file) => ts11.sys.fileExists(file), "tsconfig.json") ?? null;
+  return ts13.findConfigFile(resolve2(searchFrom), (file) => ts13.sys.fileExists(file), "tsconfig.json") ?? null;
 }
 function loadTypeScriptProjectGraph(configPath) {
   const loaded = [];
@@ -7261,8 +7408,8 @@ function loadTypeScriptProjectGraph(configPath) {
     const parsed = parseConfig(absoluteConfigPath);
     requireStrictNullChecks(parsed.options, absoluteConfigPath);
     for (const reference of parsed.projectReferences ?? [])
-      load(ts11.resolveProjectReferencePath(reference));
-    const program = ts11.createProgram({
+      load(ts13.resolveProjectReferencePath(reference));
+    const program = ts13.createProgram({
       rootNames: parsed.fileNames,
       options: parsed.options,
       configFileParsingDiagnostics: parsed.errors,
@@ -7297,8 +7444,8 @@ function projectSources(projects) {
   return [...sources.values()].sort((left, right) => left.sourceFile.fileName.localeCompare(right.sourceFile.fileName));
 }
 function parseConfig(configPath) {
-  const parsed = ts11.getParsedCommandLineOfConfigFile(configPath, undefined, {
-    ...ts11.sys,
+  const parsed = ts13.getParsedCommandLineOfConfigFile(configPath, undefined, {
+    ...ts13.sys,
     onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
       throw new TypeScriptDiagnosticsError([diagnostic], {}, dirname(configPath));
     }
@@ -7359,7 +7506,7 @@ function analyzeProject(searchFrom) {
   const projects = loadTypeScriptProjectGraph(configPath);
   const rootProject = projects.at(-1);
   const sources = projectSources(projects);
-  const diagnostics = uniqueDiagnostics(projects.flatMap((project) => ts12.getPreEmitDiagnostics(project.program)));
+  const diagnostics = uniqueDiagnostics(projects.flatMap((project) => ts14.getPreEmitDiagnostics(project.program)));
   requireNoTypeScriptErrors(diagnostics, rootProject.parsed.options);
   const files = [];
   let analyzed = 0;
@@ -7483,7 +7630,7 @@ function collectLintFindings({ program, analysis }) {
   collectStops(analysis.initializer);
   collectAssertions(analysis.initializer);
   for (const issue of program.staticAnnotationIssues) {
-    addError(issue.site, "console-assert", "console.assert is only supported inside a named top-level function declaration");
+    addError(issue.site, "console-assert", "console.assert is only supported inside a named top-level function");
   }
   for (const fn of analysis.functions) {
     collectStops(fn);
@@ -7580,7 +7727,7 @@ function formatLintPrefix(finding, rule, pretty) {
   return formatDiagnosticPrefix(finding, lintLevel(finding), rule, pretty);
 }
 function formatCoverage(coverage) {
-  return `coverage: ${coverage.analyzed}/${coverage.functions} named top-level function declarations fully analyzed; ${coverage.partial} partially supported; ${coverage.unsupported} unsupported.`;
+  return `coverage: ${coverage.analyzed}/${coverage.functions} named top-level functions fully analyzed; ${coverage.partial} partially supported; ${coverage.unsupported} unsupported.`;
 }
 function analyzeTargetFile(file) {
   const absoluteFile = resolve3(file);
@@ -7596,7 +7743,7 @@ function analyzeTargetFile(file) {
   if (source == null) {
     throw new Error(`File is not part of the project resolved from ${configPath}: ${absoluteFile}`);
   }
-  const diagnostics = ts12.getPreEmitDiagnostics(source.project.program, source.sourceFile);
+  const diagnostics = ts14.getPreEmitDiagnostics(source.project.program, source.sourceFile);
   requireNoTypeScriptErrors(diagnostics, rootProject.parsed.options);
   return {
     detailed: analyzeProjectSource(source, process.cwd()),
@@ -7605,7 +7752,7 @@ function analyzeTargetFile(file) {
 }
 function canonicalFilePath(file) {
   const real = realpathSync.native(file);
-  return ts12.sys.useCaseSensitiveFileNames ? real : real.toLowerCase();
+  return ts14.sys.useCaseSensitiveFileNames ? real : real.toLowerCase();
 }
 function analyzeFileAlone(absoluteFile) {
   return {
@@ -7616,13 +7763,13 @@ function analyzeFileAlone(absoluteFile) {
 function analyzeProjectSource(source, reportBaseDirectory) {
   return analyzeCheckedSource({
     sourceFile: source.sourceFile,
-    checker: source.project.program.getTypeChecker()
+    program: source.project.program
   }, reportBaseDirectory);
 }
 function uniqueDiagnostics(diagnostics) {
   const seen = new Set;
   return diagnostics.filter((diagnostic) => {
-    const message = ts12.flattenDiagnosticMessageText(diagnostic.messageText, `
+    const message = ts14.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
     const key = `${diagnostic.file?.fileName ?? ""}:${diagnostic.start ?? ""}:${diagnostic.length ?? ""}:${diagnostic.code}:${message}`;
     if (seen.has(key))
@@ -7643,7 +7790,7 @@ function requireNoTypeScriptErrors(diagnostics, options) {
   printTypeScriptDiagnostics(diagnostics, options, process.cwd());
 }
 function hasErrorDiagnostics(diagnostics) {
-  return diagnostics.some((diagnostic) => diagnostic.category === ts12.DiagnosticCategory.Error);
+  return diagnostics.some((diagnostic) => diagnostic.category === ts14.DiagnosticCategory.Error);
 }
 // fr.ts