@chenglou/freerange 0.0.3 → 0.0.4

package/dist/fr.js

@@ -3,7 +3,7 @@
 // src/project.ts
 import { existsSync, realpathSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
-import * as ts13 from "typescript";
+import * as ts14 from "typescript";
 
 // src/domain/number.ts
 var float64Scratch = new Float64Array(1);
@@ -2975,17 +2975,18 @@ function reachableFrom(successors, start) {
 }
 
 // src/lower/program.ts
-import * as ts9 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 = [], returnsVoid = true) {
+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])),
@@ -3192,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 } },
@@ -3207,26 +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)
@@ -3235,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;
 }
@@ -3253,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" };
@@ -3267,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) {
@@ -3299,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;
 }
@@ -3349,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);
@@ -3368,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
         });
@@ -3381,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) {
@@ -3425,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" });
@@ -3451,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 });
@@ -3498,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) });
@@ -3525,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" });
     }
@@ -3539,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" });
@@ -3560,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" });
@@ -3592,7 +3617,7 @@ function lowerExpression(expression, context) {
             continue;
           }
           const callableParameter = callee.signature?.declaration?.parameters[index];
-          if (callableParameter != null && ts4.isParameter(callableParameter) && callableParameter.questionToken != null) {
+          if (callableParameter != null && ts5.isParameter(callableParameter) && callableParameter.questionToken != null) {
             arguments_.push(addInstruction(context, parameter, { kind: "nullishConstant", sentinel: "undefined" }));
             continue;
           }
@@ -3619,13 +3644,13 @@ function lowerExpression(expression, context) {
         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);
@@ -3647,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);
@@ -3662,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),
@@ -3670,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 });
     }
@@ -3689,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") {
@@ -3704,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") {
@@ -3721,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);
@@ -3751,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 : {
@@ -3760,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);
@@ -3776,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);
@@ -3806,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;
   }
@@ -3838,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;
@@ -3864,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;
 }
@@ -3930,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;
@@ -4008,8 +4033,8 @@ function lowerConditionalExpression(expression, 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);
@@ -4020,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;
   }
@@ -4038,20 +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 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;
@@ -4059,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;
@@ -4079,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);
 }
@@ -4117,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;
@@ -4140,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);
@@ -4162,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;
@@ -4192,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)
@@ -4202,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;
@@ -4211,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;
   }
@@ -4242,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;
@@ -4289,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;
@@ -4307,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;
@@ -4326,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;
@@ -4340,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);
@@ -4365,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",
@@ -4376,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())
@@ -4386,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;
   };
@@ -4414,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) => {
@@ -4423,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");
     }
@@ -4437,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";
@@ -4452,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 });
@@ -4498,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) });
@@ -4511,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)
@@ -4523,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)) {
@@ -4542,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)) {
@@ -4578,17 +4587,17 @@ function unwrap(expression, checker) {
 }
 
 // src/lower/function-unit.ts
-import * as ts5 from "typescript";
+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), ts5.SignatureKind.Call);
+  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) => !ts5.isParameter(parameter) || parameter.dotDotDotToken != null)) {
+  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;
@@ -4596,14 +4605,14 @@ function callableSignature(unit, checker) {
 function topLevelFunctionUnits(sourceFile) {
   const units = [];
   for (const statement of sourceFile.statements) {
-    if (ts5.isFunctionDeclaration(statement) && statement.name != null) {
+    if (ts6.isFunctionDeclaration(statement) && statement.name != null) {
       units.push({ name: statement.name, declaration: statement, initializer: null });
       continue;
     }
-    if (!ts5.isVariableStatement(statement) || (statement.declarationList.flags & ts5.NodeFlags.Const) === 0)
+    if (!ts6.isVariableStatement(statement) || (statement.declarationList.flags & ts6.NodeFlags.Const) === 0)
       continue;
     for (const initializer of statement.declarationList.declarations) {
-      if (!ts5.isIdentifier(initializer.name) || initializer.initializer == null)
+      if (!ts6.isIdentifier(initializer.name) || initializer.initializer == null)
         continue;
       const declaration = directFunctionExpression(initializer.initializer);
       if (declaration != null) {
@@ -4614,14 +4623,14 @@ function topLevelFunctionUnits(sourceFile) {
   return units;
 }
 function directFunctionExpression(expression) {
-  return ts5.isArrowFunction(expression) || ts5.isFunctionExpression(expression) ? expression : null;
+  return ts6.isArrowFunction(expression) || ts6.isFunctionExpression(expression) ? expression : null;
 }
 
 // src/lower/module.ts
-import * as ts7 from "typescript";
+import * as ts8 from "typescript";
 
 // src/lower/statements.ts
-import * as ts6 from "typescript";
+import * as ts7 from "typescript";
 function lowerStatements(statements, context) {
   for (const statement of statements) {
     if (context.currentBlock.terminator != null)
@@ -4630,11 +4639,11 @@ function lowerStatements(statements, context) {
   }
 }
 function lowerStatement(statement, context) {
-  if (ts6.isVariableStatement(statement)) {
+  if (ts7.isVariableStatement(statement)) {
     lowerVariableDeclarationList(statement.declarationList, context);
     return;
   }
-  if (ts6.isReturnStatement(statement)) {
+  if (ts7.isReturnStatement(statement)) {
     let value2 = statement.expression == null ? null : lowerExpression(statement.expression, context);
     if (context.returnsVoid)
       value2 = null;
@@ -4644,43 +4653,43 @@ function lowerStatement(statement, context) {
     terminate(context.currentBlock, { kind: "return", value: value2, site: addSite(context, statement) });
     return;
   }
-  if (ts6.isExpressionStatement(statement)) {
+  if (ts7.isExpressionStatement(statement)) {
     lowerStatementExpression(statement.expression, context);
     return;
   }
-  if (ts6.isIfStatement(statement)) {
+  if (ts7.isIfStatement(statement)) {
     lowerIfStatement(statement, context);
     return;
   }
-  if (ts6.isForOfStatement(statement)) {
+  if (ts7.isForOfStatement(statement)) {
     lowerForOfStatement(statement, context);
     return;
   }
-  if (ts6.isForStatement(statement)) {
+  if (ts7.isForStatement(statement)) {
     lowerForStatement(statement, context);
     return;
   }
-  if (ts6.isWhileStatement(statement)) {
+  if (ts7.isWhileStatement(statement)) {
     lowerWhileStatement(statement, context);
     return;
   }
-  if (ts6.isContinueStatement(statement)) {
+  if (ts7.isContinueStatement(statement)) {
     lowerContinueStatement(statement, context);
     return;
   }
-  if (ts6.isBlock(statement)) {
+  if (ts7.isBlock(statement)) {
     lowerStatements(statement.statements, context);
     return;
   }
-  if (ts6.isSwitchStatement(statement)) {
+  if (ts7.isSwitchStatement(statement)) {
     lowerSwitchStatement(statement, context);
     return;
   }
-  if (ts6.isThrowStatement(statement)) {
+  if (ts7.isThrowStatement(statement)) {
     terminate(context.currentBlock, { kind: "thrown", site: addSite(context, statement) });
     return;
   }
-  throw unsupported(statement, { kind: "statementForm", syntax: ts6.SyntaxKind[statement.kind] });
+  throw unsupported(statement, { kind: "statementForm", syntax: ts7.SyntaxKind[statement.kind] });
 }
 function lowerIfStatement(statement, context) {
   const bindingsBeforeBranch = new Map(context.bindings);
@@ -4707,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 = ts6.TypeFlags.Null | ts6.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) });
@@ -4719,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 (ts6.isDefaultClause(clause)) {
+    if (ts7.isDefaultClause(clause)) {
       if (index !== clauses.length - 1 || pendingLabels.length > 0) {
         throw unsupported(clause, { kind: "switchDefaultNotLast" });
       }
@@ -4740,7 +4749,7 @@ function lowerSwitchStatement(statement, context) {
   const lowerBody = (group) => {
     const body = group.statements;
     const last = body[body.length - 1];
-    const endsWithBreak = last != null && ts6.isBreakStatement(last);
+    const endsWithBreak = last != null && ts7.isBreakStatement(last);
     lowerStatements(endsWithBreak ? body.slice(0, -1) : body, context);
     if (context.currentBlock.terminator == null) {
       if (!endsWithBreak)
@@ -4759,7 +4768,7 @@ function lowerSwitchStatement(statement, context) {
       let condition;
       if (tagUnionExpression != null) {
         const unwrappedLabel = label;
-        if (!ts6.isStringLiteral(unwrappedLabel) && !ts6.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 });
@@ -4801,7 +4810,7 @@ function lowerSwitchStatement(statement, context) {
   mergeAtContinuation(exits, bindingsBefore, statement, context);
 }
 function lowerForOfStatement(statement, context) {
-  if (!ts6.isVariableDeclarationList(statement.initializer) || statement.initializer.declarations.length !== 1 || !ts6.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;
@@ -4878,7 +4887,7 @@ function lowerForOfStatement(statement, context) {
 }
 function lowerForStatement(statement, context) {
   if (statement.initializer != null) {
-    if (ts6.isVariableDeclarationList(statement.initializer)) {
+    if (ts7.isVariableDeclarationList(statement.initializer)) {
       lowerVariableDeclarationList(statement.initializer, context);
     } else {
       lowerStatementExpression(statement.initializer, context);
@@ -4987,21 +4996,16 @@ function lowerBranch(statement, block, bindings, context) {
 }
 function lowerVariableDeclarationList(declarations, context) {
   for (const declaration of declarations.declarations) {
-    if (ts6.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 (!ts6.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 : ts6.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) });
         }
@@ -5010,7 +5014,7 @@ function lowerVariableDeclarationList(declarations, context) {
       }
       continue;
     }
-    if (!ts6.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);
@@ -5029,12 +5033,12 @@ function lowerVariableDeclarationList(declarations, context) {
 function assignedSymbols(nodes, checker) {
   const symbols = new Set;
   const visit = (node) => {
-    if (ts6.isFunctionLike(node))
+    if (ts7.isFunctionLike(node))
       return;
     const assignment = identifierAssignment(node);
     if (assignment != null)
       symbols.add(requiredSymbol(assignment.target, checker));
-    ts6.forEachChild(node, visit);
+    ts7.forEachChild(node, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -5053,46 +5057,46 @@ function scanModuleBindings(sourceFile, checker) {
     bindings.push({ name: name.text, category });
   };
   for (const statement of sourceFile.statements) {
-    if (ts7.isVariableStatement(statement)) {
-      if ((statement.declarationList.flags & (ts7.NodeFlags.Let | ts7.NodeFlags.Const)) === 0)
+    if (ts8.isVariableStatement(statement)) {
+      if ((statement.declarationList.flags & (ts8.NodeFlags.Let | ts8.NodeFlags.Const)) === 0)
         continue;
-      const isConst = (statement.declarationList.flags & ts7.NodeFlags.Const) !== 0;
+      const isConst = (statement.declarationList.flags & ts8.NodeFlags.Const) !== 0;
       for (const declarator of statement.declarationList.declarations) {
-        if (ts7.isIdentifier(declarator.name)) {
+        if (ts8.isIdentifier(declarator.name)) {
           register(declarator.name, isConst && declarator.initializer != null && directFunctionExpression(declarator.initializer) != null ? { kind: "function" } : declaredCategory(declarator.name, checker));
           continue;
         }
-        if (ts7.isObjectBindingPattern(declarator.name)) {
+        if (ts8.isObjectBindingPattern(declarator.name)) {
           for (const element of declarator.name.elements) {
-            if (ts7.isIdentifier(element.name))
+            if (ts8.isIdentifier(element.name))
               register(element.name, declaredCategory(element.name, checker));
           }
         }
       }
       continue;
     }
-    if (ts7.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 && ts7.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 && ts7.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 || ts7.isFunctionLike(node);
-    ts7.forEachChild(node, (child) => {
+    const enteringFunction = insideFunction || ts8.isFunctionLike(node);
+    ts8.forEachChild(node, (child) => {
       visit(child, enteringFunction);
     });
   };
@@ -5101,13 +5105,13 @@ function scanModuleBindings(sourceFile, checker) {
 }
 function importedCategory(name, checker) {
   const symbol = checker.getSymbolAtLocation(name);
-  if (symbol == null || (symbol.flags & ts7.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 || !ts7.isVariableDeclaration(declaration))
+  if (declaration == null || !ts8.isVariableDeclaration(declaration))
     return { kind: "import" };
-  if ((ts7.getCombinedNodeFlags(declaration) & ts7.NodeFlags.Const) === 0)
+  if ((ts8.getCombinedNodeFlags(declaration) & ts8.NodeFlags.Const) === 0)
     return { kind: "import" };
   if (declaration.getSourceFile().isDeclarationFile)
     return { kind: "import" };
@@ -5123,7 +5127,7 @@ function demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, wri
       written[binding] = true;
   };
   const target = (expression) => {
-    if (ts7.isIdentifier(expression)) {
+    if (ts8.isIdentifier(expression)) {
       const symbol = checker.getSymbolAtLocation(expression);
       const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
       if (binding != null)
@@ -5131,39 +5135,39 @@ function demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, wri
       return;
     }
     const visitPattern = (child) => {
-      if (ts7.isShorthandPropertyAssignment(child)) {
+      if (ts8.isShorthandPropertyAssignment(child)) {
         const symbol = checker.getShorthandAssignmentValueSymbol(child);
         const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
         if (binding != null)
           record(binding);
-        ts7.forEachChild(child, visitPattern);
+        ts8.forEachChild(child, visitPattern);
         return;
       }
-      if (ts7.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;
       }
-      ts7.forEachChild(child, visitPattern);
+      ts8.forEachChild(child, visitPattern);
     };
-    ts7.forEachChild(expression, visitPattern);
+    ts8.forEachChild(expression, visitPattern);
   };
-  if (ts7.isBinaryExpression(node)) {
+  if (ts8.isBinaryExpression(node)) {
     const kind = node.operatorToken.kind;
-    if (kind >= ts7.SyntaxKind.FirstAssignment && kind <= ts7.SyntaxKind.LastAssignment)
+    if (kind >= ts8.SyntaxKind.FirstAssignment && kind <= ts8.SyntaxKind.LastAssignment)
       target(node.left);
   }
-  if ((ts7.isPrefixUnaryExpression(node) || ts7.isPostfixUnaryExpression(node)) && (node.operator === ts7.SyntaxKind.PlusPlusToken || node.operator === ts7.SyntaxKind.MinusMinusToken) && ts7.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 ((ts7.isForOfStatement(node) || ts7.isForInStatement(node)) && ts7.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) {
@@ -5172,7 +5176,7 @@ function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, si
     const recovery = snapshotLowering(context);
     try {
       assertAccepted(statement, true);
-      if (ts7.isVariableStatement(statement)) {
+      if (ts8.isVariableStatement(statement)) {
         lowerTopLevelDeclarations(statement, context, scan);
         continue;
       }
@@ -5210,31 +5214,31 @@ function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, si
   };
 }
 function containsArrayLiteral(root) {
-  if (ts7.isArrayLiteralExpression(root))
+  if (ts8.isArrayLiteralExpression(root))
     return true;
   let found = false;
-  ts7.forEachChild(root, (child) => {
+  ts8.forEachChild(root, (child) => {
     if (!found && containsArrayLiteral(child))
       found = true;
   });
   return found;
 }
 function forEachImmediatelyEvaluatedChild(node, visit) {
-  if (ts7.isFunctionLike(node)) {
-    if (node.name != null && ts7.isComputedPropertyName(node.name)) {
+  if (ts8.isFunctionLike(node)) {
+    if (node.name != null && ts8.isComputedPropertyName(node.name)) {
       visit(node.name.expression);
     }
     return;
   }
-  ts7.forEachChild(node, visit);
+  ts8.forEachChild(node, visit);
 }
 function lowerSupportedArgumentsOfSkippedTopLevelCall(statement, stop, context) {
-  if (!ts7.isExpressionStatement(statement))
+  if (!ts8.isExpressionStatement(statement))
     return;
   let expression = statement.expression;
-  while (ts7.isParenthesizedExpression(expression))
+  while (ts8.isParenthesizedExpression(expression))
     expression = expression.expression;
-  if (!ts7.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);
@@ -5249,23 +5253,23 @@ function lowerSupportedArgumentsOfSkippedTopLevelCall(statement, stop, context)
   }
 }
 function plainCallTarget(expression) {
-  if (ts7.isIdentifier(expression))
+  if (ts8.isIdentifier(expression))
     return true;
-  if (ts7.isParenthesizedExpression(expression))
+  if (ts8.isParenthesizedExpression(expression))
     return plainCallTarget(expression.expression);
-  return ts7.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 (ts7.isObjectBindingPattern(declarator.name)) {
+    if (ts8.isObjectBindingPattern(declarator.name)) {
       const source = lowerExpression(declarator.initializer, context);
       for (const element of declarator.name.elements) {
-        if (!ts7.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 : ts7.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);
@@ -5281,14 +5285,14 @@ function lowerTopLevelDeclarations(statement, context, scan) {
       }
       continue;
     }
-    if (!ts7.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 & ts7.NodeFlags.Const) !== 0 && directFunctionExpression(declarator.initializer) != null) {
+    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;
@@ -5298,15 +5302,15 @@ function lowerTopLevelDeclarations(statement, context, scan) {
   }
 }
 function skippedAtTopLevel(statement) {
-  return ts7.isFunctionDeclaration(statement) && statement.name != null || ts7.isImportDeclaration(statement) || ts7.isTypeAliasDeclaration(statement) || ts7.isInterfaceDeclaration(statement) || ts7.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 ||= ts7.isCallExpression(node) || ts7.isNewExpression(node) || ts7.isTaggedTemplateExpression(node) || ts7.isAwaitExpression(node) || ts7.isYieldExpression(node) || ts7.isForOfStatement(node) || ts7.isSpreadElement(node) || ts7.isArrayBindingPattern(node) || ts7.isVariableDeclarationList(node) && (node.flags & ts7.NodeFlags.Using) !== 0 || ts7.isBinaryExpression(node) && (node.operatorToken.kind === ts7.SyntaxKind.InstanceOfKeyword || node.operatorToken.kind === ts7.SyntaxKind.EqualsToken && containsArrayLiteral(node.left)) || ts7.isJsxElement(node) || ts7.isJsxSelfClosingElement(node) || ts7.isJsxFragment(node) || ts7.isClassDeclaration(node) || ts7.isClassExpression(node);
-    if (ts7.isVariableDeclaration(node) && ts7.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) {
@@ -5328,7 +5332,7 @@ function declaredRecordProperties(type, checker, seen) {
     return null;
   const properties = [];
   for (const property of checker.getPropertiesOfType(type)) {
-    const optional = (property.flags & ts7.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;
@@ -5434,14 +5438,14 @@ function declaredKindUncached(type, checker, seen) {
       }
       if (inner == null)
         return null;
-      const admitsNull = type.types.some((member) => (member.flags & ts7.TypeFlags.Null) !== 0);
-      const admitsUndefined = type.types.some((member) => (member.flags & ts7.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, ts7.IndexKind.Number);
+      const element = checker.getIndexTypeOfType(type, ts8.IndexKind.Number);
       if (element == null)
         return null;
       const elementKind = declaredKind(element, checker, [...seen, type]);
@@ -5493,13 +5497,14 @@ function declaredKindUncached(type, checker, seen) {
 }
 function numericLiteralInterval(type) {
   const members = type.isUnion() ? type.types : [type];
-  if (!members.every((member) => (member.flags & ts7.TypeFlags.NumberLiteral) !== 0 && (member.flags & ts7.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);
@@ -5546,7 +5551,7 @@ function joinScalarDeclaredKinds(members) {
 function tupleHasOptionalOrRestPositions(type, checker) {
   if (!checker.isTupleType(type))
     return false;
-  return type.target.elementFlags.some((flags) => (flags & ts7.ElementFlags.Required) === 0);
+  return type.target.elementFlags.some((flags) => (flags & ts8.ElementFlags.Required) === 0);
 }
 function demote(bindings, binding) {
   const category = bindings[binding].category;
@@ -5568,21 +5573,21 @@ function demote(bindings, binding) {
 }
 
 // src/lower/static-intrinsics.ts
-import * as ts8 from "typescript";
+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 (ts8.isCallExpression(node) && isStaticIntent(node, checker)) {
-      const owner = ts8.findAncestor(node, ts8.isFunctionLike);
+    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);
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(sourceFile);
   return {
@@ -5590,9 +5595,9 @@ function scanStaticAnnotations(sourceFile, functions, checker) {
       const calls = callsByFunction[index];
       const callSet = new Set(calls);
       const leading = new Set;
-      if (unit.declaration.body != null && ts8.isBlock(unit.declaration.body)) {
+      if (unit.declaration.body != null && ts9.isBlock(unit.declaration.body)) {
         for (const statement of unit.declaration.body.statements) {
-          if (!ts8.isExpressionStatement(statement) || !ts8.isCallExpression(statement.expression) || !callSet.has(statement.expression))
+          if (!ts9.isExpressionStatement(statement) || !ts9.isCallExpression(statement.expression) || !callSet.has(statement.expression))
             break;
           leading.add(statement.expression);
         }
@@ -5606,29 +5611,30 @@ function annotationForCall(call, role) {
   if (call.arguments.length !== 1) {
     return { kind: "invalid", call, role, node: call, problem: "argumentCount" };
   }
-  if (!ts8.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 || ts8.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 (!ts8.isPropertyAccessExpression(call.expression))
+  if (!ts9.isPropertyAccessExpression(call.expression))
     return false;
   const access = call.expression;
-  if (!ts8.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, ts8.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 { sourceFile, program } = checked;
+  const checker = program.getTypeChecker();
   const declarations = topLevelFunctionUnits(sourceFile);
   const staticScan = scanStaticAnnotations(sourceFile, declarations, checker);
   const recordStaticAnnotationIssues = (sites2) => staticScan.outsideTopLevelFunctions.map((call) => {
@@ -5699,7 +5705,7 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
     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;
@@ -5713,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,
@@ -5726,7 +5732,7 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
     initializerSkips: skips
   };
 }
-function lowerFunction(unit, 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") {
@@ -5735,7 +5741,7 @@ function lowerFunction(unit, staticAnnotations, sourceFile, checker, functionsBy
   }
   if (declaration.body == null)
     throw unsupported(declaration, { kind: "functionWithoutBody" });
-  if (!ts9.isArrowFunction(declaration) && declaration.asteriskToken != null || declaration.modifiers?.some((modifier) => modifier.kind === ts9.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);
@@ -5745,20 +5751,17 @@ function lowerFunction(unit, staticAnnotations, sourceFile, checker, functionsBy
       kind: unit.initializer == null ? "functionWithoutSignature" : "constFunctionSignature"
     });
   }
-  if (checker.getTypePredicateOfSignature(signature) != null) {
-    throw unsupported(declaration, { kind: "typePredicate" });
-  }
   const returnType = checker.getReturnTypeOfSignature(signature);
-  const returnsVoid = (returnType.flags & (ts9.TypeFlags.Void | ts9.TypeFlags.Undefined | ts9.TypeFlags.Never)) !== 0;
+  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, returnsVoid);
+  const context = createFunctionContext(sourceFile, checker, program, functionsBySymbol, scan.bindingsBySymbol, sites, staticAnnotations, returnsVoid);
   const entry = context.currentBlock;
   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 (ts9.isObjectBindingPattern(parameter.name)) {
+    if (ts10.isObjectBindingPattern(parameter.name)) {
       const type2 = lowerParameterType(parameter, parameterType, checker);
       const patternName = parameter.name.getText(sourceFile).replace(/\s+/g, " ");
       if (parameter.initializer != null) {
@@ -5768,10 +5771,10 @@ function lowerFunction(unit, staticAnnotations, sourceFile, checker, functionsBy
       const bindings = [];
       context.parameters.push({ value: value3, name: patternName, type: type2, site: addSite(context, parameter), bindings });
       for (const element of parameter.name.elements) {
-        if (!ts9.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 : ts9.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 });
@@ -5787,7 +5790,7 @@ function lowerFunction(unit, staticAnnotations, sourceFile, checker, functionsBy
       }
       continue;
     }
-    if (!ts9.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 });
@@ -5805,7 +5808,7 @@ function lowerFunction(unit, staticAnnotations, sourceFile, checker, functionsBy
     context.parameters.push({ value: value2, name: parameter.name.text, type, site: addSite(context, parameter), bindings: null });
   }
   lowerFiniteInputRequirements(context);
-  if (ts9.isBlock(declaration.body)) {
+  if (ts10.isBlock(declaration.body)) {
     lowerStatements(declaration.body.statements, context);
   } else {
     const value2 = lowerExpression(declaration.body, context);
@@ -5863,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 = ts9.TypeFlags.Null | ts9.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;
@@ -6730,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":
@@ -6937,7 +6936,7 @@ function formatNumber(value2) {
 }
 
 // src/typescript/diagnostics.ts
-import * as ts10 from "typescript";
+import * as ts11 from "typescript";
 
 class TypeScriptDiagnosticsError extends Error {
   diagnostics;
@@ -6954,10 +6953,10 @@ class TypeScriptDiagnosticsError extends Error {
 function formatTypeScriptDiagnostics(diagnostics, options, currentDirectory) {
   const host = {
     getCurrentDirectory: () => currentDirectory,
-    getCanonicalFileName: ts10.sys.useCaseSensitiveFileNames ? (file) => file : (file) => file.toLowerCase(),
-    getNewLine: () => ts10.sys.newLine
+    getCanonicalFileName: ts11.sys.useCaseSensitiveFileNames ? (file) => file : (file) => file.toLowerCase(),
+    getNewLine: () => ts11.sys.newLine
   };
-  return usePrettyOutput(options["pretty"]) ? ts10.formatDiagnosticsWithColorAndContext(diagnostics, host) : ts10.formatDiagnostics(diagnostics, host);
+  return usePrettyOutput(options["pretty"]) ? ts11.formatDiagnosticsWithColorAndContext(diagnostics, host) : ts11.formatDiagnostics(diagnostics, host);
 }
 function usePrettyOutput(configured) {
   if (typeof configured === "boolean")
@@ -6968,7 +6967,7 @@ function usePrettyOutput(configured) {
   const forceColor = process.env["FORCE_COLOR"];
   if (forceColor != null && forceColor !== "")
     return true;
-  return ts10.sys.writeOutputIsTTY?.() === true;
+  return ts11.sys.writeOutputIsTTY?.() === true;
 }
 function color(code, text) {
   return `\x1B[${code}m${text}\x1B[0m`;
@@ -7300,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":
@@ -7361,12 +7358,12 @@ function isCallerInput(expression) {
 
 // src/typescript/check.ts
 import { resolve } from "node:path";
-import * as ts11 from "typescript";
+import * as ts12 from "typescript";
 var fallbackOptions = {
-  target: ts11.ScriptTarget.ESNext,
-  module: ts11.ModuleKind.ESNext,
-  moduleResolution: ts11.ModuleResolutionKind.Bundler,
-  moduleDetection: ts11.ModuleDetectionKind.Force,
+  target: ts12.ScriptTarget.ESNext,
+  module: ts12.ModuleKind.ESNext,
+  moduleResolution: ts12.ModuleResolutionKind.Bundler,
+  moduleDetection: ts12.ModuleDetectionKind.Force,
   strict: true,
   noUncheckedIndexedAccess: true,
   exactOptionalPropertyTypes: true,
@@ -7376,25 +7373,25 @@ var fallbackOptions = {
 };
 function checkFile(file) {
   const absoluteFile = resolve(file);
-  const program = ts11.createProgram([absoluteFile], fallbackOptions);
+  const program = ts12.createProgram([absoluteFile], fallbackOptions);
   return checkedSource(program, absoluteFile, fallbackOptions);
 }
 function checkedSource(program, file, options) {
-  const diagnostics = ts11.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 ts12 from "typescript";
+import * as ts13 from "typescript";
 function findTypeScriptConfig(searchFrom) {
-  return ts12.findConfigFile(resolve2(searchFrom), (file) => ts12.sys.fileExists(file), "tsconfig.json") ?? null;
+  return ts13.findConfigFile(resolve2(searchFrom), (file) => ts13.sys.fileExists(file), "tsconfig.json") ?? null;
 }
 function loadTypeScriptProjectGraph(configPath) {
   const loaded = [];
@@ -7411,8 +7408,8 @@ function loadTypeScriptProjectGraph(configPath) {
     const parsed = parseConfig(absoluteConfigPath);
     requireStrictNullChecks(parsed.options, absoluteConfigPath);
     for (const reference of parsed.projectReferences ?? [])
-      load(ts12.resolveProjectReferencePath(reference));
-    const program = ts12.createProgram({
+      load(ts13.resolveProjectReferencePath(reference));
+    const program = ts13.createProgram({
       rootNames: parsed.fileNames,
       options: parsed.options,
       configFileParsingDiagnostics: parsed.errors,
@@ -7447,8 +7444,8 @@ function projectSources(projects) {
   return [...sources.values()].sort((left, right) => left.sourceFile.fileName.localeCompare(right.sourceFile.fileName));
 }
 function parseConfig(configPath) {
-  const parsed = ts12.getParsedCommandLineOfConfigFile(configPath, undefined, {
-    ...ts12.sys,
+  const parsed = ts13.getParsedCommandLineOfConfigFile(configPath, undefined, {
+    ...ts13.sys,
     onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
       throw new TypeScriptDiagnosticsError([diagnostic], {}, dirname(configPath));
     }
@@ -7509,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) => ts13.getPreEmitDiagnostics(project.program)));
+  const diagnostics = uniqueDiagnostics(projects.flatMap((project) => ts14.getPreEmitDiagnostics(project.program)));
   requireNoTypeScriptErrors(diagnostics, rootProject.parsed.options);
   const files = [];
   let analyzed = 0;
@@ -7746,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 = ts13.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()),
@@ -7755,7 +7752,7 @@ function analyzeTargetFile(file) {
 }
 function canonicalFilePath(file) {
   const real = realpathSync.native(file);
-  return ts13.sys.useCaseSensitiveFileNames ? real : real.toLowerCase();
+  return ts14.sys.useCaseSensitiveFileNames ? real : real.toLowerCase();
 }
 function analyzeFileAlone(absoluteFile) {
   return {
@@ -7766,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 = ts13.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))
@@ -7793,7 +7790,7 @@ function requireNoTypeScriptErrors(diagnostics, options) {
   printTypeScriptDiagnostics(diagnostics, options, process.cwd());
 }
 function hasErrorDiagnostics(diagnostics) {
-  return diagnostics.some((diagnostic) => diagnostic.category === ts13.DiagnosticCategory.Error);
+  return diagnostics.some((diagnostic) => diagnostic.category === ts14.DiagnosticCategory.Error);
 }
 
 // fr.ts