diff --git a/packages/compiler/src/frontend/lowering/builtins/numbers.ts b/packages/compiler/src/frontend/lowering/builtins/numbers.ts index 08d6cb349..4f86e6f74 100644 --- a/packages/compiler/src/frontend/lowering/builtins/numbers.ts +++ b/packages/compiler/src/frontend/lowering/builtins/numbers.ts @@ -2,7 +2,7 @@ import * as ts from "../../ts7/adapter.js"; import { type Lowerer, own } from "../lowerer.js"; import { lowerCheckedPredicateValue } from "../lower-builtin-values.js"; import { locOf } from "../../program.js"; -import { BOOL, F64, type IrExpr, type IrLibFn } from "../../../ir/ir.js"; +import { BOOL, F64, STRING, type IrExpr, type IrLibFn } from "../../../ir/ir.js"; import { lowerBuiltinValuePreservingUndefined, lowerOptionalNumberPredicate } from "./arguments.js"; import { tryLowerExpression } from "../expressions/try-lower-expression.js"; import { lowerStaticNumberGlobal } from "../lower-calls.js"; @@ -88,6 +88,22 @@ export function lowerNumberStaticCall( const parsed = lowerStaticNumberGlobal(lowerer, member, call, call.arguments, loc); if (parsed !== null) return parsed; } + // A checked-dynamic argument (`Number.parseInt(env.FORCE_COLOR, 10)` + // over a JavaScript dictionary read): the parsers' own ToString, + // exactly the global parseFloat's dyn form. + if (probed?.type.kind === "dyn") { + const text: IrExpr = { + kind: "libCall", + fn: "dyn.toStringCoerce", + args: [probed], + type: STRING, + loc, + }; + if (member === "parseFloat") + return { kind: "libCall", fn: "num.parseFloat", args: [text], type: F64, loc }; + const radix = lowerer.lowerExprExpecting(call.arguments[1]!, F64); + return { kind: "libCall", fn: "num.parseInt", args: [text, radix], type: F64, loc }; + } const argText = probed !== null ? lowerer.fmt(probed.type) diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts index 97bf1e963..94c2cdba7 100644 --- a/packages/compiler/src/frontend/lowering/builtins/process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/process.ts @@ -233,6 +233,41 @@ export function lowerProcessStreamProperty( * read in source order). Method members referenced without a call are * rejected specifically. Null for non-process receivers (the chain keeps * trying other property lowerings). */ +/** The value of a DATA member of the process global taken off by + * destructuring (`const { env, argv } = process` in JavaScript, the + * supports-color opening): the same values the spelled `process.env` / + * `process.argv` reads produce, typed by the binding. Null for members + * this does not cover (methods keep the destructuring fence). */ +export function processDataMemberValue( + lowerer: Lowerer, + member: string, + binding: ts.Node, + loc: SrcLoc, +): IrExpr | null { + switch (member) { + case "env": { + const mapped = lowerer.mapTypeOf(lowerer.typeOf(binding)); + if (mapped?.kind !== "record") return null; + const helper = envSnapshotHelper(lowerer, mapped.shapeId, loc); + return helper === null ? null : { kind: "call", callee: helper, args: [], type: mapped, loc }; + } + case "argv": + return { kind: "libCall", fn: "process.argv", args: [], type: arrayOf(STRING), loc }; + case "platform": + return { kind: "libCall", fn: "process.platform", args: [], type: STRING, loc }; + case "arch": + return { kind: "libCall", fn: "process.arch", args: [], type: STRING, loc }; + case "pid": + return { kind: "libCall", fn: "process.pid", args: [], type: F64, loc }; + case "execPath": + return { kind: "libCall", fn: "process.execPath", args: [], type: STRING, loc }; + case "versions": + return { kind: "libCall", fn: "process.versions", args: [], type: DYN, loc }; + default: + return null; + } +} + export function lowerProcessProperty( lowerer: Lowerer, expr: ts.PropertyAccessExpression, diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts index 444a9cf23..120032bf5 100644 --- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts +++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts @@ -1159,7 +1159,9 @@ export class ClassDynamicDispatch { // Runtime-owned roots keep their dedicated property contracts. A // family whose fields all exist from construction and are never // deleted keeps a fixed layout, as TypeScript classes do. - this.deletedNames ??= deletedPropertyNames(lowerer.moduleOrder); + // null is a result too; undefined means not computed yet. + if (this.deletedNames === undefined) + this.deletedNames = deletedPropertyNames(lowerer.moduleOrder); if (!root.base?.def.runtime && !fixedFieldFamily(root, this.deletedNames)) track(root); } const loc = this.propertyBag.loc; diff --git a/packages/compiler/src/frontend/lowering/construction-escapes.ts b/packages/compiler/src/frontend/lowering/construction-escapes.ts index a1626f12d..484920a1c 100644 --- a/packages/compiler/src/frontend/lowering/construction-escapes.ts +++ b/packages/compiler/src/frontend/lowering/construction-escapes.ts @@ -124,15 +124,6 @@ export function constructionEscape(inputs: ConstructionInputs): ConstructionEsca continue; } if (ts.isExpressionStatement(stmt) && !exposes(stmt.expression, depth)) continue; - // A check that only reads assigned fields and throws or does nothing - // with the receiver (`if (this.size < 0) throw new RangeError()`) - // does not expose the instance; assignments in its branches are not - // definite and still count as exposures. - if ( - (ts.isIfStatement(stmt) || ts.isThrowStatement(stmt) || ts.isBlock(stmt)) && - !exposes(stmt, depth) - ) - continue; return false; } return true; diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts new file mode 100644 index 000000000..23ebdfaa9 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.test.ts @@ -0,0 +1,38 @@ +import { afterAll, expect, test } from "vitest"; +import * as ts from "../ts7/adapter.js"; +import { closeSourceParser, parseSourceFile } from "../ts7/source-parser-node.js"; +import { isValueReturningConstructorClass } from "./js-dynamic-objects.js"; + +afterAll(closeSourceParser); + +function classify(source: string): boolean { + const file = parseSourceFile("classes.js", source, "js"); + let decl: ts.ClassDeclaration | undefined; + ts.walkPreorder(file, (node) => { + if (!decl && ts.isClassDeclaration(node)) decl = node; + }); + if (!decl) throw new Error("fixture has no class"); + return isValueReturningConstructorClass(decl); +} + +test("a constructor-only class returning a value is claimed", () => { + expect(classify(`class Chalk { constructor(options) { return chalkFactory(options); } }`)).toBe( + true, + ); + expect(classify(`class C { constructor(a) { if (a) return { a }; return [a]; } ; }`)).toBe(true); + expect(classify(`class C { constructor() { const f = () => 1; return { f }; } }`)).toBe(true); +}); + +test("classes that keep their instance layout are left alone", () => { + // No value return, or only nested functions return. + expect(classify(`class C { constructor() { return; } }`)).toBe(false); + expect(classify(`class C { constructor() { function f() { return 1; } f(); } }`)).toBe(false); + expect(classify(`class C { constructor() { const f = () => { return 1; }; f(); } }`)).toBe(false); + // Other members, heritage, or a constructor that observes `this`. + expect(classify(`class C { constructor() { return {}; } m() {} }`)).toBe(false); + expect(classify(`class C { x = 1; constructor() { return {}; } }`)).toBe(false); + expect(classify(`class C extends B { constructor() { super(); return {}; } }`)).toBe(false); + expect(classify(`class C { constructor() { this.a = 1; return {}; } }`)).toBe(false); + expect(classify(`class C { constructor() { const g = () => this; return { g }; } }`)).toBe(false); + expect(classify(`class C {}`)).toBe(false); +}); diff --git a/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts new file mode 100644 index 000000000..1d7ab6eee --- /dev/null +++ b/packages/compiler/src/frontend/lowering/js-dynamic-objects.ts @@ -0,0 +1,312 @@ +/* JavaScript declarations whose values only the checked-dynamic + * representation can hold faithfully. TypeScript infers a fixed object + * type for each of them, but the program changes the value's shape or + * identity at run time, so a static layout would answer stale members + * (or throw on a value that no longer fits): + * + * - a non-empty object literal bound to a variable that the same file + * grows or reshapes dynamically: a keyed write with a runtime key + * (`o[k] = v`), a `delete`, or `Object.defineProperty(o, ...)` / + * `Object.defineProperties(o, ...)` (ansi-styles' `assembleStyles`). + * The object literals nested in its property values belong to the same + * value graph and are marked with it; + * - a class whose only member is a constructor that returns a value and + * never reads `this` (chalk's `class Chalk { constructor(options) { + * return chalkFactory(options); } }`): `new C()` answers whatever the + * constructor returns, so its instance type has no fixed layout. + * + * The type mapper answers the checked-dynamic type for the instance and + * object-literal types these declarations own (TypeMapperCtx + * .jsDynamicDeclaration). The scan is syntactic, runs over JavaScript + * files only, and an empty answer leaves every mapping unchanged, so + * TypeScript programs and JavaScript that never uses these patterns + * compile exactly as before. */ +import * as ts from "../ts7/adapter.js"; +import { isJsSourceFile, locOf } from "../program.js"; +import { BOOL, DYN, type IrExpr, type IrStmt } from "../../ir/ir.js"; +import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js"; +import type { Lowerer } from "./lowerer.js"; +import type { ParamShape } from "./call-signatures.js"; +import { newFnCtx } from "./function-context.js"; + +const SCANNED_KINDS: ReadonlySet = new Set([ + ts.SyntaxKind.VariableDeclaration, + ts.SyntaxKind.ClassDeclaration, + ts.SyntaxKind.BinaryExpression, + ts.SyntaxKind.DeleteExpression, + ts.SyntaxKind.CallExpression, +]); + +function unparenthesized(node: ts.Expression): ts.Expression { + while (ts.isParenthesizedExpression(node)) node = node.expression; + return node; +} + +function isLiteralKey(node: ts.Expression): boolean { + const key = unparenthesized(node); + return ( + ts.isStringLiteral(key) || ts.isNumericLiteral(key) || ts.isNoSubstitutionTemplateLiteral(key) + ); +} + +function isAssignmentOperator(kind: ts.SyntaxKind): boolean { + return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment; +} + +/** `class C { constructor(...) { ...; return value; } }` with nothing else: + * no heritage, decorators or other members, a constructor body that + * returns a value at its own level and never mentions `this`/`super`. */ +export function isValueReturningConstructorClass(decl: ts.ClassDeclaration): boolean { + if (decl.heritageClauses !== undefined && decl.heritageClauses.length > 0) return false; + if (decl.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.Decorator)) return false; + let ctor: ts.ConstructorDeclaration | undefined; + for (const member of decl.members) { + if (ts.isSemicolonClassElement(member)) continue; + if (!ts.isConstructorDeclaration(member) || ctor !== undefined) return false; + ctor = member; + } + if (ctor?.body === undefined) return false; + let returnsValue = false; + let observesThis = false; + const visit = (node: ts.Node): void => { + if (observesThis) return; + if (node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.SuperKeyword) { + observesThis = true; + return; + } + // Arrow functions share the constructor's `this`; other functions + // have their own `this` and their own returns. + if (ts.isFunctionLike(node) && !ts.isArrowFunction(node)) return; + if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) return; + if (ts.isReturnStatement(node) && node.expression !== undefined && !insideArrow(node, ctor!)) + returnsValue = true; + node.forEachChild(visit); + }; + ctor.body.forEachChild(visit); + for (const parameter of ctor.parameters) parameter.forEachChild(visit); + return returnsValue && !observesThis; +} + +function insideArrow(node: ts.Node, ctor: ts.ConstructorDeclaration): boolean { + for (let p = node.parent; p !== undefined && p !== ctor; p = p.parent) { + if (ts.isArrowFunction(p)) return true; + } + return false; +} + +function markNested(literal: ts.ObjectLiteralExpression, out: Set): void { + if (out.has(literal)) return; + out.add(literal); + for (const property of literal.properties) { + if (!ts.isPropertyAssignment(property)) continue; + const value = unparenthesized(property.initializer); + if (ts.isObjectLiteralExpression(value)) markNested(value, out); + } +} + +export function jsDynamicDeclarations( + files: readonly ts.SourceFile[], + checker: ts.TypeChecker, +): Set { + const out = new Set(); + for (const file of files) { + if (!isJsSourceFile(file) || file.isDeclarationFile) continue; + const literals = new Map(); + const reshaped = new Set(); + const receiver = (expression: ts.Expression | undefined): void => { + if (expression === undefined) return; + const target = unparenthesized(expression); + if (!ts.isIdentifier(target)) return; + const symbol = checker.getSymbolAtLocation(target); + if (symbol !== undefined) reshaped.add(symbol); + }; + ts.walkPreorder( + file, + (node) => { + if (ts.isVariableDeclaration(node)) { + if (!ts.isIdentifier(node.name) || node.initializer === undefined) return; + const init = unparenthesized(node.initializer); + // An empty literal's binding is already checked-dynamic + // (jsOpenObjectType), and its type describes no layout. + if (!ts.isObjectLiteralExpression(init) || init.properties.length === 0) return; + const symbol = checker.getSymbolAtLocation(node.name); + if (symbol !== undefined) literals.set(symbol, init); + return; + } + if (ts.isClassDeclaration(node)) { + if (isValueReturningConstructorClass(node)) out.add(node); + return; + } + if (ts.isBinaryExpression(node)) { + if (!isAssignmentOperator(node.operatorToken.kind)) return; + const left = unparenthesized(node.left); + if (ts.isElementAccessExpression(left) && !isLiteralKey(left.argumentExpression)) + receiver(left.expression); + return; + } + if (ts.isDeleteExpression(node)) { + const operand = unparenthesized(node.expression); + if (ts.isElementAccessExpression(operand) || ts.isPropertyAccessExpression(operand)) + receiver(operand.expression); + return; + } + if (ts.isCallExpression(node)) { + const callee = unparenthesized(node.expression); + if ( + ts.isPropertyAccessExpression(callee) && + ts.isIdentifier(callee.expression) && + callee.expression.text === "Object" && + (callee.name.text === "defineProperty" || callee.name.text === "defineProperties") + ) + receiver(node.arguments[0]); + } + }, + SCANNED_KINDS, + ); + for (const symbol of reshaped) { + const literal = literals.get(symbol); + if (literal !== undefined) markNested(literal, out); + } + } + return out; +} + +/** `new C(args)` for a value-returning constructor class (above): the + * constructor body runs as an ordinary JavaScript function whose result + * is the construction's value. A returned object or function is Node's + * answer; a fall-through or primitive return would answer the bare + * instance, which has no static home here, and throws the deferred + * refusal instead. Null when the callee is not such a class. */ +export function lowerValueReturningConstructorNew( + lowerer: Lowerer, + expr: ts.NewExpression, +): IrExpr | null { + const isDynamic = lowerer.typeCtx.jsDynamicDeclaration; + if (isDynamic === undefined) return null; + const callee = unparenthesized(expr.expression); + if (!ts.isIdentifier(callee)) return null; + let symbol = lowerer.resolveValueSymbol(callee); + if (symbol !== null && (symbol.flags & ts.SymbolFlags.Alias) !== 0) + symbol = lowerer.checker.getAliasedSymbol(symbol); + const decl = symbol + ? lowerer.checker + .declarationsOf(symbol) + .find((node): node is ts.ClassDeclaration => ts.isClassDeclaration(node) && isDynamic(node)) + : undefined; + if (decl === undefined) return null; + const loc = locOf(expr); + const ctor = decl.members.find(ts.isConstructorDeclaration)!; + const simple = ctor.parameters.every( + (p) => ts.isIdentifier(p.name) && p.dotDotDotToken === undefined && p.initializer === undefined, + ); + if (!simple || !ts.isSourceFile(decl.parent)) { + lowerer.unsupported( + "SC1090", + expr, + "constructing a class whose constructor returns a value, with parameter defaults, rest or patterns, or declared inside a function", + ); + } + const args = expr.arguments ?? []; + if (args.some(ts.isSpreadElement)) { + lowerer.unsupported( + "SC1090", + expr, + "spread arguments when constructing a class whose constructor returns a value", + ); + } + const key = `ctorValue:${decl.getSourceFile().fileName}:${decl.getStart()}`; + let name = lowerer.valueHelpers.get(key); + if (name === undefined) { + name = `%ctorValue.${lowerer.valueHelpers.size}`; + lowerer.valueHelpers.set(key, name); + const savedClass = lowerer.currentClass; + lowerer.currentClass = null; + lowerer.fnStack.push(newFnCtx(false, null, null, DYN)); + try { + const shapes: ParamShape[] = ctor.parameters.map(() => ({ type: DYN, mode: "required" })); + const declared = lowerer.declareParams(ctor.parameters, shapes); + const body: IrStmt[] = [ + ...declared.prologue, + ...lowerer.lowerStmts(ctor.body!.statements), + { + kind: "runtimeFence", + code: "SC1090", + message: `constructors that return no object (the bare instance of '${decl.name?.text ?? "class"}' has no representation here) are not supported yet [SC1090 at ${decl.getSourceFile().fileName}:${ts.getLineAndCharacterOfPosition(decl.getSourceFile(), ctor.getStart()).line + 1}]`, + loc: locOf(ctor), + }, + ]; + lowerer.liftedFns.push({ + name, + params: declared.params, + returnType: DYN, + locals: lowerer.ctx.locals, + body, + loc: locOf(ctor), + }); + } finally { + lowerer.fnStack.pop(); + lowerer.currentClass = savedClass; + } + } + const lowered = ctor.parameters.map((_, i) => + args[i] !== undefined ? lowerer.lowerExprExpecting(args[i]!, DYN) : dynUndefinedExpr(loc), + ); + // Surplus arguments still evaluate, left to right, after the others. + const surplus: IrStmt[] = args + .slice(ctor.parameters.length) + .map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc: locOf(arg) })); + const result = lowerer.declareHiddenLocal("%constructed", DYN); + const value: IrExpr = { kind: "varRef", localId: result.id, type: DYN, loc }; + const sf = expr.getSourceFile(); + const line = ts.getLineAndCharacterOfPosition(sf, expr.getStart()).line + 1; + const objectLike: IrExpr = { + kind: "logical", + op: "||", + left: { kind: "dynTest", test: "function", value, type: BOOL, loc }, + right: { + kind: "logical", + op: "&&", + left: { kind: "dynTest", test: "object", value, type: BOOL, loc }, + right: { kind: "dynTest", test: "null", negated: true, value, type: BOOL, loc }, + type: BOOL, + loc, + }, + type: BOOL, + loc, + }; + const args0: IrStmt[] = []; + const argLocals = lowered.map((arg) => { + const local = lowerer.declareHiddenLocal("%constructArg", DYN); + args0.push({ kind: "varDecl", localId: local.id, init: arg, loc }); + return { kind: "varRef", localId: local.id, type: DYN, loc } as IrExpr; + }); + return { + kind: "seqExpr", + stmts: [ + ...args0, + ...surplus, + { + kind: "varDecl", + localId: result.id, + init: { kind: "call", callee: name, args: argLocals, type: DYN, loc }, + loc, + }, + ], + result: { + kind: "ternary", + cond: objectLike, + then: value, + else_: nodeThrowExpr( + 0, + "SC1090", + `constructors that return no object are not supported yet [SC1090 at ${sf.fileName}:${line}]`, + DYN, + loc, + ), + type: DYN, + loc, + }, + type: DYN, + loc, + }; +} diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 3260c0484..2037ba17c 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -3480,13 +3480,41 @@ function lowerDynReceiverMethodCall( // its name overlaps a primitive prototype (`colors.bold(...)`): the // source value was compiled from that object shape, while genuinely // untyped/any receivers retain the runtime-kind ambiguity and fence. - if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable) return null; + // A name only String.prototype declares (`bold`, `italics`, `link`, + // ...) on a checker-untyped receiver: every other dyn kind answers its + // own or inherited member exactly like a non-prototype name (chalk's + // `chalk.red.bold(...)` reads a prototype getter of a function), so + // only a string receiver keeps the refusal, deferred to run time. + const stringOnlyName = + checkerUntyped && !ownCallable && DYN_STRING_PROTO_ONLY_NAMES.has(access.name.text); + if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable && !stringOnlyName) return null; // Optional forms (`obj.cb?.()`, `obj?.cb()`) belong to the chain // machinery's short-circuit semantics — not modeled here yet. if (call.questionDotToken || access.questionDotToken) return null; const loc = locOf(call); const receiverLocal = lowerer.declareHiddenLocal("%dynCallReceiver", DYN); const receiver: IrExpr = { kind: "varRef", localId: receiverLocal.id, type: DYN, loc }; + // The string refusal throws in place of the member read (a seqExpr + // statement cannot leave the expression). + const stringRefusal = (read: IrExpr): IrExpr => { + if (!stringOnlyName) return read; + const sf = call.getSourceFile(); + const line = ts.getLineAndCharacterOfPosition(sf, call.getStart(sf)).line + 1; + return { + kind: "ternary", + cond: { kind: "dynTest", test: "string", value: receiver, type: BOOL, loc }, + then: nodeThrowExpr( + 0, + "SC1090", + `method calls like '${access.getText()}' on a string are not supported yet [SC1090 at ${sf.fileName}:${line}]`, + DYN, + loc, + ), + else_: read, + type: DYN, + loc, + }; + }; const member: IrExpr = { kind: "dynKeyGet", key: { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access) }, @@ -3498,7 +3526,7 @@ function lowerDynReceiverMethodCall( const callee = varRef(calleeLocal.id, DYN, loc); const stmts: IrStmt[] = [ { kind: "varDecl", localId: receiverLocal.id, init: recv, loc }, - { kind: "varDecl", localId: calleeLocal.id, init: member, loc }, + { kind: "varDecl", localId: calleeLocal.id, init: stringRefusal(member), loc }, ]; if (call.arguments.some(ts.isSpreadElement)) { const spread = lowerSpreadArgsCall(lowerer, call, callee, loc); @@ -3607,6 +3635,31 @@ const DYN_PROTO_METHOD_NAMES = new Set([ "toPrecision", ]); +/** The DYN_PROTO_METHOD_NAMES that only String.prototype declares among + * the dyn-representable kinds' prototypes. */ +const DYN_STRING_PROTO_ONLY_NAMES = new Set([ + "anchor", + "big", + "blink", + "bold", + "codePointAt", + "fixed", + "fontcolor", + "fontsize", + "isWellFormed", + "italics", + "link", + "localeCompare", + "normalize", + "small", + "strike", + "sub", + "sup", + "toLocaleLowerCase", + "toLocaleUpperCase", + "toWellFormed", +]); + /** The SHARED prototype names scr_dyn_invoke dispatches at runtime (the * subset of DYN_PROTO_METHOD_NAMES with a receiver-kind dispatch): the * runtime runs the real method for the receiver's kind, throws Node's diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts index 7b2d176c3..b177b231d 100644 --- a/packages/compiler/src/frontend/lowering/lower-classes.ts +++ b/packages/compiler/src/frontend/lowering/lower-classes.ts @@ -1,3 +1,4 @@ +import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js"; import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js"; import { checkedIterableSpread } from "./checked-iterable-spread.js"; import { lowerReadlineUiNew } from "./builtins/readline.js"; @@ -143,7 +144,7 @@ import { lowerObjectFactoryNew } from "./object-factory-new.js"; import { tryLowerExpression } from "./expressions/try-lower-expression.js"; import { lowerInstanceConstructorNew } from "./class-instance-constructor.js"; import { classPrototypeData } from "./class-prototypes.js"; -import { constructionEscape, mentionsReceiver } from "./construction-escapes.js"; +import { constructionEscape } from "./construction-escapes.js"; import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js"; import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js"; import { reflectedClassStaticMethodValue } from "./class-method-values.js"; @@ -468,11 +469,6 @@ export interface ClassInfo { * unassigned read throws the catchable TypeError instead of yielding * an undefined the declared type cannot hold (SEMANTICS.md). */ deferredInitFields?: Set; - /** Fields (inherited included) that code construction exposes the - * instance to can read before their assignment: the slot is the - * undefined-armed union, allocation writes undefined, and reads yield the - * union value, so an early read sees undefined as in Node. */ - earlyReadFields?: Set; /** True when construction may hand the instance to other code (a method * call, an argument, a callback, or a base constructor that does) — a * subclass's own fields can then be read before their assignment. */ @@ -3507,54 +3503,55 @@ export function collectClassShapeInner( const derived = decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ?? false; - // A generic family is not emitted; its instances and each mixin - // application analyze their own construction with their actual base. - const escape: { escapes: boolean; assigned: Set | null } = familyMode - ? { escapes: derived, assigned: null } - : constructionEscape({ - ctor, - fields: fieldOrder.flatMap((f) => - paramProps.some((pp) => pp.name === f.name) - ? [] - : [{ name: f.name, initializer: f.initializer }], - ), - paramProps: paramProps.map((pp) => pp.name), - derived, - baseEscapes: - base === null || - callableBase !== undefined || - factoryBaseExpression !== undefined || - base.constructionEscapes === true, - isField: (name) => - fields.has(name) && - !methods.has(`set:${name}`) && - !lowerer.findMethodOn(base, `set:${name}`), - privateMethodBody: (call) => { - const callee = call.expression; - if (!ts.isPropertyAccessExpression(callee)) return null; - const name = callee.name.text; - const declaration = decl.members.find( - (member): member is ts.MethodDeclaration => - ts.isMethodDeclaration(member) && - member.body !== undefined && - (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) && - member.name.text === name, - ); - if (!declaration?.body || declaration.asteriskToken) return null; - const modifiers = ts.getModifiers(declaration) ?? []; - if ( - modifiers.some( - (m) => - m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AsyncKeyword, + // Generic instances and mixins share layouts across declarations, so + // they only report whether construction exposes the instance. + const escape: { escapes: boolean; assigned: Set | null } = + familyMode || mixin + ? { escapes: derived, assigned: null } + : constructionEscape({ + ctor, + fields: fieldOrder.flatMap((f) => + paramProps.some((pp) => pp.name === f.name) + ? [] + : [{ name: f.name, initializer: f.initializer }], + ), + paramProps: paramProps.map((pp) => pp.name), + derived, + baseEscapes: + base === null || + callableBase !== undefined || + factoryBaseExpression !== undefined || + base.constructionEscapes === true, + isField: (name) => + fields.has(name) && + !methods.has(`set:${name}`) && + !lowerer.findMethodOn(base, `set:${name}`), + privateMethodBody: (call) => { + const callee = call.expression; + if (!ts.isPropertyAccessExpression(callee)) return null; + const name = callee.name.text; + const declaration = decl.members.find( + (member): member is ts.MethodDeclaration => + ts.isMethodDeclaration(member) && + member.body !== undefined && + (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) && + member.name.text === name, + ); + if (!declaration?.body || declaration.asteriskToken) return null; + const modifiers = ts.getModifiers(declaration) ?? []; + if ( + modifiers.some( + (m) => + m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AsyncKeyword, + ) ) - ) - return null; - const isPrivate = - ts.isPrivateIdentifier(declaration.name) || - modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword); - return isPrivate ? declaration.body : null; - }, - }); + return null; + const isPrivate = + ts.isPrivateIdentifier(declaration.name) || + modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword); + return isPrivate ? declaration.body : null; + }, + }); // The deferred definite-assignment check: a field on the unguarded // list passes only with an unconditional `this.x = ...` at the // constructor's TOP LEVEL — the same standard the JS-class path @@ -3610,30 +3607,18 @@ export function collectClassShapeInner( } } - // Fields assigned after construction can expose the instance (a method - // call, a base constructor that calls an override) can be read while - // Node still holds undefined. Their slots admit undefined, allocation - // writes it, and reads yield it, as in Node. - const earlyReadFields = new Set(base?.earlyReadFields ?? []); - if (escape.assigned && escape.escapes) { + if (escape.assigned && !inst) { for (const f of fieldOrder) { if (f.redeclared || escape.assigned.has(f.name) || deferredInitFields.has(f.name)) continue; + if (paramProps.some((pp) => pp.name === f.name)) continue; const declared = fields.get(f.name); - if (declared === undefined || !earlyReadable(lowerer, declared)) continue; - // A declared `T | undefined` field already starts undefined. - if (declared.kind === "union" && lowerer.armTag(declared.unionId, UNDEFINED_T) >= 0) + if (declared?.kind !== "object" || lowerer.classes.get(declared.className)?.def.runtime) continue; - const armed = lowerer.runtimeOptionalType(declared); - if (armed.kind !== "union") continue; + const armed = lowerer.withUndefinedArm(declared); + if (armed === null || armed.kind !== "union") continue; fields.set(f.name, armed); f.type = armed; - // Primitive and union slots yield the undefined value itself. - // Reference slots keep the deferred-init reads: consumers that - // observe undefined (printing, equality, typeof, nullish defaults) - // see it, and member access on it throws a TypeError, as in Node. - if (declared.kind === "union" || PRIMITIVE_EARLY_READS.has(declared.kind)) - earlyReadFields.add(f.name); - else deferredInitFields.add(f.name); + deferredInitFields.add(f.name); } } @@ -3738,43 +3723,6 @@ export function collectClassShapeInner( (name) => !hasAccessor(name) && !methods.has(name) && !lowerer.findMethodOn(base, name), ) : null; - // Constructor statements that run after the instance may have been - // exposed (a method call, `this` passed along, a base constructor - // that exposes it): a field they create can be read before its - // assignment, while Node holds undefined. - const exposedBefore = new Set(); - { - let exposed = false; - for (const stmt of ctor?.body?.statements ?? []) { - const expression = ts.isExpressionStatement(stmt) ? stmt.expression : null; - if ( - expression && - ts.isCallExpression(expression) && - expression.expression.kind === ts.SyntaxKind.SuperKeyword - ) { - if (base?.constructionEscapes === true || expression.arguments.some(mentionsReceiver)) - exposed = true; - continue; - } - const assigned = - expression && - ts.isBinaryExpression(expression) && - expression.operatorToken.kind === ts.SyntaxKind.EqualsToken && - ts.isPropertyAccessExpression(expression.left) && - expression.left.expression.kind === ts.SyntaxKind.ThisKeyword - ? expression - : null; - if (exposed || (assigned && mentionsReceiver(assigned.right))) exposedBefore.add(stmt); - const plainAssignment = - assigned !== null && - ts.isPropertyAccessExpression(assigned.left) && - !mentionsReceiver(assigned.right) && - !hasAccessor(assigned.left.name.text) && - !methods.has(assigned.left.name.text) && - !lowerer.findMethodOn(base, assigned.left.name.text); - if (!plainAssignment && mentionsReceiver(stmt)) exposed = true; - } - } if (ctor?.body) { for (const stmt of ctor.body.statements) { const lhs = @@ -3845,15 +3793,8 @@ export function collectClassShapeInner( type = inheritedJsFieldType(lowerer, decl, name, type); // super() can invoke a subclass setter or method before its // constructor assignments run. These slots start undefined. - const sealed = sealedPrefix?.created.has(name) === true; - if (base && lowerer.dynConvertible(type) && !sealed) type = DYN; - if (exposedBefore.has(stmt) && !sealed && earlyReadable(lowerer, type)) { - const armed = lowerer.runtimeOptionalType(type); - if (armed.kind === "union") { - type = armed; - earlyReadFields.add(name); - } - } + if (base && lowerer.dynConvertible(type) && !sealedPrefix?.created.has(name)) + type = DYN; fields.set(name, type); fieldOrder.push({ name, type, initializer: undefined }); continue; @@ -4114,7 +4055,6 @@ export function collectClassShapeInner( ? { classDecorators: { nodes: classDecoratorNodes } } : {}), ...(deferredInitFields.size > 0 ? { deferredInitFields } : {}), - ...(earlyReadFields.size > 0 ? { earlyReadFields } : {}), ...(escape.escapes ? { constructionEscapes: true as const } : {}), }; // GENERIC members get their declaring-class backlink now that the @@ -6289,33 +6229,6 @@ function overrideReturnAbi( return declared; } -/** Field kinds whose early reads yield the undefined value (earlyReadFields). */ -const PRIMITIVE_EARLY_READS: ReadonlySet = new Set([ - "f64", - "bool", - "string", - "bigint", -]); - -/** Field types whose slot can admit undefined for reads before the field's - * assignment. Date values are scalars, so their unassigned slot is memory - * safe; checked-dynamic slots already hold undefined. */ -function earlyReadable(lowerer: Lowerer, type: IrType): boolean { - if (isUnitType(type)) return false; - switch (type.kind) { - case "dyn": - case "void": - case "date": - case "generator": - case "caught": - return false; - case "object": - return lowerer.classes.get(type.className)?.def.runtime !== true; - default: - return true; - } -} - /** The nearest declaration of `name` at or above `info` — the method a * receiver of that static class runs when nothing below overrides it. */ export function findMethodOn( @@ -7753,11 +7666,7 @@ function paramPropInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLoca obj: { kind: "varRef", localId: thisLocal.id, type: thisType, loc }, className: info.def.name, field: pp.name, - // An early-readable field's slot admits undefined (earlyReadFields). - value: lowerer.coerceToExpected( - { kind: "varRef", localId: local!.id, type: local!.type, loc }, - info.fields.get(pp.name) ?? local!.type, - ), + value: { kind: "varRef", localId: local!.id, type: local!.type, loc }, loc, }); } @@ -8551,6 +8460,8 @@ export function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr { undefined, lowerer.checker.getSymbolAtLocation(expr.expression), ); + const valueReturning = lowerValueReturningConstructorNew(lowerer, expr); + if (valueReturning) return valueReturning; const instanceConstructor = lowerInstanceConstructorNew(lowerer, expr); if (instanceConstructor) return instanceConstructor; const objectFactory = lowerObjectFactoryNew(lowerer, expr); diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index 4ef139293..b1116dd27 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -3161,51 +3161,6 @@ export function lowerTernary( * the same union (unnarrowed use), to a SUB-union (partial narrowing — * unrepresentable without a re-tag), or to nothing (`never` in an * exhaustive default) leaves the expression union-typed. */ -/** Uses that read an early-read field's value as Node does when it is - * undefined: printing, templates, operators, tests, member access, calls of - * program functions (whose parameters the optional-value analysis widens), - * and stores into bindings, fields and returns. Other uses, such as library - * arguments, extract the declared type with a check. */ -function observesEarlyRead(node: ts.Node): boolean { - let child = node; - let parent = node.parent; - while (parent && ts.isParenthesizedExpression(parent)) { - child = parent; - parent = parent.parent; - } - if (!parent) return false; - if ( - ts.isTemplateSpan(parent) || - ts.isBinaryExpression(parent) || - ts.isPrefixUnaryExpression(parent) || - ts.isPostfixUnaryExpression(parent) || - ts.isTypeOfExpression(parent) || - ts.isConditionalExpression(parent) || - ts.isIfStatement(parent) || - ts.isWhileStatement(parent) || - ts.isReturnStatement(parent) || - ts.isVariableDeclaration(parent) || - ts.isPropertyAssignment(parent) || - ts.isArrayLiteralExpression(parent) || - (ts.isPropertyAccessExpression(parent) && parent.expression === child) || - (ts.isElementAccessExpression(parent) && parent.expression === child) - ) - return true; - if (ts.isCallExpression(parent) && parent.arguments.includes(child as ts.Expression)) { - const callee = parent.expression; - if ( - ts.isPropertyAccessExpression(callee) && - ts.isIdentifier(callee.expression) && - callee.expression.text === "console" - ) - return true; - return ( - !ts.isPropertyAccessExpression(callee) || callee.expression.kind === ts.SyntaxKind.ThisKeyword - ); - } - return false; -} - export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrExpr { if ( (expr.type.kind === "union" || expr.type.kind === "dyn") && @@ -3416,25 +3371,6 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx if (expr.type.kind !== "union") return expr; if (ts.isPropertyAccessExpression(node) && isOptionalProcessStreamProperty(lowerer, node)) return expr; - // A field read before its assignment holds undefined although its - // declared type omits it; the declared type is no narrowing proof. A flow - // narrowing past the declared type (`if (this.x !== null)`) extracts the - // narrowed arm with a check, since the slot may still hold undefined. - if ( - expr.kind === "fieldGet" && - lowerer.classes.get(expr.className)?.earlyReadFields?.has(expr.field) === true - ) { - const symbol = ts.isPropertyAccessExpression(node) - ? lowerer.checker.getSymbolAtLocation(node.name) - : undefined; - const declared = symbol ? lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(symbol)) : null; - const narrowedArm = lowerer.mapTypeOf(lowerer.typeOf(node)); - if (narrowedArm === null || narrowedArm.kind === "union") return expr; - if (declared !== null && typeEquals(declared, narrowedArm) && observesEarlyRead(node)) - return expr; - const helper = lowerer.narrowedArmHelper(expr.type.unionId, narrowedArm, expr.loc); - return helper ? lowerer.checkedNarrowCall(helper, expr, narrowedArm, expr.loc) : expr; - } // Represented fields and index values can include undefined even when // checker inference or lib.d.ts declares strings (RegExp captures). @@ -5082,6 +5018,34 @@ export function lowerIntrinsicProperty( return { kind: "libCall", fn: "dyn.arrayPrototype", args: [], type: DYN, loc: locOf(expr) }; if (lowerer.stdlibGlobalMember(expr, "Object") === "prototype") return { kind: "libCall", fn: "dyn.objectPrototype", args: [], type: DYN, loc: locOf(expr) }; + // Function.prototype as a VALUE (a prototype-chain link: + // `Object.setPrototypeOf(F.prototype, Function.prototype)`): one + // anonymous function answering undefined, length 0 — a zero-capture + // closure of a compiler helper, so every read is the same function + // (closure identity) and shares its property table. Reads through it + // find the function members the checked runtime models for every + // function (apply, constructor, name, length). Member forms keep their + // own lowerings. + if (lowerer.stdlibGlobalMember(expr, "Function") === "prototype") { + const loc = locOf(expr); + const name = "%dyn.functionPrototype"; + if (!lowerer.liftedFns.some((fn) => fn.name === name)) + lowerer.liftedFns.push({ + name, + params: [], + locals: [], + returnType: DYN, + body: [{ kind: "return", value: dynUndefinedExpr(loc), loc }], + loc, + }); + return { + kind: "dynFrom", + value: { kind: "closure", fnName: name, captures: [], type: funcOf([], DYN), loc }, + fnName: "", + type: DYN, + loc, + }; + } if (lowerer.stdlibGlobalMember(expr, "Array") === "isArray") return lowerArrayIsArrayValue(lowerer, locOf(expr)); if (lowerer.stdlibGlobalMember(expr, "Array") === "from") @@ -11538,6 +11502,34 @@ function lowerLogicalPair(lowerer: Lowerer, expr: ts.BinaryExpression, left: IrE // same lift the union-operand path above takes, arriving here // with two plain arm values instead. const target = lowerer.mapTypeOf(lowerer.typeOf(expr)); + // An always-truthy left operand (a record, object, array or function + // value: every JS object is truthy): `o && x` evaluates `o` for its + // effects and answers `x`; `o || x` answers `o` and never evaluates + // `x`. supports-color's `stream && stream.isTTY` is the shape. Ahead + // of the union lift below exactly where that lift would store the + // object in a result union with no arm for it; a union holding the + // operand keeps the lift. + if ( + REF_TRUTHY_KINDS.has(kind) && + (target?.kind !== "union" || + (op === ts.SyntaxKind.AmpersandAmpersandToken && + lowerer.armTag(target.unionId, left.type) < 0)) + ) { + const and = op === ts.SyntaxKind.AmpersandAmpersandToken; + const answer = and ? right : left; + const answerT = target ?? answer.type; + if (answerT.kind !== "void") { + const value = lowerer.coerceInto(and ? expr.right : expr.left, answer, answerT); + if (!and) return value; + return { + kind: "seqExpr", + stmts: [{ kind: "exprStmt", expr: left, loc }], + result: value, + type: answerT, + loc, + }; + } + } if (target?.kind === "union") { lowerer.requireTruthyUnion(target.unionId, expr); return { @@ -15465,20 +15457,6 @@ export function fieldGetExpr( const helper = lowerer.deferredReadHelper(target.fieldType.unionId, inner, loc); if (helper) return { kind: "call", callee: helper, args: [read], type: inner, loc }; } - // An early-read field (ClassInfo.earlyReadFields) yields its undefined - // where the use reads it as Node does; elsewhere the declared type is - // extracted with a check. - if ( - target.fieldType.kind === "union" && - lowerer.classes.get(target.className)?.earlyReadFields?.has(target.field) === true && - !observesEarlyRead(blame) - ) { - const declared = lowerer.mapTypeOf(lowerer.typeOf(blame)); - if (declared && declared.kind !== "union") { - const helper = lowerer.narrowedArmHelper(target.fieldType.unionId, declared, loc); - if (helper) return lowerer.checkedNarrowCall(helper, read, declared, loc); - } - } return read; } return { @@ -16019,22 +15997,6 @@ function lowerFieldCompoundValue( if (op === "+" && read.type.kind === "string") { appended = lowerer.ensureString(rhs, rhsNode ?? access); value = { kind: "strConcat", left: read, right: appended, type: STRING, loc }; - } else if ( - op === "+" && - read.type.kind === "union" && - lowerer.stripUndefinedArm(read.type).kind === "string" && - target.container === "class" && - lowerer.classes.get(target.className)?.earlyReadFields?.has(target.field) === true - ) { - // A string field read before its assignment holds undefined, which - // concatenates as "undefined". - value = { - kind: "strConcat", - left: lowerer.ensureString(read, access), - right: lowerer.ensureString(rhs, rhsNode ?? access), - type: STRING, - loc, - }; } else if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") { value = { kind: "bin", op, left: numericRead, right: numericRhs, type: F64, loc }; } else if (bigintValue) { diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts index 93f00596c..9eb512332 100644 --- a/packages/compiler/src/frontend/lowering/lower-stmts.ts +++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts @@ -10,6 +10,7 @@ import { InternalCompilerError } from "../../errors.js"; * flow (if/while/for/for-of/do, switch, try/catch, abrupt completions), * explicit resource management, and blocked-binding poisoning. */ import * as ts from "../ts7/adapter.js"; +import { processDataMemberValue } from "./builtins/process.js"; import { requireInitFlagStmt } from "./require-initialization.js"; import { isJsonRequireDecl } from "./json-require.js"; import { bindingSource } from "../binding-source.js"; @@ -3277,6 +3278,9 @@ function stdlibGlobalTokenDestructure( token: string; alias: string | null; g: IrGlobal | undefined; + /** A data member's value (`const { env } = process`), bound instead + * of a token. */ + value?: IrExpr; }[] = []; for (const el of decl.name.elements) { if (el.name === undefined) continue; @@ -3312,8 +3316,9 @@ function stdlibGlobalTokenDestructure( "destructuring with computed keys that do not fold to one property name", ); } - let token: string; + let token = ""; let alias: string | null = null; + let value: IrExpr | null = null; if (globalName === "globalThis") { // The member must BE a stdlib global (user script vars are // properties of `typeof globalThis` too — their values are real @@ -3333,6 +3338,13 @@ function stdlibGlobalTokenDestructure( token = `[builtin console.${propName}]`; } else if (TOKEN_OPAQUE_GLOBALS.has(globalName)) { token = `[builtin ${globalName}.${propName}]`; + } else if ( + globalName === "process" && + ts.isIdentifier(el.name) && + (value = processDataMemberValue(lowerer, propName, el.name, locOf(el))) !== null + ) { + // A data member reads its value once, exactly like the spelled + // `process.` read the destructuring performs. } else { lowerer.unsupported( "SC1031", @@ -3349,6 +3361,10 @@ function stdlibGlobalTokenDestructure( ); } const g = lowerer.globalsBySymbol.get(symbol); + if (value !== null) { + binds.push({ name: el.name, token, alias, g, value }); + continue; + } if (g !== undefined && g.type.kind !== "string" && g.type.kind !== "dyn") { lowerer.unsupported( "SC1031", @@ -3361,6 +3377,21 @@ function stdlibGlobalTokenDestructure( const out: IrStmt[] = []; for (const b of binds) { const loc = locOf(b.name); + if (b.value !== undefined) { + if (b.g !== undefined) { + out.push({ + kind: "assign", + localId: b.g.id, + value: lowerer.coerceInto(b.name, b.value, b.g.type), + ...(b.g.tdz ? { initializes: true as const } : {}), + loc, + }); + } else { + const local = lowerer.declareLocal(b.name, b.name.text, b.value.type, isLet); + out.push({ kind: "varDecl", localId: local.id, init: b.value, loc }); + } + continue; + } const token: IrExpr = { kind: "strLit", value: b.token, type: STRING, loc }; if (b.alias !== null) { const symbol = lowerer.checker.getSymbolAtLocation(b.name); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index b77768c28..dc218b3aa 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1,3 +1,4 @@ +import { jsDynamicDeclarations } from "./js-dynamic-objects.js"; import { lifetimeRegionType, lowerLifetimeRegionCall, @@ -2902,6 +2903,8 @@ export class Lowerer { this.fileTag.set(sf, sf === entry ? "" : `%m${i}.`); }); if (this.moduleOrder.length === 0) this.fileTag.set(entry, ""); + const jsDynamic = jsDynamicDeclarations(this.moduleOrder, this.checker); + if (jsDynamic.size > 0) this.typeCtx.jsDynamicDeclaration = (decl) => jsDynamic.has(decl); this.registerBuiltinErrorClasses(); registerBuiltinEmitterClass(this); registerBuiltinStreamClasses(this); @@ -3976,18 +3979,6 @@ export class Lowerer { if (!s) return null; return s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s; }; - // Fields that can be read before their assignment hold undefined then; - // their reads are runtime-optional values like missing array reads. - for (const info of this.classes.values()) { - if (!info.earlyReadFields || !info.decl?.name) continue; - const classSymbol = symbolOf(info.decl.name); - if (!classSymbol) continue; - const instance = this.checker.getDeclaredTypeOfSymbol(classSymbol); - for (const name of info.earlyReadFields) { - const property = this.checker.getPropertyOfType(instance, name); - if (property) optionalSymbols.add(property); - } - } const signatureOf = (node: ts.Identifier): FnSig | null => { const symbol = symbolOf(node); if (!symbol) return null; diff --git a/packages/compiler/src/frontend/npm-static-prune.ts b/packages/compiler/src/frontend/npm-static-prune.ts index c6c1f9caf..a420b6b7c 100644 --- a/packages/compiler/src/frontend/npm-static-prune.ts +++ b/packages/compiler/src/frontend/npm-static-prune.ts @@ -15,7 +15,21 @@ export function isPrunedNpmReexport(program: ts.Program, stmt: ts.ExportDeclarat return program.analysis.prunedNpmReexports.has(stmt); } -function packageJson(path: string): Record | null { +type PackageJson = Record | null; + +/** Parsed package.json files by path, kept for one plan: every purity check + * reads the metadata of its file's package again. */ +type PackageJsonCache = Map; + +function packageJson(path: string, cache: PackageJsonCache): PackageJson { + const cached = cache.get(path); + if (cached !== undefined) return cached; + const json = readPackageJson(path); + cache.set(path, json); + return json; +} + +function readPackageJson(path: string): PackageJson { const source = trackedReadFile(path); if (source === null) return null; try { @@ -58,12 +72,16 @@ function sideEffectPattern(pattern: string): RegExp { /** A nested format scope such as dist/esm/package.json is not the package's * published metadata. Stay inside the resolved package while finding its * named root, including pnpm's realpath and workspace-linked installs. */ -function packageRootJsonPath(fromFile: string, packageName: string): string | null { +function packageRootJsonPath( + fromFile: string, + packageName: string, + cache: PackageJsonCache, +): string | null { let dir = dirname(resolve(fromFile)); let root: string | null = null; while (npmPackageNameOf(dir.replaceAll("\\", "/")) === packageName) { const path = join(dir, "package.json"); - if (packageJson(path)?.["name"] === packageName) root = path; + if (packageJson(path, cache)?.["name"] === packageName) root = path; const parent = dirname(dir); if (parent === dir) break; dir = parent; @@ -73,9 +91,13 @@ function packageRootJsonPath(fromFile: string, packageName: string): string | nu // An external package's executable sources may not be in this program. // Preserve the conservative whole-dependency promise in that case. -function pureExternalPackage(path: string, visiting = new Set()): boolean { +function pureExternalPackage( + path: string, + cache: PackageJsonCache, + visiting = new Set(), +): boolean { if (visiting.has(path)) return true; - const json = packageJson(path); + const json = packageJson(path, cache); const value = json?.["sideEffects"]; if (json === null || !(value === false || (Array.isArray(value) && value.length === 0))) return false; @@ -85,8 +107,8 @@ function pureExternalPackage(path: string, visiting = new Set()): boolea if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue; for (const name of Object.keys(dependencies)) { const resolved = resolveBareModule(path, name, "js-only"); - const root = resolved === null ? null : packageRootJsonPath(resolved.typesFile, name); - if (root === null || !pureExternalPackage(root, visiting)) return false; + const root = resolved === null ? null : packageRootJsonPath(resolved.typesFile, name, cache); + if (root === null || !pureExternalPackage(root, cache, visiting)) return false; } } return true; @@ -135,10 +157,11 @@ export function planNpmStaticReexports( for (const path of extraRoots) request(program.getSourceFile(path) ?? null, null); const pureMemo = new Map(); + const packageJsons: PackageJsonCache = new Map(); const filePure = (sf: ts.SourceFile): boolean => { const pkg = npmPackageNameOf(sf.fileName) ?? npmStaticPackageOfPath(sf.fileName); - const path = pkg === null ? null : packageRootJsonPath(sf.fileName, pkg); - const json = path === null ? null : packageJson(path); + const path = pkg === null ? null : packageRootJsonPath(sf.fileName, pkg, packageJsons); + const json = path === null ? null : packageJson(path, packageJsons); const value = json?.["sideEffects"]; if (value === false) return true; if ( @@ -195,8 +218,10 @@ export function planNpmStaticReexports( const resolved = resolveBareModule(sf.fileName, edge.spec, "js-only"); const pkg = resolved === null ? null : npmPackageNameOf(resolved.typesFile); const root = - pkg === null || resolved === null ? null : packageRootJsonPath(resolved.typesFile, pkg); - return root !== null && pureExternalPackage(root); + pkg === null || resolved === null + ? null + : packageRootJsonPath(resolved.typesFile, pkg, packageJsons); + return root !== null && pureExternalPackage(root, packageJsons); }); }; const pure = visit(root); diff --git a/packages/compiler/src/frontend/npm-static.ts b/packages/compiler/src/frontend/npm-static.ts index 1f83a12d4..d2f4ea3e8 100644 --- a/packages/compiler/src/frontend/npm-static.ts +++ b/packages/compiler/src/frontend/npm-static.ts @@ -190,6 +190,10 @@ export function npmStaticTransformPkgJson(pkg: Record): void { for (const value of Object.values(obj)) transform(value); }; if (pkg["exports"] !== undefined) transform(pkg["exports"]); + // The "imports" field maps "#" specifiers with the same condition objects + // (chalk 5's `"#supports-color": { node, default }`), so Node's "node" + // target hoists there too. + if (pkg["imports"] !== undefined) transform(pkg["imports"]); } /** npmStaticTransformPkgJson over a package.json TEXT (the fs shadow's diff --git a/packages/compiler/src/frontend/resolve.test.ts b/packages/compiler/src/frontend/resolve.test.ts index 0d135b3c2..0dd09e73d 100644 --- a/packages/compiler/src/frontend/resolve.test.ts +++ b/packages/compiler/src/frontend/resolve.test.ts @@ -11,6 +11,7 @@ import { setProjectPathMappings, setProjectRealm, } from "./resolve.js"; +import { setNpmStaticPackages } from "./npm-static.js"; const fixturesRoot = join(import.meta.dirname, "../../../..", "tests/fixtures"); @@ -60,3 +61,56 @@ test("source-only workspace packages are project modules while JavaScript packag clearResolveCaches(); } }); + +test("package imports inside a --npm-static package answer the shipped JavaScript", async () => { + // chalk 5's shape: a declaration twin beside every runtime file, and a + // `{ node, default }` imports entry whose node target is what Node runs. + const dir = realpathSync(await mkdtemp(join(tmpdir(), "scriptc-resolve-imports-"))); + try { + const pkg = join(dir, "node_modules", "colors"); + const vendor = join(pkg, "source", "vendor"); + await mkdir(join(vendor, "styles"), { recursive: true }); + await mkdir(join(vendor, "detect"), { recursive: true }); + await Promise.all([ + writeFile( + join(pkg, "package.json"), + JSON.stringify({ + name: "colors", + version: "1.0.0", + type: "module", + exports: "./source/index.js", + imports: { + "#styles": "./source/vendor/styles/index.js", + "#detect": { + node: "./source/vendor/detect/index.js", + default: "./source/vendor/detect/browser.js", + }, + }, + }), + ), + writeFile(join(pkg, "source", "index.js"), 'import styles from "#styles";\n'), + writeFile(join(pkg, "source", "index.d.ts"), "export {};\n"), + writeFile(join(vendor, "styles", "index.js"), "export default {};\n"), + writeFile(join(vendor, "styles", "index.d.ts"), "export {};\n"), + writeFile(join(vendor, "detect", "index.js"), "export default 1;\n"), + writeFile(join(vendor, "detect", "index.d.ts"), "export {};\n"), + writeFile(join(vendor, "detect", "browser.js"), "export default 0;\n"), + writeFile(join(vendor, "detect", "browser.d.ts"), "export {};\n"), + ]); + const from = join(pkg, "source", "index.js"); + + clearResolveCaches(); + setNpmStaticPackages([]); + expect(resolveProjectModule(from, "#styles")).toBe(join(vendor, "styles", "index.d.ts")); + + clearResolveCaches(); + setNpmStaticPackages(["colors"]); + expect(resolveProjectModule(from, "#styles")).toBe(join(vendor, "styles", "index.js")); + expect(resolveProjectModule(from, "#detect")).toBe(join(vendor, "detect", "index.js")); + expect(resolveProjectModule(from, "#missing")).toBeNull(); + } finally { + setNpmStaticPackages([]); + clearResolveCaches(); + await rm(dir, { recursive: true, force: true }); + } +}); diff --git a/packages/compiler/src/frontend/resolve.ts b/packages/compiler/src/frontend/resolve.ts index db440c199..463400475 100644 --- a/packages/compiler/src/frontend/resolve.ts +++ b/packages/compiler/src/frontend/resolve.ts @@ -617,6 +617,18 @@ export function resolveProjectImport(fromFile: string, specifier: string): strin // Node's validity rule: only the bare "#" is never resolvable ("#/..." // matches "#/*"-pattern keys on current Node). if (specifier === "#") return null; + // Inside an opted-in --npm-static package, an imports entry resolves + // the way the tsgo host's fs shadow does: the transformed document + // (the "node" condition hoisted), the runtime JS conditions, and the + // shipped JS rather than a declaration twin (see resolveRelativeModule). + if (npmStaticPackageOfPath(resolve(fromFile)) !== null) { + const transformed = JSON.parse(JSON.stringify(pkg)) as PkgJson & Record; + npmStaticTransformPkgJson(transformed); + const jsTarget = resolvePackageImports(transformed.imports, specifier, JS_ONLY_CONDITIONS); + if (jsTarget === null || !jsTarget.startsWith("./")) return null; + const jsPath = join(pkgDir, jsTarget); + return normalizeResolvedAnswer(loadAsJsFile(jsPath) ?? loadAsJsDirectory(jsPath)); + } target = resolvePackageImports(pkg.imports, specifier, EXPORT_CONDITIONS); // An imports target that is not "./"-relative is PACKAGE_RESOLVE'd as // a bare specifier (Node's PACKAGE_IMPORTS_EXPORTS_RESOLVE): the diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index 5ecfc60ae..f37703fd8 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -996,6 +996,10 @@ export type TypeParamTsResolver = (t: ts.Type) => ts.Type | null; * one new field here, not a new parameter at every call site. */ export interface TypeMapperCtx { checker: ts.TypeChecker; + /** JavaScript declarations whose instance or object-literal types only + * the checked-dynamic representation holds (js-dynamic-objects.ts). + * Absent when the program has none: every mapping is unchanged. */ + jsDynamicDeclaration?: (decl: ts.Node) => boolean; /** Set while mapping a generic callable member's erased type * (erasedGenericMemberType): the signature's own type parameters * resolve to `unknown` instead of refusing the mapping. */ @@ -1368,6 +1372,16 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { const intrinsic = type.getSymbol(); if (intrinsic?.name === "globalThis" && checker.declarationsOf(intrinsic).length === 0) return DYN; + if (ctx.jsDynamicDeclaration !== undefined && intrinsic !== undefined) { + const objectLiteral = (intrinsic.flags & ts.SymbolFlags.ObjectLiteral) !== 0; + const classInstance = + (intrinsic.flags & ts.SymbolFlags.Class) !== 0 && type.isClassOrInterface(); + if ( + (objectLiteral || classInstance) && + checker.declarationsOf(intrinsic).some((decl) => ctx.jsDynamicDeclaration!(decl)) + ) + return DYN; + } { const moduleId = ctx.moduleNamespaceId?.(type) ?? null; if (moduleId !== null) return { kind: "moduleNs", moduleId }; diff --git a/packages/compiler/test/class-early-field-reads.test.ts b/packages/compiler/test/class-early-field-reads.test.ts deleted file mode 100644 index c602a2f42..000000000 --- a/packages/compiler/test/class-early-field-reads.test.ts +++ /dev/null @@ -1,93 +0,0 @@ -import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; -import { tmpdir } from "node:os"; -import { join } from "node:path"; -import { expect, test } from "vitest"; -import { compile, deserializeModule, validateModule } from "../src/index.js"; -import type { IrModule } from "../src/ir/ir.js"; - -async function lower(source: string, file = "main.ts"): Promise { - const dir = await mkdtemp(join(tmpdir(), "scriptc-early-field-reads-")); - try { - const entry = join(dir, file), - output = join(dir, "main.ir.json"); - await writeFile(entry, source); - const result = await compile(entry, { outDir: dir, outPath: output, outputKind: "ir" }); - if (!result.ok) - throw new Error(result.diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n")); - const module = deserializeModule(await readFile(output, "utf8")); - expect(validateModule(module)).toEqual([]); - return module; - } finally { - await rm(dir, { recursive: true, force: true }); - } -} - -/** Field name → IR kind for a class. */ -function fields(module: IrModule, name: string): string { - const cls = module.classes.find((candidate) => candidate.name === name); - expect(cls, name).toBeDefined(); - return cls!.fields - .filter((field) => !field.name.startsWith("%")) - .map((field) => `${field.name}:${field.type.kind}`) - .join(" "); -} - -test("fields assigned after construction can call an override admit undefined", async () => { - const module = await lower(` -abstract class Base { - constructor() { - this.describe(); - } - abstract describe(): void; -} -class Panel extends Base { - label: string; - width: number; - count = 0; - constructor() { - super(); - this.label = "panel"; - this.width = 2; - } - describe(): void { - console.log(this.label, this.width, this.count); - } -} -class Plain { - label: string; - width: number; - constructor() { - this.label = "plain"; - this.width = 1; - this.describe(); - } - describe(): void { - console.log(this.label, this.width); - } -} -new Panel(); -new Plain(); -`); - expect(fields(module, "Panel")).toBe("label:union width:union count:union"); - expect(fields(module, "Plain")).toBe("label:string width:f64"); -}); - -test("JavaScript fields created after the constructor calls a method admit undefined", async () => { - const module = await lower( - ` -class Widget { - constructor() { - this.ready = true; - this.render(); - this.title = "widget"; - } - render() { - console.log(this.ready, this.title); - } -} -new Widget(); -`, - "main.js", - ); - expect(fields(module, "Widget")).toBe("ready:bool title:union"); -}); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json deleted file mode 100644 index d2dcdcc24..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5943-fields-read-before-assignment.ts.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/5943-fields-read-before-assignment.ts" - ], - "diags": [] -} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json deleted file mode 100644 index e9800b71d..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5944-js-fields-read-before-assignment.js.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "order": [ - "/tests/corpus/5944-js-fields-read-before-assignment.js" - ], - "diags": [] -} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json new file mode 100644 index 000000000..cdbf47751 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5980-cycle-components.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5980-cycle-components.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json new file mode 100644 index 000000000..0e719fe78 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/5996-rejections-between-macrotasks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/5996-rejections-between-macrotasks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json new file mode 100644 index 000000000..d1f487f89 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-builder-string-method-names/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/js-builder-string-method-names/builder.js", + "/tests/corpus/js-builder-string-method-names/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json new file mode 100644 index 000000000..8f1025c47 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-builder.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-callable-builder.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json new file mode 100644 index 000000000..e05f1760c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-constructor-returns/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/js-class-constructor-returns/factory.js", + "/tests/corpus/js-class-constructor-returns/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json new file mode 100644 index 000000000..b0fa827e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-function-prototype-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-function-prototype-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json new file mode 100644 index 000000000..608e24d40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-number-parse-dynamic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-number-parse-dynamic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json new file mode 100644 index 000000000..87d43324e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-process-destructure.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-process-destructure.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json new file mode 100644 index 000000000..939240b2c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reshaped-object-literal.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-reshaped-object-literal.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json new file mode 100644 index 000000000..96661c630 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/truthy-object-logical.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/truthy-object-logical.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json new file mode 100644 index 000000000..065c96347 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/chalk5/main.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_async.c b/packages/runtime/src/scr_async.c index 308c9198d..48f3a5329 100644 --- a/packages/runtime/src/scr_async.c +++ b/packages/runtime/src/scr_async.c @@ -4464,7 +4464,9 @@ static bool scr_loop_run_pass(ScrPromise *top_level, bool first_checkpoint) { } scr_firing_id = 0; if (scr_exc_pending()) return false; /* uncaught throw in a callback: main handles it */ - if (scr_ready_len > 0 || scr_nt_head != NULL) break; /* drain ticks and microtasks before more timers */ + /* Drain ticks and microtasks, and report the rejections the callback + * left, before more timers (Node's runNextTicks between timers). */ + if (scr_ready_len > 0 || scr_nt_head != NULL || scr_nunhandled > 0) break; } /* The check phase: immediates queued BEFORE this phase started run * now, FIFO; ones a callback queues wait for the next turn (the end @@ -4474,7 +4476,7 @@ static bool scr_loop_run_pass(ScrPromise *top_level, bool first_checkpoint) { * every macrotask; pending ticks or a woken fiber restart the turn * first (the timer loop's break above), so the phase only runs on a * drained checkpoint. */ - if (scr_ready_len == 0 && scr_nt_head == NULL && scr_pending_immediates > 0) { + if (scr_ready_len == 0 && scr_nt_head == NULL && scr_nunhandled == 0 && scr_pending_immediates > 0) { size_t end = scr_nimmediates; while (scr_immediates_head < end) { size_t i = scr_immediates_head++; @@ -4490,6 +4492,13 @@ static bool scr_loop_run_pass(ScrPromise *top_level, bool first_checkpoint) { scr_closure_release(cb); if (scr_exc_pending()) return false; /* uncaught throw: main handles it */ if (!scr_loop_run_checkpoint()) return false; + /* Node's runNextTicks between immediates also reports the + * rejections the callback left before the next one runs; a + * listener's jobs drain before the next report. */ + while (scr_nunhandled > 0 && (top_level == NULL || top_level->state != SCR_PROM_REJECTED)) { + if (scr_report_unhandled_rejections()) return true; + if (!scr_loop_run_checkpoint()) return false; + } if (top_level != NULL && top_level->state == SCR_PROM_REJECTED) break; } /* Fully drained: reset the cursor so the array reuses its slots. */ diff --git a/packages/runtime/src/scr_cycle.c b/packages/runtime/src/scr_cycle.c index 69485dd6c..e8e7c73fa 100644 --- a/packages/runtime/src/scr_cycle.c +++ b/packages/runtime/src/scr_cycle.c @@ -26,14 +26,19 @@ * count was already given up (which would over-decrement and free live * data). * - * The main graph phases keep a bounded depth-first walk and defer deeper - * traces to reusable worklists. Ordinary RC destruction and cross-generation - * releases are separate paths. White candidates are recorded during scan - * and filtered after outside roots settle, avoiding a separate gather walk. - * markGray also records the objects it grays and counts those still - * externally referenced (rc > 0 after the trial decrements). When none is, - * every gray object is garbage, which is what scan would find, so the pass - * whitens the recorded set and skips scan. + * The graph phases keep a bounded depth-first walk and defer deeper traces + * to reusable worklists. Ordinary RC destruction and cross-generation + * releases are separate paths. markGray records the objects it grays (up + * to SCR_CYC_GRAY_LIST_MAX) and counts those still externally referenced + * (rc > 0 after the trial decrements), per pass and per component: the + * objects first reached from one candidate. A component with none is + * garbage, which is what scan would find, so the pass dooms it at once. + * For the others, scan blackens from each recorded object that is still + * externally referenced, which restores exactly the survivors, and what + * stays gray is the garbage: no walk whitens it. Only a pass too large to + * record walks scan from the candidates, whitening as it goes, and then + * filters the white set after outside roots settle, avoiding a separate + * gather walk. * * ── generations ────────────────────────────────────────────────────── * A pass costs O(objects reachable from its candidates), and a candidate @@ -225,6 +230,9 @@ typedef struct { size_t trigger; size_t alloc_trigger; size_t gray_referenced; + size_t comp_referenced; + uint32_t gray_comp; + ScrVec live_ranges; size_t scheduled_mature_age; size_t xg_freed; size_t mature_dead; @@ -256,6 +264,9 @@ static _Thread_local ScrCycThread scr_cyc_thread = {.gen_limit = SCR_CYC_OLD}; #define scr_cyc_trigger (scr_cyc_thread.trigger) #define scr_cyc_alloc_trigger (scr_cyc_thread.alloc_trigger) #define scr_gray_referenced (scr_cyc_thread.gray_referenced) +#define scr_comp_referenced (scr_cyc_thread.comp_referenced) +#define scr_gray_comp (scr_cyc_thread.gray_comp) +#define scr_live_ranges (scr_cyc_thread.live_ranges) #define scr_cyc_scheduled_mature_age (scr_cyc_thread.scheduled_mature_age) #define scr_xg_freed (scr_cyc_thread.xg_freed) #define scr_cyc_mature_dead (scr_cyc_thread.mature_dead) @@ -347,7 +358,7 @@ void *scr_cyc_alloc(size_t size, ScrCycType *type) { void scr_cyc_free(void *obj) { scr_cyc_free_inline(obj); } -static void scr_cyc_grow(ScrVec *vec) { +static __attribute__((noinline, cold)) void scr_cyc_grow(ScrVec *vec) { /* Candidate positions are 31-bit (ScrCycHdr.buf). */ if (vec->cap > (size_t)(SCR_CYC_BUFFERED_BIT - 1) / 2) scr_cyc_oom(); vec->cap = vec->cap ? vec->cap * 2 : 64; @@ -368,6 +379,16 @@ static inline void scr_cyc_push_work(ScrVec *vec, void *obj) { if (vec->n > vec->used) vec->used = vec->n; } +/* The same push inline, for the gray list markGray fills once per object; + * the pass records the list's high-water mark itself (scr_cyc_note_used). */ +static inline void scr_cyc_push_gray(ScrVec *vec, void *obj) { + if (__builtin_expect(vec->n == vec->cap, 0)) scr_cyc_grow(vec); + vec->v[vec->n++] = obj; +} +static inline void scr_cyc_note_used(ScrVec *vec) { + if (vec->n > vec->used) vec->used = vec->n; +} + /* ── the candidate-root buffers (one per generation) ──────────────────── */ #ifndef SCR_WORKERS @@ -392,7 +413,6 @@ static SCR_TL ScrVec scr_promote; static SCR_TL ScrVec scr_pending; static SCR_TL ScrVec scr_restore_pending; #endif -#define SCR_CYC_WALK_DEPTH 64 /* The gathered white set (freed after the walk completes). */ #ifndef SCR_WORKERS @@ -547,9 +567,19 @@ static SCR_TL size_t scr_cyc_alloc_trigger = 0; #endif /* Gray objects whose count is above zero after the trial decrements so far * (see scr_mg_visit). markGray records the gray objects in scr_white while - * there are fewer than SCR_CYC_GRAY_LIST_MAX; a larger walk runs scan. */ + * there are fewer than SCR_CYC_GRAY_LIST_MAX; a larger walk runs scan. + * + * The same count is kept per component (see "components" at scr_cyc_pass): + * the objects one candidate's walk grays first carry that walk's number in + * `buf` (gray objects are never buffered during a pass), and + * scr_comp_referenced counts those still externally referenced. + * scr_live_ranges holds (start, end) ranges of scr_white whose component + * was externally referenced and is left to scan. */ #ifndef SCR_WORKERS static SCR_TL size_t scr_gray_referenced = 0; +static SCR_TL size_t scr_comp_referenced = 0; +static SCR_TL uint32_t scr_gray_comp = 0; +static SCR_TL ScrVec scr_live_ranges; #endif #define SCR_CYC_GRAY_LIST_MAX 65536 @@ -982,42 +1012,103 @@ void scr_cyc_on_release(void *obj) { ((child) == NULL || SCR_RC(child) == SIZE_MAX \ || scr_cyc_gen(scr_cyc_hdr(child)) > scr_gen_limit) -/* Trace callbacks forward an integer depth through their opaque context; - * it is never dereferenced. The ABI already carries it through every edge. */ -static void scr_mark_gray(void *obj, uintptr_t depth); +/* The walks are depth-first and recursive up to SCR_CYC_WALK_DEPTH, where + * an object is queued instead (scr_pending, or scr_restore_pending for the + * restoration, which can run inside scan) and traced from the queue. Trace + * callbacks forward that integer depth through their opaque context; it is + * never dereferenced. */ +#define SCR_CYC_WALK_DEPTH 64 + +/* A walk visits a dense cycle-capable array's children itself: the present + * dense elements, which are all scr_arr_trace_v visits when the array has + * no sparse entries, properties or metadata (no `ext`). Each walk gets its + * own copy, out of line, so the per-edge visitors stay small. */ +#define SCR_CYC_ARRAY_WALK(name, visit) \ + static __attribute__((noinline)) void name(const ScrArr *arr, void *ctx) { \ + size_t end = arr->len < arr->cap ? arr->len : arr->cap; \ + size_t filled = arr->filled < end ? arr->filled : end; \ + for (size_t i = 0; i < filled; i++) visit((void *)(uintptr_t)arr->data[i], ctx); \ + for (size_t i = filled; i < end; i++) \ + if (arr->present[i] == SCR_ARR_VALUE) visit((void *)(uintptr_t)arr->data[i], ctx); \ + } + +/* Visit every child of `obj` with VISIT, through ARRAY_WALK for a dense + * cycle-capable array and through the type's trace otherwise. */ +#define SCR_CYC_CHILDREN(obj, type, ARRAY_WALK, VISIT, depth) \ + do { \ + if ((type)->kind == SCR_CYC_KIND_ARRAY && ((const ScrArr *)(obj))->ext == NULL) \ + ARRAY_WALK((const ScrArr *)(obj), (void *)(depth)); \ + else \ + (type)->trace((obj), (VISIT), (void *)(depth)); \ + } while (0) + +static void scr_mg_visit(void *child, void *ctx); +static void scr_sb_visit(void *child, void *ctx); +static void scr_scan_visit(void *child, void *ctx); +SCR_CYC_ARRAY_WALK(scr_mg_array, scr_mg_visit) +SCR_CYC_ARRAY_WALK(scr_sb_array, scr_sb_visit) +SCR_CYC_ARRAY_WALK(scr_scan_array, scr_scan_visit) + +static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth); static void scr_mg_visit(void *child, void *ctx) { if (child == NULL || SCR_RC(child) == SIZE_MAX) return; - if (scr_cyc_gen(scr_cyc_hdr(child)) > scr_gen_limit) { + ScrCycHdr *h = scr_cyc_hdr(child); + if (scr_cyc_gen(h) > scr_gen_limit) { scr_cyc_push_work(&scr_xgen_edges, scr_gray_holder); scr_cyc_push_work(&scr_xgen_edges, child); return; } size_t rc = --SCR_RC(child); - if (scr_cyc_color(scr_cyc_hdr(child)) == SCR_CYC_GRAY) { - if (rc == 0) scr_gray_referenced--; + if (scr_cyc_color(h) == SCR_CYC_GRAY) { + if (rc == 0) { + scr_gray_referenced--; + if (h->buf == scr_gray_comp) scr_comp_referenced--; + } return; } scr_mark_gray(child, (uintptr_t)ctx); } -static void scr_mark_gray(void *obj, uintptr_t depth) { +/* markGray reaches `obj` (its count already trial-decremented): gray it, + * number it with the walk's component, record it, count it while it is + * externally referenced, and walk its children. */ +static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); - if (scr_cyc_color(h) == SCR_CYC_GRAY) return; scr_cyc_set_color(h, SCR_CYC_GRAY); /* A full pass takes every buffer, so each buffered object it reaches - * leaves its buffer here, in the header write the walk makes anyway. */ - if (scr_gen_limit == SCR_CYC_OLD && !scr_cyc_take) scr_cyc_clear_buffered(h); - if (scr_white.n < SCR_CYC_GRAY_LIST_MAX) scr_cyc_push_work(&scr_white, obj); - if (SCR_RC(obj) > 0) scr_gray_referenced++; + * leaves its buffer here, in the header write that numbers it anyway. A + * limited pass can gray candidates it did not take; they keep their + * buffer position and are simply never counted as members. */ + if (!scr_cyc_is_buffered(h) || (scr_gen_limit == SCR_CYC_OLD && !scr_cyc_take)) + h->buf = scr_gray_comp; + if (scr_white.n < SCR_CYC_GRAY_LIST_MAX) scr_cyc_push_gray(&scr_white, obj); + if (SCR_RC(obj) > 0) { + scr_gray_referenced++; + scr_comp_referenced++; + } if (depth == SCR_CYC_WALK_DEPTH) { scr_cyc_push_work(&scr_pending, obj); return; } void *holder = scr_gray_holder; scr_gray_holder = obj; - scr_cyc_type(h)->trace(obj, scr_mg_visit, (void *)(depth + 1)); + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_mg_array, scr_mg_visit, depth + 1); scr_gray_holder = holder; } +/* markGray from one (black) candidate, through the queue. */ +static void scr_mark_gray_from(void *root) { + scr_mark_gray(root, 0); + while (scr_pending.n) { + void *obj = scr_pending.v[--scr_pending.n]; + const ScrCycType *type = scr_cyc_type(scr_cyc_hdr(obj)); + scr_gray_holder = obj; + SCR_CYC_CHILDREN(obj, type, scr_mg_array, scr_mg_visit, 1); + } +} +/* scan's restoration: blacken an externally referenced object and + * everything it reaches that is not black yet, giving back the trial + * decrements of the edges it follows. */ static void scr_scan_black(void *obj, uintptr_t depth); static void scr_sb_visit(void *child, void *ctx) { if (SCR_CYC_SKIP(child)) return; @@ -1028,14 +1119,29 @@ static void scr_sb_visit(void *child, void *ctx) { static void scr_scan_black(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); scr_cyc_set_color(h, SCR_CYC_BLACK); + /* Drop markGray's component number: a survivor leaves the pass unbuffered + * unless it is a candidate that a limited pass did not take. */ + if (!scr_cyc_is_buffered(h)) scr_cyc_clear_buffered(h); if (scr_cyc_gen(h) < SCR_CYC_OLD) scr_cyc_push_work(&scr_promote, obj); if (depth == SCR_CYC_WALK_DEPTH) { scr_cyc_push_work(&scr_restore_pending, obj); return; } - scr_cyc_type(h)->trace(obj, scr_sb_visit, (void *)(depth + 1)); + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_sb_array, scr_sb_visit, depth + 1); +} +static void scr_restore_from(void *root) { + scr_scan_black(root, 0); + while (scr_restore_pending.n) { + void *obj = scr_restore_pending.v[--scr_restore_pending.n]; + const ScrCycType *type = scr_cyc_type(scr_cyc_hdr(obj)); + SCR_CYC_CHILDREN(obj, type, scr_sb_array, scr_sb_visit, 1); + } } +/* scan, walking: restore a gray object that is externally referenced, else + * whiten it, record it once (a later outside root can still restore it; + * settle filters the list) and walk its children. */ static void scr_scan(void *obj, uintptr_t depth); static void scr_scan_visit(void *child, void *ctx) { if (SCR_CYC_SKIP(child)) return; @@ -1045,22 +1151,17 @@ static void scr_scan(void *obj, uintptr_t depth) { ScrCycHdr *h = scr_cyc_hdr(obj); if (scr_cyc_color(h) != SCR_CYC_GRAY) return; if (SCR_RC(obj) > 0) { - scr_scan_black(obj, 0); - while (scr_restore_pending.n) { - void *next = scr_restore_pending.v[--scr_restore_pending.n]; - scr_cyc_type(scr_cyc_hdr(next))->trace(next, scr_sb_visit, NULL); - } + scr_restore_from(obj); return; } scr_cyc_set_color(h, SCR_CYC_WHITE); - /* Record each whitened object once. A later outside root can restore it; - * filter the list only after every scan finishes. No gather trace needed. */ scr_cyc_push_work(&scr_white, obj); if (depth == SCR_CYC_WALK_DEPTH) { scr_cyc_push_work(&scr_pending, obj); return; } - scr_cyc_type(h)->trace(obj, scr_scan_visit, (void *)(depth + 1)); + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_scan_array, scr_scan_visit, depth + 1); } /* ── cross-generation edges ───────────────────────────────────────────── */ @@ -1138,22 +1239,28 @@ static SCR_CYC_COMPACT void scr_xg_release(void *obj) { * spend their time in the trace and teardown calls they make, so this half is * built for size; the graph walk above it stays fully optimized. Returns how * many objects the pass freed. */ -static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit) { +static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit, bool doomed) { size_t dead = 0; scr_cyc_mature_dead = 0; - for (size_t i = 0; i < scr_white.n; i++) { + scr_cyc_note_used(&scr_white); + /* The list holds the dead set: doomed components, and what scan whitened + * (black once a later outside root restored it), or, when the pass found + * nothing externally referenced, every gray object. `doomed` says that + * every entry is a doomed component's already. */ + for (size_t i = 0; i < scr_white.n && !doomed; i++) { void *obj = scr_white.v[i]; ScrCycHdr *h = scr_cyc_hdr(obj); - if (scr_cyc_color(h) != SCR_CYC_WHITE) continue; - /* A limited pass can reach candidates it did not take: out of their - * buffers before they are freed. */ - if (scr_cyc_take && scr_cyc_is_buffered(h)) scr_cyc_on_dead(obj); - scr_cyc_set_color(h, SCR_CYC_DOOMED); - if (gen_limit < SCR_CYC_OLD) scr_cyc_freed(scr_cyc_type(h), gen_limit); - else scr_cyc_mature_dead += scr_cyc_gen(h) == SCR_CYC_MATURE; + unsigned color = scr_cyc_color(h); + if (color == SCR_CYC_BLACK) continue; + if (color != SCR_CYC_DOOMED) { + /* A limited pass can reach candidates it did not take: out of their + * buffers before they are freed. */ + if (scr_cyc_take && scr_cyc_is_buffered(h)) scr_cyc_on_dead(obj); + scr_cyc_set_color(h, SCR_CYC_DOOMED); + } scr_white.v[dead++] = obj; } - scr_white.n = dead; + if (!doomed) scr_white.n = dead; /* Pin the cross-generation targets of everything about to be freed, while * `gen` still holds the values the walk filtered on (promotion below is @@ -1217,13 +1324,19 @@ static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit) { * over every page the dead structure used, and the structures built from * them, and every later walk over those, would miss the cache on most * objects. In address order the blocks come back in the order the bump - * pointers hand out fresh memory. Teardown order is not observable. */ + * pointers hand out fresh memory. Teardown order is not observable. The + * level statistics are counted here, where the teardown reads the type + * anyway; they only steer later passes. */ size_t freed = scr_white.n; if (scr_white.n >= SCR_CYC_ORDER_MIN) scr_mem_order_for_free(scr_white.v, scr_white.n, sizeof(ScrCycHdr)); for (size_t i = 0; i < scr_white.n; i++) { void *obj = scr_white.v[i]; - scr_cyc_type(scr_cyc_hdr(obj))->free_fn(obj); + ScrCycHdr *h = scr_cyc_hdr(obj); + const ScrCycType *type = scr_cyc_type(h); + if (gen_limit < SCR_CYC_OLD) scr_cyc_freed(type, gen_limit); + else scr_cyc_mature_dead += scr_cyc_gen(h) == SCR_CYC_MATURE; + type->free_fn(obj); } scr_white.n = 0; @@ -1299,6 +1412,7 @@ static size_t scr_cyc_pass_done(size_t freed) { scr_cyc_trim(&scr_restore_pending); scr_cyc_trim(&scr_xgen); scr_cyc_trim(&scr_xgen_edges); + scr_cyc_trim(&scr_live_ranges); return freed; } @@ -1369,28 +1483,114 @@ static size_t scr_cyc_pass(unsigned gen_limit) { scr_xgen_edges.n = 0; scr_white.n = 0; scr_gray_referenced = 0; - for (size_t i = 0; i < scr_cands.n; i++) scr_mark_gray(scr_cands.v[i], 0); - while (scr_pending.n) { - void *obj = scr_pending.v[--scr_pending.n]; - scr_gray_holder = obj; - scr_cyc_type(scr_cyc_hdr(obj))->trace(obj, scr_mg_visit, NULL); + scr_live_ranges.n = 0; + /* Components. Each candidate that no earlier walk reached starts a walk + * of its own, and the objects that walk grays first form its component. + * A component whose objects all end the walk at count zero is garbage: + * a count of zero means every reference to the object was trial-deleted, + * i.e. came from an object grayed so far. An earlier component cannot + * hold one (the walk that grayed it would have grayed the target too), + * so every reference comes from inside the component, and a later walk + * cannot add one: its objects would be referencing this component, and + * those references are still counted. scan would whiten exactly this + * set, so it is doomed at once and scan runs only over the components + * that are externally referenced, if any. A limited pass keeps the single + * whole-pass decision below (its untaken candidates cannot carry the + * component number). */ + bool split = scr_cyc_take == NULL; + uint32_t comp = 0; + for (size_t i = 0; i < scr_cands.n; i++) { + void *obj = scr_cands.v[i]; + if (scr_cyc_color(scr_cyc_hdr(obj)) != SCR_CYC_BLACK) continue; /* walked already */ + size_t start = scr_white.n; + scr_gray_comp = split ? ++comp : 0; + scr_comp_referenced = 0; + scr_mark_gray_from(obj); + if (!split) continue; + size_t end = scr_white.n; + if (scr_comp_referenced == 0 && end < SCR_CYC_GRAY_LIST_MAX) { + for (size_t j = start; j < end; j++) scr_cyc_set_color(scr_cyc_hdr(scr_white.v[j]), SCR_CYC_DOOMED); + } else if (scr_live_ranges.n && (uintptr_t)scr_live_ranges.v[scr_live_ranges.n - 1] == start) { + scr_live_ranges.v[scr_live_ranges.n - 1] = (void *)(uintptr_t)end; + } else { + scr_cyc_push_work(&scr_live_ranges, (void *)(uintptr_t)start); + scr_cyc_push_work(&scr_live_ranges, (void *)(uintptr_t)end); + } } - if (scr_gray_referenced == 0 && scr_white.n < SCR_CYC_GRAY_LIST_MAX) { - for (size_t i = 0; i < scr_white.n; i++) scr_cyc_set_color(scr_cyc_hdr(scr_white.v[i]), SCR_CYC_WHITE); - return scr_cyc_pass_done(scr_cyc_settle(gen_limit)); + scr_cyc_note_used(&scr_white); + /* Nothing externally referenced at all: every gray object is garbage, + * including components that looked referenced only because a later + * component held them. settle dooms the recorded set. */ + if (scr_gray_referenced == 0 && scr_white.n < SCR_CYC_GRAY_LIST_MAX) + return scr_cyc_pass_done(scr_cyc_settle(gen_limit, split && scr_live_ranges.n == 0)); + + /* scan, from the recorded set when markGray recorded every gray object: + * the survivors are exactly what the externally referenced gray objects + * reach, so blackening from each of them in turn leaves the garbage gray + * without walking it again, and settle dooms what is still gray. Only + * the referenced components' entries need looking at; the doomed ones + * are settled already. */ + if (scr_white.n < SCR_CYC_GRAY_LIST_MAX) { + /* One sweep over the list, keeping the doomed components' entries and, + * of the referenced components', only those still gray: a survivor + * leaves the list as soon as it is seen black, and an object kept here + * that a later restoration blackens is skipped by settle. */ + size_t kept = 0, from = 0; + size_t nranges = split ? scr_live_ranges.n : 2; + for (size_t k = 0; k < nranges; k += 2) { + size_t start = split ? (uintptr_t)scr_live_ranges.v[k] : 0; + size_t end = split ? (uintptr_t)scr_live_ranges.v[k + 1] : scr_white.n; + if (start > from) memmove(scr_white.v + kept, scr_white.v + from, (start - from) * sizeof *scr_white.v); + kept += start - from; + for (size_t j = start; j < end; j++) { + void *obj = scr_white.v[j]; + if (scr_cyc_color(scr_cyc_hdr(obj)) != SCR_CYC_GRAY) continue; + if (SCR_RC(obj) > 0) scr_restore_from(obj); + else scr_white.v[kept++] = obj; + } + from = end; + } + if (scr_white.n > from) memmove(scr_white.v + kept, scr_white.v + from, (scr_white.n - from) * sizeof *scr_white.v); + scr_white.n = kept + (scr_white.n - from); + return scr_cyc_pass_done(scr_cyc_settle(gen_limit, false)); } - scr_white.n = 0; - for (size_t i = 0; i < scr_cands.n; i++) scr_scan(scr_cands.v[i], 0); + /* Otherwise scan walks from the candidates. Keep only the doomed + * components' entries; scan appends what it whitens. */ + if (!split) { + scr_white.n = 0; + } else if (scr_live_ranges.n) { + size_t kept = 0, from = 0; + for (size_t k = 0; k < scr_live_ranges.n; k += 2) { + size_t start = (uintptr_t)scr_live_ranges.v[k], end = (uintptr_t)scr_live_ranges.v[k + 1]; + memmove(scr_white.v + kept, scr_white.v + from, (start - from) * sizeof *scr_white.v); + kept += start - from; + from = end; + } + memmove(scr_white.v + kept, scr_white.v + from, (scr_white.n - from) * sizeof *scr_white.v); + scr_white.n = kept + (scr_white.n - from); + } + /* Externally referenced candidates first: what they restore is never + * whitened only to be restored again. */ + for (size_t i = 0; i < scr_cands.n; i++) { + void *obj = scr_cands.v[i]; + if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_GRAY && SCR_RC(obj) > 0) scr_restore_from(obj); + } + for (size_t i = 0; i < scr_cands.n; i++) { + void *obj = scr_cands.v[i]; + if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_GRAY) scr_scan(obj, 0); + } while (scr_pending.n) { void *obj = scr_pending.v[--scr_pending.n]; - /* A later outside root may have restored this deferred white node and - * its descendants already. Never scan a black node's edges again. */ - if (scr_cyc_color(scr_cyc_hdr(obj)) == SCR_CYC_WHITE) - scr_cyc_type(scr_cyc_hdr(obj))->trace(obj, scr_scan_visit, NULL); + /* A later outside root may have restored this deferred white object and + * its descendants already. Never scan a black object's edges again. */ + ScrCycHdr *h = scr_cyc_hdr(obj); + if (scr_cyc_color(h) != SCR_CYC_WHITE) continue; + const ScrCycType *type = scr_cyc_type(h); + SCR_CYC_CHILDREN(obj, type, scr_scan_array, scr_scan_visit, 1); } - return scr_cyc_pass_done(scr_cyc_settle(gen_limit)); + return scr_cyc_pass_done(scr_cyc_settle(gen_limit, false)); } #ifdef SCR_CYC_TESTING @@ -1425,7 +1625,7 @@ void scr_collect_cycles(void) { void scr_cyc_context_cleanup(void) { scr_collect_cycles(); ScrVec *vectors[] = {&scr_roots[SCR_CYC_NURSERY], &scr_roots[SCR_CYC_MATURE], - &scr_roots[SCR_CYC_OLD], &scr_cands, &scr_promote, &scr_pending, &scr_restore_pending, &scr_white, &scr_xgen, &scr_xgen_edges, + &scr_roots[SCR_CYC_OLD], &scr_cands, &scr_promote, &scr_pending, &scr_restore_pending, &scr_white, &scr_xgen, &scr_xgen_edges, &scr_live_ranges, &scr_pub_holes[SCR_CYC_NURSERY], &scr_pub_holes[SCR_CYC_MATURE], &scr_pub_holes[SCR_CYC_OLD]}; for (size_t i = 0; i < sizeof vectors / sizeof vectors[0]; i++) { free(vectors[i]->v); diff --git a/packages/runtime/src/scr_rc.h b/packages/runtime/src/scr_rc.h index cdc03c966..d6e1f8e88 100644 --- a/packages/runtime/src/scr_rc.h +++ b/packages/runtime/src/scr_rc.h @@ -92,6 +92,9 @@ typedef struct ScrCycType { * SCR_CYC_KIND_EMITTED (llvm/alloc.ts FIRST_EMITTED_CYC_KIND). */ enum { SCR_CYC_KIND_NONE = 0, + /* Also how the collector recognizes a cycle-capable ScrArr, whose dense + * elements it visits inline (scr_cycle.c SCR_CYC_CHILDREN): reserved for + * scr_array.c's descriptor. */ SCR_CYC_KIND_ARRAY, SCR_CYC_KIND_PROMISE, SCR_CYC_KIND_BOX, diff --git a/tests/corpus/5943-fields-read-before-assignment.ts b/tests/corpus/5943-fields-read-before-assignment.ts deleted file mode 100644 index 922b3c34d..000000000 --- a/tests/corpus/5943-fields-read-before-assignment.ts +++ /dev/null @@ -1,181 +0,0 @@ -// @transform-types -// Fields that a base constructor (or the constructor itself) can read -// through an override or a method call before they are assigned hold -// undefined then, as in Node, for every field kind. After construction -// the fields read and update normally. -class Point { - x: number; - constructor(x: number) { - this.x = x; - } -} -function show(label: string, value: number): string { - return `${label}=${value}`; -} -abstract class Widget { - log: string[] = []; - constructor() { - this.describe("base"); - } - abstract describe(when: string): void; -} -class Panel extends Widget { - label: string; - width: number; - visible: boolean; - origin: Point; - items: number[]; - options: { depth: number }; - key: string | number; - index: Map; - tags: Set; - count = 5; - constructor(label: string, readonly id: string) { - super(); - this.label = label; - this.width = 10; - this.visible = true; - this.origin = new Point(1); - this.items = [1, 2]; - this.options = { depth: 2 }; - this.key = 7; - this.index = new Map([["a", 1]]); - this.tags = new Set(["t"]); - this.describe("ctor"); - } - describe(when: string): void { - console.log(when, this.label, this.width, this.visible, this.origin, this.items, this.options, this.key, this.count, this.id); - console.log(when, `${this.label}:${this.width}`, this.width + 1, this.count * 2, this.label === undefined, typeof this.items, this.origin?.x, this.options?.depth ?? -1, this.index?.size, this.tags?.has("t")); - console.log(when, show(this.label, this.width), String(this.key), [this.label].length); - try { - console.log(this.label.length, this.items.length); - } catch (error) { - console.log(when, (error as Error).message); - } - } - grow(): number { - this.count++; - this.width += 5; - this.label += "!"; - this.items.push(this.width); - return this.count + this.width + this.items.length; - } -} -const panel = new Panel("main", "p1"); -console.log(panel.grow(), panel.label, panel.items, panel.count, panel.width); - -class Plain { - total: number; - name: string; - constructor() { - this.total = 1; - this.name = "plain"; - this.bump(); - } - bump(): void { - this.total++; - } -} -const plain = new Plain(); -console.log(plain.total, plain.name); - -class Toucher { - constructor() { - this.touch(); - } - touch(): void {} -} -class Counter extends Toucher { - count = 0; - label: string; - items: string[]; - constructor() { - super(); - this.label = "c"; - this.items = []; - } - override touch(): void { - this.count++; - this.label += "x"; - console.log(this.count, this.label, Number.isNaN(this.count)); - try { - this.items.push("a"); - } catch (error) { - console.log(error instanceof TypeError); - } - } -} -const c = new Counter(); -c.touch(); -console.log(c.count, c.label, c.items); - -class Shower { - constructor() { - this.show(); - } - show(): void {} -} -class Box extends Shower { - label: string; - value: T; - constructor(value: T) { - super(); - this.label = "box"; - this.value = value; - } - override show(): void { - console.log("show", this.label, this.value); - } -} -new Box(3).show(); -new Box("s").show(); - -type Ctor = new (...args: any[]) => T; -class Viewer { - constructor() { - this.show(); - } - show(): void {} -} -function Labeled>(Parent: B) { - return class extends Parent { - label = "mixed"; - override show(): void { - console.log("show", this.label); - } - }; -} -const L = Labeled(Viewer); -new L().show(); - -interface Crash { loc: number; message: string } -class Setupper { - constructor() { - this.setup(); - } - setup(): void {} -} -class Host extends Setupper { - crash: Crash | null; - name: string | null; - constructor(c: Crash | null) { - super(); - this.crash = c; - this.name = "host"; - } - override setup(): void { - console.log("setup", this.crash, this.name); - if (this.crash !== null) { - try { - console.log(this.crash.loc); - } catch (error) { - console.log(error instanceof TypeError); - } - } - } - report(): string { - if (this.crash) return `${this.crash.message} at ${this.crash.loc}`; - return this.name === null ? "none" : this.name.toUpperCase(); - } -} -console.log(new Host({ loc: 3, message: "boom" }).report(), new Host(null).report()); diff --git a/tests/corpus/5944-js-fields-read-before-assignment.js b/tests/corpus/5944-js-fields-read-before-assignment.js deleted file mode 100644 index e313a12b0..000000000 --- a/tests/corpus/5944-js-fields-read-before-assignment.js +++ /dev/null @@ -1,28 +0,0 @@ -// JavaScript class fields that the constructor creates after it calls a -// method, or after a base constructor that does, hold undefined until -// they are assigned, as in Node. -class Widget { - constructor(name) { - this.render(); - this.name = name; - this.size = 3; - this.title = "widget"; - this.parts = ["a"]; - this.meta = { id: 1 }; - } - render() { - console.log("render", this.name, this.title, this.size, this.parts, this.meta, this.size + 1, `${this.name}!`); - } -} -class Big extends Widget { - constructor() { - super("big"); - this.extra = 2; - } - render() { - super.render(); - console.log("big", this.extra); - } -} -new Widget("w").render(); -new Big().render(); diff --git a/tests/corpus/5980-cycle-components.ts b/tests/corpus/5980-cycle-components.ts new file mode 100644 index 000000000..05e8ffed1 --- /dev/null +++ b/tests/corpus/5980-cycle-components.ts @@ -0,0 +1,101 @@ +// Collector passes whose candidates mix dead structures with live ones: the +// ring under construction when a pass runs, owners that keep an inner node +// of an otherwise dead ring, trees whose child arrays have holes and sparse +// slots, and a live structure too large for a pass to record. Each dead +// structure is reclaimed whole, and everything still reachable survives +// with its contents intact. The sanitized lane's RC audit fails if anything +// below leaks or is freed while reachable. + +class Node { + next: Node | null = null; + kids: (Node | undefined)[] = []; + owner: Node | null = null; + value: number; + constructor(value: number) { + this.value = value; + } +} + +function ring(size: number, base: number): Node { + const first = new Node(base); + let last = first; + for (let i = 1; i < size; i++) { + const node = new Node(base + i); + last.next = node; + last = node; + } + last.next = first; + return first; +} + +function tree(depth: number, owner: Node | null, value: number): Node { + const node = new Node(value); + node.owner = owner; + if (depth > 0) for (let i = 0; i < 3; i++) node.kids.push(tree(depth - 1, node, value * 3 + i)); + return node; +} + +function total(start: Node): number { + const seen = new Set(); + const stack: Node[] = [start]; + let sum = 0; + while (stack.length > 0) { + const node = stack.pop()!; + if (seen.has(node)) continue; + seen.add(node); + sum = (sum + node.value) % 1000003; + if (node.next) stack.push(node.next); + if (node.owner) stack.push(node.owner); + for (const kid of node.kids) if (kid) stack.push(kid); + } + return sum * 1000 + (seen.size % 1000); +} + +// Dead rings dropped while the next one is being built; a few are kept. +let rings = 0; +const kept: Node[] = []; +for (let round = 0; round < 3000; round++) { + const r = ring(5 + (round % 7), round); + rings = (rings + r.next!.value) % 1000003; + if (round % 500 === 0) kept.push(r); +} +console.log("rings", rings, kept.map(total).join(" ")); + +// Rings whose head is dropped while an owner keeps a node in the middle: +// the ring stays reachable through it and must survive whole. +const anchors: Node[] = []; +for (let round = 0; round < 400; round++) { + let mid = ring(30, round * 100); + for (let i = 0; i < 15; i++) mid = mid.next!; + if (round % 4 === 0) anchors.push(mid); +} +let anchored = 0; +for (const anchor of anchors) anchored = (anchored + total(anchor)) % 1000003; +console.log("anchored", anchors.length, anchored); + +// Trees with holes and sparse slots in their child arrays. +let trees = 0; +const shaped: Node[] = []; +for (let round = 0; round < 300; round++) { + const t = tree(4, null, round); + if (round % 3 === 0) t.kids.length = 6; + if (round % 5 === 0) t.kids[200] = tree(2, t, round + 7); + if (round % 7 === 0) t.kids[0]!.kids.length = 1; + trees = (trees + total(t)) % 1000003; + if (round % 60 === 0) shaped.push(t.kids[2]!); +} +console.log("trees", trees, shaped.map(total).join(" ")); + +// A live tree larger than one pass records, built and read while dead +// structures keep dying around it, then dropped. +const big = tree(10, null, 1); +let churn = 0; +for (let round = 0; round < 200; round++) { + const r = ring(50, round); + const branch = big.kids[round % 3]!.kids[(round >> 2) % 3]!; + branch.next = r; + churn = (churn + total(r)) % 1000003; + if (round % 50 === 0) churn = (churn + total(big)) % 1000003; + branch.next = null; +} +console.log("big", churn, total(big)); diff --git a/tests/corpus/5996-rejections-between-macrotasks.cjs b/tests/corpus/5996-rejections-between-macrotasks.cjs new file mode 100644 index 000000000..1afd8c8e8 --- /dev/null +++ b/tests/corpus/5996-rejections-between-macrotasks.cjs @@ -0,0 +1,33 @@ +'use strict'; +// Unhandled rejections are reported after the callback that left them, +// before the next due timer or the next immediate runs (Node's +// runNextTicks between macrotasks), also when several timers expire in +// the same turn. +process.on('unhandledRejection', (reason) => { + console.log('unhandledRejection', reason instanceof Error ? reason.message : JSON.stringify(reason)); +}); +process.on('uncaughtException', (err, origin) => console.log(origin, err)); + +const start = Date.now(); +setTimeout(() => void Promise.reject({ a: 1 }), 1); +setTimeout(() => void Promise.reject(new TypeError('typed reason')), 2); +setTimeout(() => { + throw 'thrown string'; +}, 3); +setTimeout(() => { + console.log('timer 4'); + Promise.reject('handled later').catch((e) => console.log('caught', e)); +}, 4); +setTimeout(() => console.log('timer 5'), 5); +// Every timer above is due once this returns. +while (Date.now() - start < 20) {} + +setTimeout(() => { + setImmediate(() => void Promise.reject('first immediate')); + setImmediate(() => { + console.log('second immediate'); + process.nextTick(() => console.log('tick')); + void Promise.reject('second immediate'); + }); + setImmediate(() => console.log('third immediate')); +}, 30); diff --git a/tests/corpus/js-builder-string-method-names/builder.js b/tests/corpus/js-builder-string-method-names/builder.js new file mode 100644 index 000000000..36824c317 --- /dev/null +++ b/tests/corpus/js-builder-string-method-names/builder.js @@ -0,0 +1,22 @@ +// Prototype getters named like String.prototype's HTML methods (bold, +// italics, link, big): each read builds a callable that wraps its input. +const wrap = (tag) => ({ + get() { + const parent = this; + const builder = (text) => builder.prefix(text); + builder.prefix = (text) => parent.prefix(`<${tag}>` + text + ``); + Object.setPrototypeOf(builder, proto); + return builder; + }, +}); +const proto = Object.defineProperties(() => {}, { + bold: wrap("b"), + italics: wrap("i"), + link: wrap("a"), + big: wrap("big"), + red: wrap("red"), +}); +const root = (text) => text; +root.prefix = (text) => text; +Object.setPrototypeOf(root, proto); +export default root; diff --git a/tests/corpus/js-builder-string-method-names/main.ts b/tests/corpus/js-builder-string-method-names/main.ts new file mode 100644 index 000000000..5cab8e4ca --- /dev/null +++ b/tests/corpus/js-builder-string-method-names/main.ts @@ -0,0 +1,14 @@ +// A TypeScript caller reaching JavaScript builders whose member names +// collide with String.prototype methods: the receiver is a function, so +// each call reads the function's inherited getter, not the string method. +import builder from "./builder.js"; + +// TypeScript infers no members for the builder's prototype getters. +const tags: any = builder; + +console.log(tags.bold("strong")); +console.log(tags.red.bold("nested")); +console.log(tags.italics.link("deep").length); +console.log(tags.big.red.italics("three")); +const chain = tags.link; +console.log(chain.bold("from a binding")); diff --git a/tests/corpus/js-callable-builder.js b/tests/corpus/js-callable-builder.js new file mode 100644 index 000000000..3697d788d --- /dev/null +++ b/tests/corpus/js-callable-builder.js @@ -0,0 +1,110 @@ +// A chalk-style builder: every style read through a function's runtime +// prototype chain runs a getter that creates a new callable builder, +// links it to a shared prototype with Object.setPrototypeOf, and caches +// it on the receiver with Object.defineProperty. +const GENERATOR = Symbol("GENERATOR"); +const STYLER = Symbol("STYLER"); +const IS_EMPTY = Symbol("IS_EMPTY"); +const codes = { red: [31, 39], green: [32, 39], bold: [1, 22], underline: [4, 24] }; +let getterRuns = 0; + +const styles = Object.create(null); +for (const [name, [open, close]] of Object.entries(codes)) { + styles[name] = { + get() { + getterRuns++; + const builder = createBuilder(this, createStyler(`<${open}>`, ``, this[STYLER]), this[IS_EMPTY]); + Object.defineProperty(this, name, { value: builder }); + return builder; + }, + }; +} +styles.visible = { + get() { + const builder = createBuilder(this, this[STYLER], true); + Object.defineProperty(this, "visible", { value: builder }); + return builder; + }, +}; + +const proto = Object.defineProperties(() => {}, { + ...styles, + level: { + enumerable: true, + get() { + return this[GENERATOR].level; + }, + set(level) { + this[GENERATOR].level = level; + }, + }, +}); + +function createStyler(open, close, parent) { + if (parent === undefined) return { open, close, openAll: open, closeAll: close, parent }; + return { open, close, openAll: parent.openAll + open, closeAll: close + parent.closeAll, parent }; +} + +function createBuilder(self, styler, isEmpty) { + const builder = (...args) => applyStyle(builder, args.length === 1 ? "" + args[0] : args.join(" ")); + Object.setPrototypeOf(builder, proto); + builder[GENERATOR] = self; + builder[STYLER] = styler; + builder[IS_EMPTY] = isEmpty; + return builder; +} + +function applyStyle(self, text) { + if (self.level <= 0 || !text) return self[IS_EMPTY] ? "" : text; + let styler = self[STYLER]; + if (styler === undefined) return text; + const { openAll, closeAll } = styler; + if (text.includes(" strings.join(" "); + chalk.level = options && options.level !== undefined ? options.level : 1; + Object.setPrototypeOf(chalk, createChalk.prototype); + return chalk; +} +Object.setPrototypeOf(createChalk.prototype, Function.prototype); +Object.defineProperties(createChalk.prototype, styles); + +const chalk = createChalk(); +console.log(chalk.red("x")); +console.log(chalk.red.bold("nested")); +console.log(chalk.green("a " + chalk.red("b") + " c")); +console.log(chalk.underline.green.bold("three", "args", 3)); +console.log(JSON.stringify(chalk.red("")), chalk.visible("v"), chalk.red.visible("rv")); +console.log(chalk("plain", "call"), typeof chalk, typeof chalk.red, typeof chalk.red.bold); +console.log(chalk.red === chalk.red, chalk.red.bold === chalk.red.bold, getterRuns); +console.log(Object.getPrototypeOf(chalk) === createChalk.prototype); +console.log(Object.getPrototypeOf(chalk.red) === proto, Object.getPrototypeOf(chalk.red.bold) === proto); +console.log(Object.getPrototypeOf(createChalk.prototype) === Function.prototype); +console.log(chalk.apply(null, ["via", "apply"])); +console.log(Object.keys(chalk).join(","), Object.hasOwn(chalk, "red"), "red" in chalk); + +const red = chalk.red; +chalk.level = 0; +console.log(red("off"), red.level, chalk.level, JSON.stringify(red.visible("hidden"))); +red.level = 2; +console.log(chalk.level, chalk.green.level, red("on")); +const quiet = createChalk({ level: 0 }); +console.log(quiet.red.bold("quiet"), quiet.level, chalk.level); diff --git a/tests/corpus/js-class-constructor-returns/factory.js b/tests/corpus/js-class-constructor-returns/factory.js new file mode 100644 index 000000000..9fe0b84c4 --- /dev/null +++ b/tests/corpus/js-class-constructor-returns/factory.js @@ -0,0 +1,35 @@ +// Classes whose constructor returns a value: `new` answers that value. +const make = (options = {}) => { + const fn = (...parts) => parts.join(options.separator ?? " "); + fn.level = options.level ?? 1; + return fn; +}; + +export class Joiner { + constructor(options) { + return make(options); + } +} + +export class Record { + constructor(name, size) { + const value = { name, size, kind: "record" }; + if (size > 10) return { ...value, large: true }; + return value; + } +} + +let constructed = 0; +export class Counted { + constructor() { + constructed++; + return { id: constructed }; + } +} + +const j = new Joiner({ separator: "-", level: 3 }); +console.log(typeof j, j("a", "b", "c"), j.level); +const plain = new Joiner(); +console.log(plain("x", "y"), plain.level); +console.log(JSON.stringify(new Record("box", 4)), JSON.stringify(new Record("crate", 40))); +console.log(new Counted().id, new Counted().id, constructed); diff --git a/tests/corpus/js-class-constructor-returns/main.ts b/tests/corpus/js-class-constructor-returns/main.ts new file mode 100644 index 000000000..800016329 --- /dev/null +++ b/tests/corpus/js-class-constructor-returns/main.ts @@ -0,0 +1,11 @@ +// The same classes constructed from TypeScript: the values come from the +// constructors' returns. +import { Counted, Joiner, Record } from "./factory.js"; + +// TypeScript types `new` by the class; the values are what the constructors return. +const joiner: any = new Joiner({ separator: "+" }); +console.log(joiner("1", "2")); +const record = new Record("tube", 11); +console.log(JSON.stringify(record)); +const counted: any = new Counted(); +console.log(counted.id); diff --git a/tests/corpus/js-function-prototype-value.js b/tests/corpus/js-function-prototype-value.js new file mode 100644 index 000000000..3efe4540e --- /dev/null +++ b/tests/corpus/js-function-prototype-value.js @@ -0,0 +1,17 @@ +// Function.prototype as a value: a callable answering undefined, with an +// empty name and length 0, usable as a prototype-chain link. +const fp = Function.prototype; +console.log(typeof fp, fp === Function.prototype, JSON.stringify(fp.name), fp.length); +console.log(fp(), fp(1, 2, 3)); + +function Base() {} +Object.setPrototypeOf(Base.prototype, Function.prototype); +console.log(Object.getPrototypeOf(Base.prototype) === Function.prototype); + +const callable = (...args) => args.length; +Object.setPrototypeOf(callable, Base.prototype); +console.log(callable(1, 2), Object.getPrototypeOf(callable) === Base.prototype); +console.log(callable.apply(null, [1, 2, 3]), callable.call(null, 1)); + +const plain = Object.setPrototypeOf({ own: 1 }, Function.prototype); +console.log(typeof plain, plain.own, Object.getPrototypeOf(plain) === Function.prototype); diff --git a/tests/corpus/js-number-parse-dynamic.js b/tests/corpus/js-number-parse-dynamic.js new file mode 100644 index 000000000..e4b050046 --- /dev/null +++ b/tests/corpus/js-number-parse-dynamic.js @@ -0,0 +1,8 @@ +// Number.parseInt / Number.parseFloat over checked-dynamic values apply +// the parsers' own ToString, as supports-color does with FORCE_COLOR. +const env = JSON.parse('{"FORCE_COLOR":"2","DEPTH":" 3.5px","EMPTY":"","HEX":"ff"}'); +console.log(Number.parseInt(env.FORCE_COLOR, 10), Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3)); +console.log(Number.parseInt(env.MISSING, 10), Number.parseInt(env.EMPTY, 10), Number.parseInt(env.HEX, 16)); +console.log(Number.parseFloat(env.DEPTH), Number.parseFloat(env.MISSING)); +const values = JSON.parse("[12, true, null]"); +console.log(Number.parseInt(values[0], 10), Number.parseInt(values[1], 36), Number.parseInt(values[2], 36)); diff --git a/tests/corpus/js-process-destructure.mjs b/tests/corpus/js-process-destructure.mjs new file mode 100644 index 000000000..81660e22c --- /dev/null +++ b/tests/corpus/js-process-destructure.mjs @@ -0,0 +1,12 @@ +// Data members of the process object taken off by destructuring. +import process from "node:process"; + +const { env, argv, platform } = process; +console.log(env.SCRIPTC_TEST_ENV, "SCRIPTC_TEST_ENV" in env, "SCRIPTC_NOT_SET_ANYWHERE" in env); +console.log(Array.isArray(argv), typeof argv[0], platform === process.platform); + +function readFlags() { + const { env: environment, pid } = process; + return [typeof environment.SCRIPTC_TEST_ENV, pid === process.pid]; +} +console.log(readFlags().join(" ")); diff --git a/tests/corpus/js-reshaped-object-literal.js b/tests/corpus/js-reshaped-object-literal.js new file mode 100644 index 000000000..c184cc388 --- /dev/null +++ b/tests/corpus/js-reshaped-object-literal.js @@ -0,0 +1,42 @@ +// An object literal the program reshapes at run time (runtime-keyed +// writes, defineProperty, delete): every read sees the live object, not +// the layout TypeScript inferred for the literal (ansi-styles' +// assembleStyles shape). +const styles = { + modifier: { reset: [0, 0], bold: [1, 22] }, + color: { red: [31, 39], green: [32, 39] }, +}; + +function assemble() { + const codes = new Map(); + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { open: `<${style[0]}>`, close: `` }; + group[styleName] = styles[styleName]; + codes.set(style[0], style[1]); + } + Object.defineProperty(styles, groupName, { value: group, enumerable: false }); + } + Object.defineProperty(styles, "codes", { value: codes, enumerable: false }); + styles.color.close = ""; + styles.color.ansi = (code) => `[${code}]`; + Object.defineProperties(styles, { + double: { value: (n) => n * 2, enumerable: false }, + }); + return styles; +} + +const ansi = assemble(); +console.log(Object.keys(ansi).join(",")); +console.log(ansi.red.open, ansi.color.red.close, ansi.color.close, ansi.color.ansi(5)); +console.log(ansi.codes.get(31), ansi.codes.size, ansi.double(21)); +console.log(ansi.modifier.bold === ansi.bold, Object.keys(ansi.color).join(",")); +for (const [name, style] of Object.entries(ansi)) console.log(name, style.open, style.close); + +const table = { a: 1, b: 2, c: 3 }; +const drop = (key) => { + delete table[key]; +}; +drop("b"); +table["d" + 1] = 4; +console.log(JSON.stringify(table), Object.keys(table).length, "b" in table); diff --git a/tests/corpus/truthy-object-logical.ts b/tests/corpus/truthy-object-logical.ts new file mode 100644 index 000000000..0b84b760b --- /dev/null +++ b/tests/corpus/truthy-object-logical.ts @@ -0,0 +1,31 @@ +// `&&` and `||` whose left operand is an object, array or function value: +// every object is truthy, so `o && x` evaluates `o` and answers `x`, and +// `o || x` answers `o` without evaluating `x`. +interface Stream { + isTTY: boolean; + columns: number; +} +let reads = 0; +const stream = (): Stream => { + reads++; + return { isTTY: reads % 2 === 1, columns: 80 }; +}; +function tty(s: Stream): boolean { + return s && s.isTTY; +} +console.log(tty({ isTTY: true, columns: 1 }), tty({ isTTY: false, columns: 2 })); +const width = stream() && stream().columns; +console.log(width, reads); +const list = [3, 1, 2]; +const first = list && list.length; +console.log(first); +const fn = (n: number): number => n * 2; +const doubled = fn && fn(21); +console.log(doubled); +let evaluated = false; +const fallback = (): Stream => { + evaluated = true; + return { isTTY: false, columns: 0 }; +}; +const chosen = stream() || fallback(); +console.log(chosen.columns, evaluated, reads); diff --git a/tests/fixtures/npm/cases/chalk5/main.ts b/tests/fixtures/npm/cases/chalk5/main.ts new file mode 100644 index 000000000..6a33a1466 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/main.ts @@ -0,0 +1,64 @@ +// chalk 5 (the real package, pinned in node_modules): the callable +// builder whose styles are prototype getters on a function chain, every +// color model, nested styles, chalk.level and new Chalk({ level }) at all +// four levels. chalk.test.ts runs the same program under FORCE_COLOR and +// the --color flags. +import chalk, { Chalk, chalkStderr, supportsColor, modifierNames, foregroundColorNames, backgroundColorNames, colorNames } from "chalk"; + +const show = (label: string, value: string): void => { + console.log(label + " " + JSON.stringify(value)); +}; + +console.log("default level " + String(chalk.level) + " stderr " + String(chalkStderr.level)); +console.log("supportsColor " + JSON.stringify(supportsColor)); +console.log(modifierNames.join(",")); +console.log(foregroundColorNames.length + " " + backgroundColorNames.length + " " + colorNames.length); + +show("red", chalk.red("red")); +show("red.bold", chalk.red.bold("bold red")); +show("nested", chalk.blue("a " + chalk.red("b") + " c")); +show("multi-arg", chalk.green("one", "two", 3)); +show("number", chalk.yellow(42 as unknown as string)); +show("empty", chalk.red("")); +show("newline", chalk.magenta.underline("line1\nline2\r\nline3")); +show("bg", chalk.bgCyan.black("bg")); +show("bright", chalk.redBright.bgBlueBright("bright")); +show("modifiers", chalk.italic.inverse.strikethrough.overline("mods")); +show("hidden-visible", chalk.hidden("h") + "|" + chalk.visible("v")); +show("rgb", chalk.rgb(10, 20, 30)("rgb")); +show("hex", chalk.hex("#ff8800").bold("hex")); +show("hex-short", chalk.bgHex("#0f0")("bg hex")); +show("ansi256", chalk.ansi256(201)("ansi256")); +show("bgAnsi256", chalk.bgAnsi256(17).white("bgAnsi256")); +show("callable", chalk("plain", "args")); +show("gray-grey", chalk.gray("x") + chalk.grey("y")); + +for (const level of [0, 1, 2, 3] as const) { + const c = new Chalk({ level }); + show(`L${level} red.bold`, c.red.bold("x")); + show(`L${level} hex`, c.hex("#123456")("x")); + show(`L${level} rgb`, c.rgb(255, 255, 255).bgRgb(0, 0, 0)("x")); + show(`L${level} ansi256`, c.ansi256(100).bgAnsi256(200)("x")); + show(`L${level} visible`, c.visible.red("v")); + show(`L${level} nested`, c.green("g" + c.yellow("y") + "g")); +} + +const mutable = new Chalk({ level: 3 }); +const red = mutable.red; +show("before", red("r")); +mutable.level = 0; +show("after level 0", red("r") + "|" + mutable.blue("b")); +console.log("level via builder " + String(red.level)); +red.level = 2; +console.log("shared level " + String(mutable.level)); +show("restored", mutable.cyan("c")); + +try { + new Chalk({ level: 5 as 0 }); +} catch (error) { + console.log("error " + (error as Error).message); +} + +chalk.level = 1; +show("global after set", chalk.red.bold("x")); +console.log("global level " + String(chalk.level)); diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/license b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/license new file mode 100644 index 000000000..fa7ceba3e --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json new file mode 100644 index 000000000..c9e0dc52b --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/package.json @@ -0,0 +1,83 @@ +{ + "name": "chalk", + "version": "5.6.2", + "description": "Terminal string styling done right", + "license": "MIT", + "repository": "chalk/chalk", + "funding": "https://github.com/chalk/chalk?sponsor=1", + "type": "module", + "main": "./source/index.js", + "exports": "./source/index.js", + "imports": { + "#ansi-styles": "./source/vendor/ansi-styles/index.js", + "#supports-color": { + "node": "./source/vendor/supports-color/index.js", + "default": "./source/vendor/supports-color/browser.js" + } + }, + "types": "./source/index.d.ts", + "sideEffects": false, + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "scripts": { + "test": "xo && c8 ava && tsd", + "bench": "matcha benchmark.js" + }, + "files": [ + "source", + "!source/index.test-d.ts" + ], + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "ansi", + "style", + "styles", + "tty", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "devDependencies": { + "@types/node": "^16.11.10", + "ava": "^3.15.0", + "c8": "^7.10.0", + "color-convert": "^2.0.1", + "execa": "^6.0.0", + "log-update": "^5.0.0", + "matcha": "^0.7.0", + "tsd": "^0.19.0", + "xo": "^0.57.0", + "yoctodelay": "^2.0.0" + }, + "xo": { + "rules": { + "unicorn/prefer-string-slice": "off", + "@typescript-eslint/consistent-type-imports": "off", + "@typescript-eslint/consistent-type-exports": "off", + "@typescript-eslint/consistent-type-definitions": "off", + "unicorn/expiring-todo-comments": "off" + } + }, + "c8": { + "reporter": [ + "text", + "lcov" + ], + "exclude": [ + "source/vendor" + ] + } +} diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts new file mode 100644 index 000000000..8295d9252 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.d.ts @@ -0,0 +1,325 @@ +// TODO: Make it this when TS suports that. +// import {ModifierName, ForegroundColor, BackgroundColor, ColorName} from '#ansi-styles'; +// import {ColorInfo, ColorSupportLevel} from '#supports-color'; +import { + ModifierName, + ForegroundColorName, + BackgroundColorName, + ColorName, +} from './vendor/ansi-styles/index.js'; +import {ColorInfo, ColorSupportLevel} from './vendor/supports-color/index.js'; + +export interface Options { + /** + Specify the color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + readonly level?: ColorSupportLevel; +} + +/** +Return a new Chalk instance. +*/ +export const Chalk: new (options?: Options) => ChalkInstance; // eslint-disable-line @typescript-eslint/naming-convention + +export interface ChalkInstance { + (...text: unknown[]): string; + + /** + The color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + level: ColorSupportLevel; + + /** + Use RGB values to set text color. + + @example + ``` + import chalk from 'chalk'; + + chalk.rgb(222, 173, 237); + ``` + */ + rgb: (red: number, green: number, blue: number) => this; + + /** + Use HEX value to set text color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk from 'chalk'; + + chalk.hex('#DEADED'); + ``` + */ + hex: (color: string) => this; + + /** + Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color. + + @example + ``` + import chalk from 'chalk'; + + chalk.ansi256(201); + ``` + */ + ansi256: (index: number) => this; + + /** + Use RGB values to set background color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgRgb(222, 173, 237); + ``` + */ + bgRgb: (red: number, green: number, blue: number) => this; + + /** + Use HEX value to set background color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgHex('#DEADED'); + ``` + */ + bgHex: (color: string) => this; + + /** + Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgAnsi256(201); + ``` + */ + bgAnsi256: (index: number) => this; + + /** + Modifier: Reset the current style. + */ + readonly reset: this; + + /** + Modifier: Make the text bold. + */ + readonly bold: this; + + /** + Modifier: Make the text have lower opacity. + */ + readonly dim: this; + + /** + Modifier: Make the text italic. *(Not widely supported)* + */ + readonly italic: this; + + /** + Modifier: Put a horizontal line below the text. *(Not widely supported)* + */ + readonly underline: this; + + /** + Modifier: Put a horizontal line above the text. *(Not widely supported)* + */ + readonly overline: this; + + /** + Modifier: Invert background and foreground colors. + */ + readonly inverse: this; + + /** + Modifier: Print the text but make it invisible. + */ + readonly hidden: this; + + /** + Modifier: Puts a horizontal line through the center of the text. *(Not widely supported)* + */ + readonly strikethrough: this; + + /** + Modifier: Print the text only when Chalk has a color level above zero. + + Can be useful for things that are purely cosmetic. + */ + readonly visible: this; + + readonly black: this; + readonly red: this; + readonly green: this; + readonly yellow: this; + readonly blue: this; + readonly magenta: this; + readonly cyan: this; + readonly white: this; + + /* + Alias for `blackBright`. + */ + readonly gray: this; + + /* + Alias for `blackBright`. + */ + readonly grey: this; + + readonly blackBright: this; + readonly redBright: this; + readonly greenBright: this; + readonly yellowBright: this; + readonly blueBright: this; + readonly magentaBright: this; + readonly cyanBright: this; + readonly whiteBright: this; + + readonly bgBlack: this; + readonly bgRed: this; + readonly bgGreen: this; + readonly bgYellow: this; + readonly bgBlue: this; + readonly bgMagenta: this; + readonly bgCyan: this; + readonly bgWhite: this; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGray: this; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGrey: this; + + readonly bgBlackBright: this; + readonly bgRedBright: this; + readonly bgGreenBright: this; + readonly bgYellowBright: this; + readonly bgBlueBright: this; + readonly bgMagentaBright: this; + readonly bgCyanBright: this; + readonly bgWhiteBright: this; +} + +/** +Main Chalk object that allows to chain styles together. + +Call the last one as a method with a string argument. + +Order doesn't matter, and later styles take precedent in case of a conflict. + +This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`. +*/ +declare const chalk: ChalkInstance; + +export const supportsColor: ColorInfo; + +export const chalkStderr: typeof chalk; +export const supportsColorStderr: typeof supportsColor; + +export { + ModifierName, ForegroundColorName, BackgroundColorName, ColorName, + modifierNames, foregroundColorNames, backgroundColorNames, colorNames, +// } from '#ansi-styles'; +} from './vendor/ansi-styles/index.js'; + +export { + ColorInfo, + ColorSupport, + ColorSupportLevel, +// } from '#supports-color'; +} from './vendor/supports-color/index.js'; + +// TODO: Remove these aliases in the next major version +/** +@deprecated Use `ModifierName` instead. + +Basic modifier names. +*/ +export type Modifiers = ModifierName; + +/** +@deprecated Use `ForegroundColorName` instead. + +Basic foreground color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ForegroundColor = ForegroundColorName; + +/** +@deprecated Use `BackgroundColorName` instead. + +Basic background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type BackgroundColor = BackgroundColorName; + +/** +@deprecated Use `ColorName` instead. + +Basic color names. The combination of foreground and background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type Color = ColorName; + +/** +@deprecated Use `modifierNames` instead. + +Basic modifier names. +*/ +export const modifiers: readonly Modifiers[]; + +/** +@deprecated Use `foregroundColorNames` instead. + +Basic foreground color names. +*/ +export const foregroundColors: readonly ForegroundColor[]; + +/** +@deprecated Use `backgroundColorNames` instead. + +Basic background color names. +*/ +export const backgroundColors: readonly BackgroundColor[]; + +/** +@deprecated Use `colorNames` instead. + +Basic color names. The combination of foreground and background color names. +*/ +export const colors: readonly Color[]; + +export default chalk; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js new file mode 100644 index 000000000..8bc993da5 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/index.js @@ -0,0 +1,225 @@ +import ansiStyles from '#ansi-styles'; +import supportsColor from '#supports-color'; +import { // eslint-disable-line import/order + stringReplaceAll, + stringEncaseCRLFWithFirstIndex, +} from './utilities.js'; + +const {stdout: stdoutColor, stderr: stderrColor} = supportsColor; + +const GENERATOR = Symbol('GENERATOR'); +const STYLER = Symbol('STYLER'); +const IS_EMPTY = Symbol('IS_EMPTY'); + +// `supportsColor.level` → `ansiStyles.color[name]` mapping +const levelMapping = [ + 'ansi', + 'ansi', + 'ansi256', + 'ansi16m', +]; + +const styles = Object.create(null); + +const applyOptions = (object, options = {}) => { + if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) { + throw new Error('The `level` option should be an integer from 0 to 3'); + } + + // Detect level if not set manually + const colorLevel = stdoutColor ? stdoutColor.level : 0; + object.level = options.level === undefined ? colorLevel : options.level; +}; + +export class Chalk { + constructor(options) { + // eslint-disable-next-line no-constructor-return + return chalkFactory(options); + } +} + +const chalkFactory = options => { + const chalk = (...strings) => strings.join(' '); + applyOptions(chalk, options); + + Object.setPrototypeOf(chalk, createChalk.prototype); + + return chalk; +}; + +function createChalk(options) { + return chalkFactory(options); +} + +Object.setPrototypeOf(createChalk.prototype, Function.prototype); + +for (const [styleName, style] of Object.entries(ansiStyles)) { + styles[styleName] = { + get() { + const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]); + Object.defineProperty(this, styleName, {value: builder}); + return builder; + }, + }; +} + +styles.visible = { + get() { + const builder = createBuilder(this, this[STYLER], true); + Object.defineProperty(this, 'visible', {value: builder}); + return builder; + }, +}; + +const getModelAnsi = (model, level, type, ...arguments_) => { + if (model === 'rgb') { + if (level === 'ansi16m') { + return ansiStyles[type].ansi16m(...arguments_); + } + + if (level === 'ansi256') { + return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_)); + } + + return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_)); + } + + if (model === 'hex') { + return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_)); + } + + return ansiStyles[type][model](...arguments_); +}; + +const usedModels = ['rgb', 'hex', 'ansi256']; + +for (const model of usedModels) { + styles[model] = { + get() { + const {level} = this; + return function (...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + }, + }; + + const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); + styles[bgModel] = { + get() { + const {level} = this; + return function (...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + }, + }; +} + +const proto = Object.defineProperties(() => {}, { + ...styles, + level: { + enumerable: true, + get() { + return this[GENERATOR].level; + }, + set(level) { + this[GENERATOR].level = level; + }, + }, +}); + +const createStyler = (open, close, parent) => { + let openAll; + let closeAll; + if (parent === undefined) { + openAll = open; + closeAll = close; + } else { + openAll = parent.openAll + open; + closeAll = close + parent.closeAll; + } + + return { + open, + close, + openAll, + closeAll, + parent, + }; +}; + +const createBuilder = (self, _styler, _isEmpty) => { + // Single argument is hot path, implicit coercion is faster than anything + // eslint-disable-next-line no-implicit-coercion + const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' ')); + + // We alter the prototype because we must return a function, but there is + // no way to create a function with a different prototype + Object.setPrototypeOf(builder, proto); + + builder[GENERATOR] = self; + builder[STYLER] = _styler; + builder[IS_EMPTY] = _isEmpty; + + return builder; +}; + +const applyStyle = (self, string) => { + if (self.level <= 0 || !string) { + return self[IS_EMPTY] ? '' : string; + } + + let styler = self[STYLER]; + + if (styler === undefined) { + return string; + } + + const {openAll, closeAll} = styler; + if (string.includes('\u001B')) { + while (styler !== undefined) { + // Replace any instances already present with a re-opening code + // otherwise only the part of the string until said closing code + // will be colored, and the rest will simply be 'plain'. + string = stringReplaceAll(string, styler.close, styler.open); + + styler = styler.parent; + } + } + + // We can move both next actions out of loop, because remaining actions in loop won't have + // any/visible effect on parts we add here. Close the styling before a linebreak and reopen + // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92 + const lfIndex = string.indexOf('\n'); + if (lfIndex !== -1) { + string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex); + } + + return openAll + string + closeAll; +}; + +Object.defineProperties(createChalk.prototype, styles); + +const chalk = createChalk(); +export const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0}); + +export { + modifierNames, + foregroundColorNames, + backgroundColorNames, + colorNames, + + // TODO: Remove these aliases in the next major version + modifierNames as modifiers, + foregroundColorNames as foregroundColors, + backgroundColorNames as backgroundColors, + colorNames as colors, +} from './vendor/ansi-styles/index.js'; + +export { + stdoutColor as supportsColor, + stderrColor as supportsColorStderr, +}; + +export default chalk; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js new file mode 100644 index 000000000..4366dee0d --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/utilities.js @@ -0,0 +1,33 @@ +// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`. +export function stringReplaceAll(string, substring, replacer) { + let index = string.indexOf(substring); + if (index === -1) { + return string; + } + + const substringLength = substring.length; + let endIndex = 0; + let returnValue = ''; + do { + returnValue += string.slice(endIndex, index) + substring + replacer; + endIndex = index + substringLength; + index = string.indexOf(substring, endIndex); + } while (index !== -1); + + returnValue += string.slice(endIndex); + return returnValue; +} + +export function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) { + let endIndex = 0; + let returnValue = ''; + do { + const gotCR = string[index - 1] === '\r'; + returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix; + endIndex = index + 1; + index = string.indexOf('\n', endIndex); + } while (index !== -1); + + returnValue += string.slice(endIndex); + return returnValue; +} diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts new file mode 100644 index 000000000..58f133abe --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.d.ts @@ -0,0 +1,236 @@ +export interface CSPair { // eslint-disable-line @typescript-eslint/naming-convention + /** + The ANSI terminal control sequence for starting this style. + */ + readonly open: string; + + /** + The ANSI terminal control sequence for ending this style. + */ + readonly close: string; +} + +export interface ColorBase { + /** + The ANSI terminal control sequence for ending this color. + */ + readonly close: string; + + ansi(code: number): string; + + ansi256(code: number): string; + + ansi16m(red: number, green: number, blue: number): string; +} + +export interface Modifier { + /** + Resets the current color chain. + */ + readonly reset: CSPair; + + /** + Make text bold. + */ + readonly bold: CSPair; + + /** + Emitting only a small amount of light. + */ + readonly dim: CSPair; + + /** + Make text italic. (Not widely supported) + */ + readonly italic: CSPair; + + /** + Make text underline. (Not widely supported) + */ + readonly underline: CSPair; + + /** + Make text overline. + + Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash. + */ + readonly overline: CSPair; + + /** + Inverse background and foreground colors. + */ + readonly inverse: CSPair; + + /** + Prints the text, but makes it invisible. + */ + readonly hidden: CSPair; + + /** + Puts a horizontal line through the center of the text. (Not widely supported) + */ + readonly strikethrough: CSPair; +} + +export interface ForegroundColor { + readonly black: CSPair; + readonly red: CSPair; + readonly green: CSPair; + readonly yellow: CSPair; + readonly blue: CSPair; + readonly cyan: CSPair; + readonly magenta: CSPair; + readonly white: CSPair; + + /** + Alias for `blackBright`. + */ + readonly gray: CSPair; + + /** + Alias for `blackBright`. + */ + readonly grey: CSPair; + + readonly blackBright: CSPair; + readonly redBright: CSPair; + readonly greenBright: CSPair; + readonly yellowBright: CSPair; + readonly blueBright: CSPair; + readonly cyanBright: CSPair; + readonly magentaBright: CSPair; + readonly whiteBright: CSPair; +} + +export interface BackgroundColor { + readonly bgBlack: CSPair; + readonly bgRed: CSPair; + readonly bgGreen: CSPair; + readonly bgYellow: CSPair; + readonly bgBlue: CSPair; + readonly bgCyan: CSPair; + readonly bgMagenta: CSPair; + readonly bgWhite: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGray: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGrey: CSPair; + + readonly bgBlackBright: CSPair; + readonly bgRedBright: CSPair; + readonly bgGreenBright: CSPair; + readonly bgYellowBright: CSPair; + readonly bgBlueBright: CSPair; + readonly bgCyanBright: CSPair; + readonly bgMagentaBright: CSPair; + readonly bgWhiteBright: CSPair; +} + +export interface ConvertColor { + /** + Convert from the RGB color space to the ANSI 256 color space. + + @param red - (`0...255`) + @param green - (`0...255`) + @param blue - (`0...255`) + */ + rgbToAnsi256(red: number, green: number, blue: number): number; + + /** + Convert from the RGB HEX color space to the RGB color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToRgb(hex: string): [red: number, green: number, blue: number]; + + /** + Convert from the RGB HEX color space to the ANSI 256 color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToAnsi256(hex: string): number; + + /** + Convert from the ANSI 256 color space to the ANSI 16 color space. + + @param code - A number representing the ANSI 256 color. + */ + ansi256ToAnsi(code: number): number; + + /** + Convert from the RGB color space to the ANSI 16 color space. + + @param red - (`0...255`) + @param green - (`0...255`) + @param blue - (`0...255`) + */ + rgbToAnsi(red: number, green: number, blue: number): number; + + /** + Convert from the RGB HEX color space to the ANSI 16 color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToAnsi(hex: string): number; +} + +/** +Basic modifier names. +*/ +export type ModifierName = keyof Modifier; + +/** +Basic foreground color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ForegroundColorName = keyof ForegroundColor; + +/** +Basic background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type BackgroundColorName = keyof BackgroundColor; + +/** +Basic color names. The combination of foreground and background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ColorName = ForegroundColorName | BackgroundColorName; + +/** +Basic modifier names. +*/ +export const modifierNames: readonly ModifierName[]; + +/** +Basic foreground color names. +*/ +export const foregroundColorNames: readonly ForegroundColorName[]; + +/** +Basic background color names. +*/ +export const backgroundColorNames: readonly BackgroundColorName[]; + +/* +Basic color names. The combination of foreground and background color names. +*/ +export const colorNames: readonly ColorName[]; + +declare const ansiStyles: { + readonly modifier: Modifier; + readonly color: ColorBase & ForegroundColor; + readonly bgColor: ColorBase & BackgroundColor; + readonly codes: ReadonlyMap; +} & ForegroundColor & BackgroundColor & Modifier & ConvertColor; + +export default ansiStyles; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js new file mode 100644 index 000000000..eaa7bed6c --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/ansi-styles/index.js @@ -0,0 +1,223 @@ +const ANSI_BACKGROUND_OFFSET = 10; + +const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`; + +const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`; + +const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`; + +const styles = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + overline: [53, 55], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29], + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + + // Bright color + blackBright: [90, 39], + gray: [90, 39], // Alias of `blackBright` + grey: [90, 39], // Alias of `blackBright` + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39], + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + + // Bright color + bgBlackBright: [100, 49], + bgGray: [100, 49], // Alias of `bgBlackBright` + bgGrey: [100, 49], // Alias of `bgBlackBright` + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49], + }, +}; + +export const modifierNames = Object.keys(styles.modifier); +export const foregroundColorNames = Object.keys(styles.color); +export const backgroundColorNames = Object.keys(styles.bgColor); +export const colorNames = [...foregroundColorNames, ...backgroundColorNames]; + +function assembleStyles() { + const codes = new Map(); + + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { + open: `\u001B[${style[0]}m`, + close: `\u001B[${style[1]}m`, + }; + + group[styleName] = styles[styleName]; + + codes.set(style[0], style[1]); + } + + Object.defineProperty(styles, groupName, { + value: group, + enumerable: false, + }); + } + + Object.defineProperty(styles, 'codes', { + value: codes, + enumerable: false, + }); + + styles.color.close = '\u001B[39m'; + styles.bgColor.close = '\u001B[49m'; + + styles.color.ansi = wrapAnsi16(); + styles.color.ansi256 = wrapAnsi256(); + styles.color.ansi16m = wrapAnsi16m(); + styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET); + + // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js + Object.defineProperties(styles, { + rgbToAnsi256: { + value(red, green, blue) { + // We use the extended greyscale palette here, with the exception of + // black and white. normal palette only has 4 greyscale shades. + if (red === green && green === blue) { + if (red < 8) { + return 16; + } + + if (red > 248) { + return 231; + } + + return Math.round(((red - 8) / 247) * 24) + 232; + } + + return 16 + + (36 * Math.round(red / 255 * 5)) + + (6 * Math.round(green / 255 * 5)) + + Math.round(blue / 255 * 5); + }, + enumerable: false, + }, + hexToRgb: { + value(hex) { + const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16)); + if (!matches) { + return [0, 0, 0]; + } + + let [colorString] = matches; + + if (colorString.length === 3) { + colorString = [...colorString].map(character => character + character).join(''); + } + + const integer = Number.parseInt(colorString, 16); + + return [ + /* eslint-disable no-bitwise */ + (integer >> 16) & 0xFF, + (integer >> 8) & 0xFF, + integer & 0xFF, + /* eslint-enable no-bitwise */ + ]; + }, + enumerable: false, + }, + hexToAnsi256: { + value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)), + enumerable: false, + }, + ansi256ToAnsi: { + value(code) { + if (code < 8) { + return 30 + code; + } + + if (code < 16) { + return 90 + (code - 8); + } + + let red; + let green; + let blue; + + if (code >= 232) { + red = (((code - 232) * 10) + 8) / 255; + green = red; + blue = red; + } else { + code -= 16; + + const remainder = code % 36; + + red = Math.floor(code / 36) / 5; + green = Math.floor(remainder / 6) / 5; + blue = (remainder % 6) / 5; + } + + const value = Math.max(red, green, blue) * 2; + + if (value === 0) { + return 30; + } + + // eslint-disable-next-line no-bitwise + let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red)); + + if (value === 2) { + result += 60; + } + + return result; + }, + enumerable: false, + }, + rgbToAnsi: { + value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), + enumerable: false, + }, + hexToAnsi: { + value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), + enumerable: false, + }, + }); + + return styles; +} + +const ansiStyles = assembleStyles(); + +export default ansiStyles; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts new file mode 100644 index 000000000..0e8a9ccb8 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.d.ts @@ -0,0 +1 @@ +export {default} from './index.js'; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js new file mode 100644 index 000000000..fbb6ce0fc --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/browser.js @@ -0,0 +1,34 @@ +/* eslint-env browser */ + +const level = (() => { + if (!('navigator' in globalThis)) { + return 0; + } + + if (globalThis.navigator.userAgentData) { + const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium'); + if (brand && brand.version > 93) { + return 3; + } + } + + if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) { + return 1; + } + + return 0; +})(); + +const colorSupport = level !== 0 && { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, +}; + +const supportsColor = { + stdout: colorSupport, + stderr: colorSupport, +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts new file mode 100644 index 000000000..db44a7851 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.d.ts @@ -0,0 +1,55 @@ +import type {WriteStream} from 'node:tty'; + +export type Options = { + /** + Whether `process.argv` should be sniffed for `--color` and `--no-color` flags. + + @default true + */ + readonly sniffFlags?: boolean; +}; + +/** +Levels: +- `0` - All colors disabled. +- `1` - Basic 16 colors support. +- `2` - ANSI 256 colors support. +- `3` - Truecolor 16 million colors support. +*/ +export type ColorSupportLevel = 0 | 1 | 2 | 3; + +/** +Detect whether the terminal supports color. +*/ +export type ColorSupport = { + /** + The color level. + */ + level: ColorSupportLevel; + + /** + Whether basic 16 colors are supported. + */ + hasBasic: boolean; + + /** + Whether ANSI 256 colors are supported. + */ + has256: boolean; + + /** + Whether Truecolor 16 million colors are supported. + */ + has16m: boolean; +}; + +export type ColorInfo = ColorSupport | false; + +export function createSupportsColor(stream?: WriteStream, options?: Options): ColorInfo; + +declare const supportsColor: { + stdout: ColorInfo; + stderr: ColorInfo; +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js new file mode 100644 index 000000000..265d7f858 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/node_modules/chalk/source/vendor/supports-color/index.js @@ -0,0 +1,190 @@ +import process from 'node:process'; +import os from 'node:os'; +import tty from 'node:tty'; + +// From: https://github.com/sindresorhus/has-flag/blob/main/index.js +/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) { +function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) { + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf('--'); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +} + +const {env} = process; + +let flagForceColor; +if ( + hasFlag('no-color') + || hasFlag('no-colors') + || hasFlag('color=false') + || hasFlag('color=never') +) { + flagForceColor = 0; +} else if ( + hasFlag('color') + || hasFlag('colors') + || hasFlag('color=true') + || hasFlag('color=always') +) { + flagForceColor = 1; +} + +function envForceColor() { + if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + return 1; + } + + if (env.FORCE_COLOR === 'false') { + return 0; + } + + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, + }; +} + +function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) { + flagForceColor = noFlagForceColor; + } + + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + + if (forceColor === 0) { + return 0; + } + + if (sniffFlags) { + if (hasFlag('color=16m') + || hasFlag('color=full') + || hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + } + + // Check for Azure DevOps pipelines. + // Has to be above the `!streamIsTTY` check. + if ('TF_BUILD' in env && 'AGENT_NAME' in env) { + return 1; + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 + && Number(osRelease[2]) >= 10_586 + ) { + return Number(osRelease[2]) >= 14_931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) { + return 3; + } + + if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if (env.TERM === 'xterm-kitty') { + return 3; + } + + if (env.TERM === 'xterm-ghostty') { + return 3; + } + + if (env.TERM === 'wezterm') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': { + return version >= 3 ? 3 : 2; + } + + case 'Apple_Terminal': { + return 2; + } + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +export function createSupportsColor(stream, options = {}) { + const level = _supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options, + }); + + return translateLevel(level); +} + +const supportsColor = { + stdout: createSupportsColor({isTTY: tty.isatty(1)}), + stderr: createSupportsColor({isTTY: tty.isatty(2)}), +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5/package.json b/tests/fixtures/npm/cases/chalk5/package.json new file mode 100644 index 000000000..3804daa8d --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5/package.json @@ -0,0 +1 @@ +{ "name": "chalk5-case", "private": true, "type": "module" } diff --git a/tests/harness/chalk.test.ts b/tests/harness/chalk.test.ts new file mode 100644 index 000000000..4d99bf3ee --- /dev/null +++ b/tests/harness/chalk.test.ts @@ -0,0 +1,97 @@ +/* chalk 5 compiled from its published JavaScript (tests/fixtures/npm/cases/ + * chalk5): the program runs under Node and as a native binary with each + * color-detection input supports-color reads — FORCE_COLOR values and the + * --color/--no-color flags — and stdout, stderr and the exit status must + * match byte for byte. npm.test.ts runs the same case once in the + * harness's own environment. */ +import { execFile } from "node:child_process"; +import { mkdirSync } from "node:fs"; +import { dirname, join } from "node:path"; +import { promisify } from "node:util"; +import { beforeAll, describe, expect, test } from "vitest"; +import { compile } from "@scriptc/compiler"; + +const execFileAsync = promisify(execFile); +const repoRoot = join(import.meta.dirname, "../.."); +const entry = join(repoRoot, "tests/fixtures/npm/cases/chalk5/main.ts"); +const outDir = join(repoRoot, "node_modules/.cache/scriptc-tests/chalk5"); +const sanitize = process.env["SCRIPTC_SAN"] === "1"; + +interface RunResult { + stdout: string; + stderr: string; + exitCode: number; +} + +async function run(cmd: string, args: string[], env: NodeJS.ProcessEnv): Promise { + try { + const pending = execFileAsync(cmd, args, { cwd: dirname(entry), env, encoding: "utf8" }); + pending.child.stdin?.end(); + const { stdout, stderr } = await pending; + return { stdout, stderr, exitCode: 0 }; + } catch (err) { + const e = err as { code?: unknown; stdout?: string; stderr?: string }; + if (typeof e.stdout !== "string" || typeof e.stderr !== "string") throw err; + return { + stdout: e.stdout, + stderr: e.stderr, + exitCode: typeof e.code === "number" ? e.code : -1, + }; + } +} + +/** The harness environment without the color inputs, plus `force`. */ +function colorEnv(force: string | undefined): NodeJS.ProcessEnv { + const env = { ...process.env }; + delete env["FORCE_COLOR"]; + delete env["NO_COLOR"]; + delete env["NODE_DISABLE_COLORS"]; + if (force !== undefined) env["FORCE_COLOR"] = force; + return env; +} + +const cases: { name: string; force: string | undefined; argv: string[] }[] = [ + { name: "FORCE_COLOR unset", force: undefined, argv: [] }, + ...["0", "1", "2", "3", "true", "false", ""].map((force) => ({ + name: `FORCE_COLOR=${JSON.stringify(force)}`, + force, + argv: [], + })), + ...[ + ["--no-color"], + ["--color"], + ["--color=256"], + ["--color=16m"], + ["--color", "--", "--no-color"], + ].map((argv) => ({ name: argv.join(" "), force: undefined, argv })), + { name: "FORCE_COLOR=3 --no-color", force: "3", argv: ["--no-color"] }, +]; + +let binary = ""; + +beforeAll(async () => { + mkdirSync(outDir, { recursive: true }); + const result = await compile(entry, { outPath: join(outDir, "program"), outDir, sanitize }); + if (!result.ok) + throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); + binary = result.binaryPath; +}, 300_000); + +describe("chalk 5 color detection matches Node", () => { + for (const c of cases) { + test( + c.name, + async () => { + const env = colorEnv(c.force); + const [node, native] = await Promise.all([ + run(process.execPath, [entry, ...c.argv], env), + run(binary, c.argv, env), + ]); + expect(native.stdout).toBe(node.stdout); + expect(native.stderr).toBe(node.stderr); + expect(native.exitCode).toBe(node.exitCode); + }, + 60_000, + ); + } +}); diff --git a/tests/harness/corpus-costs.json b/tests/harness/corpus-costs.json index 8ef52f39a..75e865681 100644 --- a/tests/harness/corpus-costs.json +++ b/tests/harness/corpus-costs.json @@ -1,1699 +1,1699 @@ { "note": "Milliseconds per corpus program on a GitHub-hosted ubuntu-24.04 runner: its differential plus llvm-differential case, per flavor (medians of green main runs). scripts/ci-corpus-costs.mjs refreshes it from CI logs.", "plain": { - "001-hello.ts": 4256, - "002-log-args.ts": 4431, - "100-number-format.ts": 4288, - "1000-json-stringify-basics.ts": 5132, - "1001-json-escapes-unicode.ts": 3267, - "1002-json-parse-cast.ts": 5058, - "1003-json-parse-unions.ts": 4949, - "1004-json-parse-errors.ts": 3893, - "1005-json-nested.ts": 4163, - "1006-json-fs-config.ts": 3643, - "1007-json-rc-stress.ts": 4310, - "1008-json-null-arms.ts": 3701, - "1009-json-optional-fields.ts": 5156, - "101-arithmetic.ts": 3674, - "1010-json-stringify-space.ts": 4817, - "1011-json-unknown-typeof.ts": 3898, - "102-comparisons.ts": 4171, - "1020-async-basics.ts": 2636, - "1021-async-ordering.ts": 3263, - "1022-async-exceptions.ts": 3483, - "1023-async-rc-stress.ts": 4371, - "1024-async-pending-exit.ts": 3071, - "1025-async-promise-capture.ts": 3271, - "1026-throw-promise.ts": 3956, - "1027-async-return-promise.ts": 2933, - "1028-async-return-record-literals.ts": 3384, - "1029-async-eager-chains.ts": 2879, - "103-ternary.ts": 2774, - "104-ternary-empty-arrays.ts": 3724, - "1050-comptime-tables.ts": 3691, - "1051-comptime-strings.ts": 2389, - "1052-comptime-records.ts": 3840, - "1053-comptime-json.ts": 4536, - "1054-comptime-modules/main.ts": 3656, - "110-number-radix.ts": 2382, - "111-record-entries.ts": 4655, - "1110-math-members.ts": 4248, - "1111-math-random.ts": 3457, - "1113-string-methods.ts": 3364, - "1114-string-unicode-island.ts": 3366, - "1115-parse-globals.ts": 2591, - "1116-island-static-mix.ts": 3058, - "1117-typeof-static-union.ts": 3667, - "1118-object-spread-conditional.ts": 3693, - "1119-switch-union.ts": 3739, - "112-class-descriptor-key.js": 3492, - "1121-infinity-number-tostring.ts": 3539, - "1122-any-captures.ts": 3596, - "1124-union-narrowed-retag.ts": 3745, - "113-promise-checked-exits.ts": 2180, - "114-live-record-delete.ts": 3506, - "115-array-compound.js": 2722, - "116-text-decoder-runtime.js": 3978, - "117-weak-cache-cycle.js": 2417, - "118-fs-stored-callbacks.cjs": 4105, - "119-native-patterns.js": 4047, - "1200-regex-test-basics.ts": 2828, - "1201-regex-replace.ts": 3118, - "1202-regex-substitutions.ts": 2460, - "1203-regex-split.ts": 3529, - "1204-regex-empty-unicode.ts": 2746, - "1205-regex-rc-stress.ts": 3472, - "1300-errors-basics.ts": 3642, - "1301-errors-subclass.ts": 3871, - "1302-errors-typed-catch.ts": 3598, - "1303-errors-rc-stress.ts": 2806, - "1304-errors-uncaught.ts": 2053, - "1305-errors-async-rejections.ts": 3710, - "1306-errors-runtime-instances.ts": 2540, - "1350-path-normalize-join.ts": 2427, - "1351-path-parts.ts": 2680, - "1352-path-resolve-relative.ts": 3325, - "1353-os-basics.ts": 3345, - "1354-builtin-bare-specifiers.ts": 3282, - "1355-url-parse.ts": 2902, - "1356-url-file-bridge.ts": 2530, - "1357-fsp-roundtrip.ts": 2551, - "1358-crypto-random.ts": 3328, - "1359-json-module/main.ts": 3223, - "1360-spawn-sync.ts": 3535, - "1361-spawn-events.ts": 2778, - "1362-spawn-timers.ts": 8421, - "1363-spawn-unhandled-error.ts": 2559, - "1364-union-truthiness.ts": 2999, - "1365-union-logical.ts": 3464, - "1366-union-equality.ts": 3482, - "1367-destructuring.ts": 3491, - "1368-constructor-functions.ts": 3392, - "1369-promise-union.ts": 3326, - "1370-spread.ts": 2384, - "1371-union-template-tostring.ts": 3754, - "1372-loose-null-tests.ts": 3218, - "1373-union-array-arms.ts": 4066, - "140-bitwise-operators.ts": 2496, - "1400-typedarray-basics.ts": 3520, - "1401-typedarray-slice-set.ts": 3865, - "1402-buffer-encodings.ts": 2493, - "1403-buffer-fs.ts": 2658, - "1404-zlib-crypto-bytes.ts": 2380, - "1405-bytes-unions-arrays.ts": 2532, - "1406-dataview-mp4.ts": 3915, - "1407-dataview-bounds.ts": 3752, - "1408-string-indexing.ts": 3470, - "1409-typedarray-integer-loops.ts": 2071, - "1420-number-statics.ts": 3136, - "1421-number-parse-strings.ts": 2476, - "1422-date-iso.ts": 2600, - "1423-text-codec.ts": 4597, - "1424-fs-options.ts": 3300, - "1425-stdin-tty.ts": 3063, - "1426-stdin-read.ts": 2925, - "1427-fromcharcode-lastindexof.ts": 3413, - "1428-settled-await-order.ts": 2724, - "1429-promise-catch-finally.ts": 2634, - "1430-promise-race.ts": 4554, - "1431-caught-tostring.ts": 2091, - "1432-destructured-params.ts": 3338, - "1433-filter-narrow.ts": 3904, - "1434-async-never.ts": 3174, - "1435-math-spread.ts": 3092, - "1436-default-undef-param.ts": 3956, - "1437-pad-default.ts": 3383, - "1438-promise-all.ts": 6011, - "1440-interval-basics.ts": 4575, - "1441-interval-clear-cross.ts": 6244, - "1442-interval-throw.ts": 3389, - "1443-signal-handlers.ts": 6258, - "1444-exit-listeners.ts": 3211, - "1445-exit-process-exit.ts": 3320, - "1446-exit-uncaught.ts": 2360, - "1447-stdin-closed-events.ts": 2750, - "1448-stream-columns.ts": 2209, - "1450-incdec-expression.ts": 3228, - "1451-instanceof-uint8array-unknown.ts": 2957, - "1452-return-through-finally.ts": 3660, - "1453-pmap-settled.ts": 3618, - "1454-nonnull-narrow-and-fcc-bytes.ts": 3317, - "1455-lambda-union-return-adoption.ts": 2774, - "1460-console-error-warn.ts": 3320, - "1461-process-pid-getuid-kill.ts": 3247, - "1462-exec-sync.ts": 3282, - "1463-timeout-unref.ts": 3251, - "1464-env-writes.ts": 2987, - "1465-env-value.ts": 3024, - "1466-child-containers.ts": 3422, - "1467-string-match.ts": 3346, - "1468-exec-path.ts": 2301, - "1469-remove-listener.ts": 3606, - "1470-child-lifecycle.ts": 3256, - "1471-child-unref.ts": 7451, - "1472-errno-code.ts": 3295, - "1473-promisify-execfile.ts": 2595, - "1474-string-decoder.ts": 3611, - "1475-readline-closed-stdin.ts": 3112, - "1476-assign-expression.ts": 3030, - "1477-in-expressions.ts": 2996, - "1478-promise-reject.ts": 3812, - "1479-destructuring-assign.ts": 3356, - "1480-os-network-interfaces.ts": 4196, - "1481-string-case-static.ts": 3245, - "1482-spawnsync-error.ts": 3565, - "1483-array-slice.ts": 3674, - "1520-fs-wider-surface.ts": 3471, - "1520-string-split-static.ts": 2773, - "1521-fs-lstat-lock.ts": 3726, - "1521-string-trim-pad-static.ts": 3379, - "1522-parseint-static.ts": 3352, - "1522-spawnsync-options.ts": 5275, - "1523-isnan-floor-static.ts": 3491, - "1523-spawn-options.ts": 3565, - "1524-atomics-sleep-static.ts": 3559, - "1524-catch-narrowing.ts": 3222, - "1525-child-exit-signal.ts": 3428, - "1525-unknown-typeof-validation.ts": 3170, - "1526-set-spread.ts": 3383, - "1527-logical-mixed-operands.ts": 3407, - "1528-delete-records-env.ts": 3353, - "1529-class-with-statics.ts": 2988, - "1530-array-push-variadic.ts": 3122, - "1530-spread-override-completion.ts": 2849, - "1531-delete-optional-fields.ts": 3199, - "1531-process-arch-versions.ts": 3354, - "1532-array-splice-shift.ts": 2767, - "1532-union-shared-field-read.ts": 3248, - "1533-bool-equality.ts": 3299, - "1533-path-platform-namespaces.ts": 3213, - "1534-crypto-hash-chain.ts": 3265, - "1534-union-as-arm-cast.ts": 2201, - "1535-spawn-fd-stdio.ts": 3518, - "1535-union-param-defaults.ts": 2934, - "1536-destructuring-defaults.ts": 3325, - "1536-string-array-sweep.ts": 3492, - "1537-chalk-hybrid/main.ts": 2721, - "1537-os-release-spawnsync-stdio.ts": 3013, - "1538-await-promiselike-return.ts": 3514, - "1538-math-static-scalar.ts": 2646, - "1539-readonly-set-map.ts": 2440, - "1539-unknown-truthiness.ts": 3020, - "1540-os-userinfo.ts": 2759, - "1540-void-statement.ts": 3146, - "1541-fs-readdir-dirent.ts": 3308, - "1541-union-keyed-reads.ts": 2673, - "1542-map-promise-values.ts": 3263, - "1542-record-literal-into-union.ts": 3421, - "1543-rest-destructuring.ts": 2387, - "1543-set-server-handles.ts": 3383, - "1544-dyn-json-reads.ts": 4211, - "1544-string-matchall.ts": 3589, - "1545-spread-order-and-optional.ts": 3635, - "1546-union-element-reads.ts": 3551, - "1547-computed-key-fold.ts": 3124, - "1548-boolean-condition-forms.ts": 3319, - "1549-array-isarray-unions.ts": 3931, - "1550-param-defaults-func-set.ts": 3236, - "1551-dyn-receiver-methods.ts": 4427, - "1552-exec-options-record.ts": 3644, - "1553-truthy-hof-predicates.ts": 3271, - "1554-caught-into-unknown.ts": 3523, - "1555-index-spread-into-declared.ts": 4108, - "1556-union-retag-width-arms.ts": 2796, - "1557-url-host.ts": 3260, - "1558-any-joins-and-dyn-validation.ts": 2875, - "1559-conditional-spread-index-merge.ts": 2528, - "1560-forof-homogeneous-tuples.ts": 2537, - "1561-forof-strings.ts": 2246, - "1561-promise-then.ts": 3068, - "1562-optional-chain-tails.ts": 2705, - "1562-spawn-conditional-spread.ts": 3287, - "1563-forof-iterator-projections.ts": 2707, - "1563-string-raw-fold.ts": 2255, - "1564-fs-watch.ts": 3802, - "1564-string-raw.ts": 2918, - "1565-spawn-pipe-streams.ts": 3630, - "1565-union-element-join.ts": 3683, - "1566-child-duck-interface.ts": 3169, - "1567-server-close-override.ts": 2292, - "1568-x509-fingerprint.ts": 3260, - "1569-fsp-mkdir-unlink-chmod.ts": 2151, - "1570-child-unref-kill-reffed.ts": 8153, - "1571-optional-call-tostring-tail.ts": 2977, - "1571-stdin-set-raw-mode-non-tty.ts": 2223, - "1572-promise-reject-all-tuple.ts": 3566, - "1572-x509-validity-date-gettime.ts": 2517, - "1573-promisify-execfile-env-spread.ts": 3520, - "1573-tdz-scalar-forward-capture.ts": 2526, - "1574-dyn-optional-method-number-keys.ts": 3924, - "1574-promise-all-tuple-literal.ts": 2676, - "1575-unknown-assert-into-record.ts": 3519, - "1576-width-coercions.ts": 2683, - "1577-url-hostname.ts": 2337, - "1578-exec-input-optional.ts": 3059, - "1579-matchall-index.ts": 2856, - "1580-exec-env-conditional-spread.ts": 2426, - "1581-declare-const-read.ts": 3033, - "1582-timer-sleep-resolve.ts": 3454, - "1583-loops-and-stream-captures.ts": 2185, - "1584-union-field-unassigned.ts": 2354, - "1585-union-field-conditional-ctor.ts": 2702, - "1586-derived-field-before-super-init.ts": 2376, - "1590-js-unannotated.js": 2299, - "1591-js-closures.js": 3459, - "1592-js-classes.js": 3000, - "1593-js-jsdoc-records.js": 2837, - "1594-js-async.js": 3183, - "1595-js-island-gap/main.js": 3402, - "1596-cjs-modules/main.js": 2196, - "1597-mjs-graph/main.mjs": 3071, - "1598-cjs-builtin-require/main.js": 2199, - "1599-js-uncaught-throw.js": 2702, - "1600-assert-passing.ts": 3435, - "1601-assert-fail-exit.ts": 2059, - "1602-assert-caught-error.ts": 3377, - "1603-assert-scalar-messages.ts": 3468, - "1604-assert-deep-structures.ts": 3981, - "1605-assert-import-forms.ts": 3304, - "1606-assert-strict-module.ts": 3605, - "1607-assert-throws-match.ts": 2614, - "1608-cjs-assert/main.js": 3331, - "1609-assert-async.ts": 3158, - "1610-path-win32-full.ts": 3354, - "1611-url-file-bridge-neutral.ts": 2896, - "1612-cjs-module-globals.cjs": 1926, - "1613-cjs-esm-proxy-named/main.mjs": 2400, - "1614-js-fence-dodges.cjs": 2746, - "1615-cjs-export-shapes/main.cjs": 3057, - "1616-cjs-esm-lexer-invisible/main.mjs": 2969, - "1617-cjs-esm-lexer-visible/main.mjs": 3072, - "1618-cjs-esm-poisoned-tail/main.mjs": 2562, - "1619-cjs-esm-reexport-invisible/main.mjs": 2897, - "1620-cjs-require-effects-order/main.js": 3000, - "1621-cjs-require-cache-hit/main.js": 2851, - "1622-cjs-require-conditional/main.js": 3013, - "1623-cjs-require-diamond/main.js": 2407, - "1624-cjs-require-dir-mid-file/main.js": 2600, - "1625-cjs-require-lazy-fn/main.js": 2150, - "1626-cjs-require-mjs/main.js": 2871, - "1627-mjs-import-cjs-requires/main.mjs": 1644, - "1628-checked-dynamic-builtin-args.cjs": 3084, - "1629-require-main-filename.cjs": 2697, - "1630-inspect-scalars.ts": 2908, - "1630-rmsync-retry-options.cjs": 2250, - "1631-inspect-arrays.ts": 3807, - "1632-inspect-records.ts": 3072, - "1633-inspect-map-set.ts": 3749, - "1634-inspect-classes.ts": 3647, - "1635-inspect-buffer.ts": 2966, - "1636-util-format.ts": 2790, - "1637-inspect-dyn.ts": 3304, - "1638-inspect-cjs.cjs": 2542, - "1639-versions-openssl-probe.ts": 2867, - "1640-fd-read-decode.ts": 2932, - "1641-string-search.ts": 2902, - "1642-object-fromentries-rows.ts": 3493, - "1643-metadata-dyn-return.cjs": 3745, - "1644-ee-basics.ts": 2848, - "1645-ee-extends.ts": 2459, - "1646-ee-once-remove.ts": 3027, - "1647-ee-meta-events.ts": 2585, - "1648-ee-error-event.ts": 2283, - "1649-ee-names-counts.ts": 2675, - "1650-ee-prepend.ts": 2768, - "1651-ee-max-listeners.ts": 2226, - "1652-ee-snapshot.ts": 2979, - "1653-ee-cjs.cjs": 2570, - "1654-ee-namespace.ts": 2090, - "1655-spawnsync-neutral.ts": 4974, - "1656-execsync-neutral.ts": 2907, - "1657-spawn-async-neutral.ts": 3429, - "1660-buffer-read-write-num.ts": 3576, - "1661-buffer-encodings-full.ts": 3754, - "1662-string-decoder-encodings.ts": 3115, - "1663-buffer-compare-search-fill.ts": 3954, - "1664-dyn-fn-boundary.cjs": 3077, - "1665-dyn-fn-mustcall/main.cjs": 2296, - "1666-dyn-fn-identity.ts": 1815, - "1667-dyn-fn-not-callable.cjs": 3076, - "1668-dyn-fn-throws.cjs": 2849, - "1669-symbol-identity.ts": 2663, - "1670-symbol-registry.ts": 2947, - "1671-symbol-typeof.ts": 3427, - "1672-symbol-containers.ts": 2913, - "1673-symbol-cjs.cjs": 2504, - "1674-symbol-inspect.ts": 2841, - "1676-func-array-surface.ts": 3070, - "1677-emitter-listeners.ts": 3184, - "1678-emitter-dyn-listeners.cjs": 4068, - "1679-console-dyn.js": 3572, - "1680-assert-bytes.ts": 2927, - "1681-assert-funcs.ts": 3461, - "1685-stream-readable-basics.ts": 3135, - "1686-stream-readable-paused.ts": 2443, - "1687-stream-readable-flow-control.ts": 3237, - "1688-stream-writable-basics.ts": 2329, - "1689-stream-writable-async-drain.ts": 2789, - "1690-stream-duplex.ts": 2966, - "1691-stream-transform.ts": 2618, - "1692-stream-pipe.ts": 1917, - "1693-stream-pipe-backpressure.ts": 2276, - "1694-stream-destroy.ts": 3398, - "1695-stream-props.ts": 3260, - "1696-stream-read-inside-read.ts": 2732, - "1697-stream-tick-vs-timer.ts": 2767, - "1698-stream-uncaught-error.ts": 2710, - "1699-stream-callback-shapes.ts": 5108, - "1700-mustcall-common/main.cjs": 2603, - "1701-mustcall-exit-report/main.cjs": 3638, - "1702-dyn-proto-dispatch.cjs": 3719, - "1703-arguments-rest-props.cjs": 3420, - "1710-cjs-export-class/main.js": 3197, - "1711-cjs-export-single-values/main.js": 1720, - "1712-field-incdec.ts": 2250, - "1713-js-dyn-fields.js": 2301, - "1720-assert-throws-shape.ts": 3820, - "1721-assert-throws-regex-class.ts": 3123, - "1722-assert-rejects.ts": 3400, - "1723-assert-does-not-reject.ts": 2181, - "1724-assert-iferror.ts": 2290, - "1725-assert-symbols.ts": 2728, - "1726-promise-with-resolvers.ts": 3835, - "1727-assert-throws-shape-exit.ts": 2906, - "1730-countdown-symbol-keys/main.js": 3476, - "1731-symbol-field-shapes.cjs": 2330, - "1732-symbol-field-cross-module/main.js": 2189, - "1740-stream-extends-readable.ts": 2897, - "1741-stream-extends-writable.ts": 2368, - "1742-stream-extends-duplex-transform.ts": 2283, - "1743-stream-extends-vt-dispatch.ts": 3339, - "1744-stream-set-encoding.ts": 3916, - "1745-stream-encoding-js.cjs": 2742, - "1746-stream-for-await.ts": 3433, - "1747-stream-for-await-js.cjs": 2649, - "1750-http-agent-options.ts": 3028, - "1751-options-record-stance.ts": 3136, - "1760-surplus-args-drop.cjs": 2857, - "1761-emitter-special-event-names.cjs": 2907, - "1770-assert-dyn-strict.ts": 2622, - "1771-assert-dyn-deep.ts": 3046, - "1772-assert-dyn-js.cjs": 2864, - "1773-assert-dyn-exit.ts": 3097, - "1780-http-res-surface.ts": 3598, - "1781-http-server-shapes.cjs": 3736, - "1790-computed-key-folds.ts": 2845, - "1791-searchparams-core.ts": 3126, - "1792-searchparams-encoding.ts": 2170, - "1793-searchparams-iteration.ts": 2956, - "1794-searchparams-url-live.ts": 2603, - "1795-dyn-handle-request.cjs": 2396, - "1796-dyn-handle-body.cjs": 3535, - "1797-dyn-handle-socket.cjs": 3460, - "1798-dyn-handle-typed-box.ts": 2566, - "1800-immediate-basics.ts": 2566, - "1801-immediate-handle.ts": 2028, - "1802-immediate-unref-exit.ts": 3806, - "1803-timeout-refresh.ts": 2342, - "1804-timers-module.ts": 2401, - "1805-timer-callback-args.ts": 2781, - "1806-timer-delay-trunc.ts": 2824, - "1810-stream-options-const-record.ts": 2399, - "1811-stream-option-value-callbacks.cjs": 2961, - "1812-stream-super-options-forwarding.cjs": 3737, - "1813-stream-finished.ts": 3060, - "1814-stream-pipeline.cjs": 3701, - "1815-stream-state-reads.cjs": 2427, - "1820-static-block-basics.ts": 2518, - "1821-static-block-order.ts": 1976, - "1822-static-block-js.js": 3002, - "1823-static-instance-method-names.ts": 2691, - "1824-for-of-destructuring-defaults.ts": 2461, - "1825-exhaustive-typeof-switch.ts": 2514, - "1826-settimeout-arguments-callback.js": 2251, - "1830-enum-numeric-basics.ts": 2064, - "1831-enum-string-const-reverse.ts": 2264, - "1832-enum-modules/main.ts": 1833, - "1835-var-basics.ts": 2710, - "1836-var-loop-capture.ts": 3374, - "1837-var-undefined-hoisting.ts": 2917, - "1838-var-modules/main.ts": 2984, - "1839-var-js/main.cjs": 2891, - "1840-jsdoc-import-type-only/main.js": 1993, - "1850-overload-basics.ts": 2300, - "1851-overload-return-narrowing.ts": 2471, - "1852-overload-class-members.ts": 3006, - "1853-overload-modules/main.ts": 2503, - "1854-ambient-declare-fn.ts": 2630, - "1855-ambient-declare-fn-uncaught.ts": 3114, - "1870-unit-type-values.ts": 3109, - "1871-empty-array-never.ts": 2887, - "1872-template-tostring-composite.ts": 3584, - "1880-json-declared-field-order.ts": 3331, - "1881-default-anon/main.ts": 2353, - "1882-default-cjs-interop/main.ts": 2739, - "1883-default-exports/main.ts": 2650, - "1890-ns-imports/main.ts": 2779, - "1891-ns-reexport/main.ts": 2711, - "1940-class-values-basics.ts": 2460, - "1941-class-values-registry.ts": 3025, - "1942-class-expressions.ts": 2872, - "1943-class-statics-expanded.ts": 2580, - "1944-class-values-modules/main.ts": 2749, - "1950-generic-fn-values.ts": 2970, - "1951-generic-classes-basics.ts": 2980, - "1952-generic-class-statics-values.ts": 3062, - "1953-generic-class-hierarchy.ts": 2835, - "1954-generic-modules/main.ts": 1880, - "1960-namespace-basics.ts": 2265, - "1961-namespace-nested.ts": 2468, - "1962-namespace-classes.ts": 2516, - "1963-namespace-aliases.ts": 2375, - "1964-namespace-type-only.ts": 2816, - "1965-namespace-ambient.ts": 2803, - "1966-namespace-modules/main.ts": 3021, - "1967-namespace-alias-typeonly.ts": 2847, - "1968-namespace-import-eq-snapshot.ts": 2494, - "1970-decorators-basics.ts": 2822, - "1971-decorators-rebinding.ts": 2744, - "1972-decorators-throwing.ts": 2170, - "1973-decorators-ambient.ts": 2056, - "1980-primitive-proto-statics.ts": 2953, - "1981-date-utc.ts": 3276, - "1982-freeze-resolve-passthrough.ts": 2464, - "1983-array-tuple-surfaces.ts": 2644, - "1990-labels-basics.ts": 2635, - "1991-for-in-loops.ts": 3295, - "1992-small-syntax.ts": 3144, - "200-strings.ts": 2045, - "2000-generic-methods-basic.ts": 2851, - "2001-generic-methods-generic-class.ts": 2303, - "2002-generic-methods-inheritance.ts": 2257, - "2003-generic-methods-object-literal.ts": 3223, - "2004-generic-methods-statics.ts": 2748, - "201-templates.ts": 2400, - "2010-generators-basics.ts": 2273, - "2011-generators-forof.ts": 2704, - "2012-generators-return-throw.ts": 3247, - "2013-generators-sent-values.ts": 2662, - "2014-generators-values.ts": 3279, - "2015-generators-yieldstar.ts": 2320, - "2016-generators-rc-stress.ts": 2649, - "2017-generators-async.ts": 1806, - "2018-generators-uncaught.ts": 2418, - "2019-generators-loops.ts": 2694, - "2020-generic-value-bindings.ts": 3269, - "2021-generic-value-binding-modules/main.ts": 2143, - "2022-width-index-capture.ts": 3286, - "2023-width-readonly.ts": 2938, - "2024-width-array-elems.ts": 3159, - "2025-width-union-compose.ts": 3090, - "2026-width-spread.ts": 2628, - "2030-width-nested.ts": 3229, - "2031-width-tuples.ts": 2339, - "2032-cjs-export-assigned-class-expression/main.cjs": 2543, - "2033-property-assigned-class-extends.cjs": 1959, - "2035-ternary-array-retag.cjs": 2840, - "2036-evolving-array-decl.cjs": 2905, - "2037-fn-decl-hoisting.cjs": 2710, - "2038-evolving-array-js.cjs": 2879, - "2040-any-bindings.ts": 1964, - "2040-mixin-heritage.ts": 3294, - "2041-any-params-returns.ts": 2494, - "2041-mixin-values.ts": 3171, - "2042-any-flow-loops.ts": 2765, - "2042-mixin-modules/main.ts": 2821, - "2043-any-dom-values.ts": 1989, - "2043-mixin-rc-stress.ts": 2763, - "2044-vtable-sibling-slots.ts": 3156, - "2045-objlit-accessors-basic.ts": 2839, - "2045-parameter-properties.ts": 2262, - "2046-abstract-classes.ts": 2943, - "2046-objlit-accessors-effects.ts": 3238, - "2047-objlit-accessors-shapes.ts": 2962, - "2047-optional-class-fields.ts": 2352, - "2050-dynamic-import-own-module/main.ts": 2258, - "2051-dynamic-import-then/main.ts": 2628, - "2052-dynamic-import-self.ts": 2111, - "2053-typeof-static-fold.ts": 2331, - "2054-destructuring-island-source.ts": 2721, - "2060-empty-tuple.ts": 2638, - "2070-computed-key-folds.ts": 2482, - "2071-integer-key-enumeration-order.ts": 1999, - "2072-expando-function-members.ts": 2249, - "2073-destructuring-assignment.ts": 3060, - "2074-island-destructuring.ts": 3490, - "2075-index-signature-runtime-keys.ts": 3003, - "2080-destructuring-defaults.ts": 2782, - "2081-destructuring-rest.ts": 2626, - "2082-destructuring-assignment.ts": 2395, - "2085-destructuring-heads-rest-params.ts": 3137, - "2087-destructuring-for-heads.ts": 1934, - "2090-index-signature-number-keys.ts": 3257, - "2091-index-signature-string-intersection.ts": 2929, - "2092-package-imports/main.ts": 2114, - "2093-timers-promises.ts": 2678, - "2094-diagnostics-channel.ts": 3068, - "2095-js-catch-unknown.js": 2369, - "2096-os-type.ts": 2451, - "2097-js-evolving-globals.js": 2097, - "210-string-methods.ts": 2359, - "2100-stream-default-hwm.ts": 3022, - "2101-dyn-param-defaults.ts": 3172, - "2102-empty-pattern-decls.ts": 2881, - "2105-computed-key-static-folds.ts": 2838, - "2106-comma-expressions.ts": 1834, - "211-string-unicode.ts": 2972, - "2110-top-object-types.ts": 2238, - "2111-json-stringify-unknown.ts": 3135, - "2112-array-at-findlast.ts": 3283, - "2113-string-index-methods.js": 2879, - "212-string-aliasing-append.ts": 2677, - "2120-package-self-import/main.ts": 2837, - "2121-esm-cycle-inert-backedge/main.ts": 2507, - "2123-ambient-import-crash/main.ts": 2934, - "2124-imports-field-wildcard/main.ts": 2541, - "2140-uri-component-codecs.ts": 2133, - "2160-dc-tracing-channel.cjs": 2230, - "2161-js-object-literal-identity.cjs": 2537, - "2162-js-dyn-destructure.cjs": 2853, - "2163-js-selfref-const.cjs": 2693, - "2164-js-then-dyn-handler.cjs": 3004, - "2165-js-throw-dyn.cjs": 2225, - "2166-cjs-getter-this/main.cjs": 2804, - "2170-island-array-exits.ts": 2101, - "2171-island-json-stringify.ts": 2821, - "2172-island-regexp-boundary.ts": 2351, - "2190-new-object-and-string-wrappers.ts": 1908, - "2191-uri-encoders.ts": 3002, - "2192-object-default-tostring.ts": 2457, - "2193-discarded-stdlib-reads.ts": 2611, - "2194-ambient-undef-chains.ts": 1952, - "2195-require-missing-package/main.mjs": 3141, - "2196-island-computed-key-chain.ts": 2827, - "2210-dyn-promise-crossing.cjs": 3139, - "2211-dc-trace-promise.cjs": 2409, - "2212-unhandled-rejection-listener.cjs": 3057, - "2213-async-local-storage.cjs": 3299, - "2214-dc-bind-store.cjs": 3410, - "2215-process-emit-warning-exit.cjs": 3115, - "2240-width-class-into-record.ts": 2461, - "2241-width-record-into-class.ts": 2711, - "2242-width-statics-into-record.ts": 2854, - "2243-width-assert-satisfies-shapes.ts": 2928, - "2250-tagged-templates.ts": 2744, - "2252-class-iterators.ts": 3258, - "2253-union-coercions.ts": 3096, - "2260-http2-constants.cjs": 2383, - "2280-builtin-namespace-destructure.cjs": 2801, - "2281-domexception-atob-btoa.cjs": 2886, - "2282-queue-microtask.cjs": 2614, - "2283-structured-clone.cjs": 3700, - "2284-regexp-constructor.cjs": 2429, - "2285-iferror-dyn.cjs": 2807, - "2286-dyn-object-walks.cjs": 2926, - "2300-dyn-record-spread-and-keyed-access.cjs": 2890, - "2301-cjs-export-table-dom-attach.cjs": 2512, - "2310-process-next-tick.ts": 3216, - "2311-next-tick-js-callbacks.js": 2966, - "2312-stream-underscore-assign.ts": 3290, - "2313-stream-underscore-assign-js.cjs": 2122, - "2314-process-introspection.ts": 2917, - "2320-await-unit.ts": 2292, - "2321-emitter-static-setmax.cjs": 2256, - "2322-dyn-array-sort.cjs": 2432, - "2323-timer-callback-returns.ts": 2842, - "2330-tls-server-runtime-options.cjs": 2815, - "2331-tls-server-options-typed.ts": 3087, - "2350-nan-global.ts": 3034, - "2351-async-methods.ts": 2783, - "2352-void-coercions.ts": 3060, - "2353-decorators-member-ambient.ts": 2052, - "2354-decorators-expression-ambient.ts": 1987, - "2360-tuple-to-array.ts": 3001, - "2361-assign-index-record.ts": 2918, - "2362-execsync-inherit.ts": 2884, - "2363-nullish-retag.ts": 3048, - "2364-in-runtime-key.ts": 2311, - "2365-dyn-into-island.ts": 2070, - "2366-string-well-formed.ts": 2331, - "2367-regexp-escape.ts": 3110, - "2368-set-methods.ts": 2456, - "2369-promise-try.ts": 2986, - "2370-group-by.ts": 3578, - "2371-iterator-helpers.ts": 4030, - "2380-buffer-module-named-import.ts": 2871, - "2381-builtin-default-imports.js": 2605, - "2382-cycle-two-decl/main.ts": 2659, - "2383-cycle-assertdoc/main.js": 2644, - "2384-cycle-mixed-bindings/main.ts": 2274, - "2385-builtin-reexport-facade/main.ts": 2047, - "2386-string-to-chars.ts": 2950, - "2387-tonumber-argv.ts": 2189, - "2388-tonumber-grammar-zoo.ts": 2227, - "2389-tonumber-unary-plus.ts": 2546, - "2390-dot-requires/main.cjs": 2258, - "2391-default-builtin-imports/main.ts": 3224, - "2392-block-guard-alias-scope.ts": 2115, - "2393-loop-exit-guard-narrow.ts": 2686, - "2394-loop-narrow-containment.ts": 2464, - "2395-while-cond-guard.ts": 2793, - "2396-born-narrowed-decl.ts": 2989, - "2397-branch-kill-merge.ts": 2557, - "2398-switch-arm-kill.ts": 2776, - "2399-reassign-kill-polarity.ts": 2005, - "240-stdout-write.ts": 2170, - "2400-kill-return-edge.ts": 2417, - "2401-kill-break-staging.ts": 2710, - "2402-labeled-break-kill.ts": 2048, - "2403-kill-continue-backedge.ts": 2629, - "2404-kill-throw-catch.ts": 1738, - "2405-sibling-arm-narrow.ts": 2542, - "2406-switch-clause-sibling-narrow.ts": 1729, - "2407-infinite-loop-seal.ts": 2732, - "2408-loop-terminality-reopen.ts": 2758, - "2409-loop-body-return-not-terminal.ts": 2649, - "2410-stacked-cases-terminality.ts": 2587, - "2411-exhaustive-switch-terminality.ts": 2117, - "2412-dowhile-guard-trailing-test.ts": 2829, - "2413-dowhile-kill-renarrow.ts": 2634, - "2414-dowhile-continue-kill.ts": 2056, - "2415-dowhile-break-trailing-test.ts": 2838, - "2416-spread-ternary-positions.ts": 2794, - "2417-ternary-local-inference.ts": 1836, - "2418-wrapped-ternary-arms.ts": 2376, - "2419-selector-ternary-union.ts": 1886, - "2420-nullish-null-identity.ts": 2382, - "2421-float-lane-inference.ts": 2567, - "2422-ieee-div-rem-corners.ts": 2214, - "2423-param-null-reassign.ts": 2589, - "2424-ternary-miss-first-narrowing.ts": 2704, - "2425-elseif-head-exit-narrow.ts": 2085, - "2426-default-snapshot-mutable/main.ts": 2501, - "2427-perf-hooks-now.ts": 2322, - "2428-field-redeclare-inherited.ts": 2811, - "2429-destructure-class-instance.ts": 2113, - "2430-empty-literal-unknown-field.js": 2775, - "2431-primitive-ctor-values.ts": 2709, - "2432-generic-member-fields-async.ts": 3359, - "2433-as-const-command-tables.ts": 3152, - "2434-deferred-init-fields.ts": 2675, - "2435-loose-same-kind-equality.ts": 2929, - "2440-console-inspect-args.ts": 3616, - "2441-console-process-argv.ts": 2729, - "2442-union-literal-arm-widening.ts": 2394, - "2443-union-literal-shadow-narrowing.ts": 2878, - "2444-union-literal-reducer-spread.ts": 2611, - "2445-math-minmax-nary.ts": 2928, - "2446-performance-global.ts": 1959, - "2447-island-boundary-slots/main.ts": 3526, - "2448-entries-null-arms-regex-arrays.ts": 3606, - "2450-private-instance-methods.ts": 3040, - "2451-private-fields.ts": 2458, - "2452-private-statics.ts": 2875, - "2453-private-accessors.ts": 2477, - "2454-private-generator-methods.ts": 3086, - "2455-private-brand-checks.ts": 2830, - "2456-private-async-methods.ts": 3027, - "2457-private-members.js": 2823, - "2460-qs-parse-grammar.ts": 2369, - "2461-qs-parse-options.ts": 2633, - "2462-qs-stringify.ts": 2904, - "2463-qs-escape-unescape.ts": 2627, - "2464-qs-require-forms.cjs": 2308, - "2470-mockable-module-shape.js": 3113, - "2471-record-keyed-write-hasown.js": 3326, - "2472-string-regexp-union.ts": 2731, - "2473-option-table-widths.js": 3152, - "2474-island-literal-forms.ts": 2479, - "2475-variadic-wrapper-island.js": 3198, - "2476-map-regex-values.ts": 2520, - "2480-recursive-record-tree.ts": 2079, - "2481-mutual-recursive-records.ts": 2753, - "2482-recursive-union-tree.ts": 2627, - "2483-recursive-record-cycles.ts": 3056, - "2484-json-stringify-circular.ts": 3122, - "2485-inspect-circular-refs.ts": 2852, - "2486-recursive-record-boundaries.ts": 3348, - "2487-recursive-deep-equal.ts": 2661, - "2488-ast-walker.ts": 3060, - "2490-find-miss-null-compare.ts": 1733, - "2491-strict-unit-compare-no-arm.ts": 2221, - "2492-loose-null-compare-unions.ts": 2888, - "2493-switch-unit-cases.ts": 2663, - "2494-no-arm-compare-effects.ts": 2604, - "2500-net-autosel-timeout.ts": 2518, - "2510-dyn-evolving-array-map.ts": 2547, - "2511-dyn-evolving-array-filter-foreach.ts": 2095, - "2512-dyn-evolving-array-mixed-push.ts": 1858, - "2520-private-statics-class-name-calls.ts": 2236, - "2521-private-statics-class-expression.ts": 2886, - "2522-private-statics-decorated.ts": 2242, - "2523-private-statics-aliased-class.ts": 2547, - "2530-object-destructuring-decl.ts": 2810, - "2531-array-tuple-destructuring-decl.ts": 2637, - "2532-param-destructuring-options.ts": 1880, - "2533-forof-destructuring.ts": 2933, - "2534-object-rest-decl.ts": 2924, - "2535-destructuring-assign-basics.ts": 2850, - "2536-destructuring-assign-nested.ts": 3192, - "2537-destructuring-assign-member-targets.ts": 2938, - "2538-destructuring-assign-class-source.ts": 2800, - "2539-class-instance-rest.ts": 3105, - "2540-accessor-destructuring-defaults.ts": 2832, - "2541-destructuring-eval-order.ts": 2813, - "2550-generics-keyof-pick.ts": 2927, - "2551-generics-value-aliases.ts": 2674, - "2552-generics-iface-methods.ts": 2402, - "2553-generics-signature-bindings.ts": 3014, - "2554-generics-frontier-mix.ts": 2966, - "2555-generics-keyof-writes.ts": 2779, - "2556-crypto-introspection.ts": 3064, - "2556-width-hybrid-shapes.ts": 1985, - "2557-tls-ca-store.ts": 3012, - "2557-width-field-lifts.ts": 3351, - "2558-index-signature-func-values.ts": 3392, - "2558-rejection-events.cjs": 2929, - "2559-index-signature-container-values.ts": 3437, - "2560-arraybuffer-dataview-set.ts": 3189, - "2561-object-is.ts": 2016, - "2562-intl-numberformat-en-us.ts": 2324, - "2563-stream-promises-pipeline.ts": 2778, - "2564-stream-promises-finished.ts": 2282, - "2565-stream-promises-js.cjs": 2174, - "2566-promise-reject-dyn-reason.js": 2837, - "2567-rest-spread-forward.js": 3053, - "2568-rest-spread-forward-dynamic.js": 3336, - "2569-upcast-identity.ts": 2549, - "2570-buffer-arg-validation.cjs": 3495, - "2571-searchparams-arg-validation.cjs": 3289, - "2572-readable-emitted-readable-flag.cjs": 2702, - "2573-fs-url-arg-ladders.cjs": 2908, - "2574-emitter-max-listeners-ladders.cjs": 2125, - "2575-string-destructuring-decl.ts": 3056, - "2576-string-destructuring-assign.ts": 2769, - "2577-builtin-global-destructuring.js": 2592, - "2578-jsval-into-unknown-rows.ts": 3507, - "2579-jsval-object-param-crossing.js": 2689, - "2580-jsval-routed-keyed-ops.js": 3049, - "2581-jsval-routed-calls.js": 2613, - "2582-jsval-object-statics.js": 3028, - "2582-jsval-routed-keyed-ops.js": 2927, - "2583-dyn-nullish-coalesce.js": 2319, - "2583-jsval-routed-calls.js": 3227, - "2584-jsval-object-statics.js": 2921, - "2584-union-dyn-collapse.ts": 2532, - "2585-dyn-nullish-coalesce.js": 3154, - "2585-unknown-array.ts": 3043, - "2586-object-assign-spread.js": 3635, - "2587-array-entries-forof.ts": 2696, - "2588-array-entries-chains.ts": 2632, - "2589-object-create-null.cjs": 3471, - "2590-object-create-dynamic.js": 2856, - "2591-ambient-generic-traps.ts": 2325, - "2592-ambient-trap-uncaught.ts": 2711, - "2593-generic-inert-bindings.ts": 2516, - "2594-nullish-generic-bindings.ts": 2446, - "2595-fs-arg-ladders.cjs": 3442, - "2596-net-arg-ladders.cjs": 3131, - "2597-dgram-send-ladders.cjs": 3331, - "2598-tls-arg-ladders.cjs": 3733, - "2599-stream-arg-ladders.cjs": 2976, - "2600-dyn-keyed-write-harness.js": 3406, - "2601-dyn-keyed-write-ops.js": 2727, - "2602-dyn-array-destructure.js": 2959, - "2603-island-keyed-write-dyn.js": 2708, - "2604-cycle-classes-mutual/main.ts": 2723, - "2605-cycle-three-module/main.ts": 1625, - "2606-dynamic-import-cycle/main.ts": 2126, - "2608-regex-named-groups.ts": 2860, - "2609-regex-named-replace.ts": 2148, - "2610-regex-named-matchall.ts": 2297, - "2611-regex-named-groups-js.cjs": 2862, - "2613-for-init-uninitialized-let.ts": 2631, - "2614-trap-binding-later-writes.ts": 2032, - "2615-nullish-field-record-binding.ts": 2520, - "2616-js-collect-probe-defers.js": 2218, - "2617-enum-static-field-import/main.ts": 2916, - "2618-ee-emit-override.ts": 2896, - "2619-ee-override-chain.ts": 2889, - "2620-ee-override-once-order.ts": 2166, - "2621-ee-override-error-throw.ts": 2609, - "2622-ee-override-filter.ts": 3169, - "2623-ee-job-queue.ts": 3061, - "2624-ee-override-js.cjs": 2641, - "2625-bytes-views.ts": 2414, - "2626-stream-event-names.ts": 3336, - "2627-stream-ticks-are-nextticks.ts": 2921, - "2628-stream-push-encodings.cjs": 2936, - "2629-stream-consumers.ts": 2548, - "2630-stream-consumers-errors.ts": 2549, - "2631-create-require/main.ts": 3179, - "2632-dyn-jsval-iterate.js": 2810, - "2633-island-promise-crossing.js": 3789, - "2634-stream-pipeline-arg-ladders.cjs": 3204, - "2635-trap-binding-unmappable-written.ts": 2573, - "2636-trap-binding-ambient-rooted-rewrite.ts": 2836, - "2637-create-require-bare/main.ts": 3077, - "2638-http-dyn-res-compat.cjs": 3513, - "2639-http-dyn-req-pause.cjs": 3242, - "2640-net-dyn-socket-compat.cjs": 3276, - "2641-http-agent-surface.cjs": 2546, - "2642-http-agent-maxsockets.cjs": 2399, - "2643-or-default-retag.ts": 2038, - "2644-http-client-url-argument.ts": 3141, - "2645-https-client-url-argument.ts": 3327, - "2646-top-level-await.ts": 1674, - "2647-top-level-await-modules/main.ts": 2735, - "2648-top-level-await-rejection.ts": 2839, - "2649-top-level-await-pending.ts": 2632, - "2650-top-level-await-self-import.ts": 2130, - "2651-top-level-await-pending-unhandled.ts": 2661, - "2652-top-level-await-dynamic/main.ts": 2738, - "2653-top-level-await-rejection-stops-loop.ts": 2112, - "2654-top-level-await-unrelated-rejection.ts": 2041, - "2655-top-level-await-cycle/main.ts": 1850, - "2656-top-level-await-cycle-order/main.ts": 2731, - "2657-top-level-await-cycle-dynamic/main.ts": 2538, - "2658-top-level-await-sync-completion/main.ts": 2977, - "2659-top-level-await-dynamic-cycle/main.ts": 2760, - "2660-top-level-await-cycle-rejection/main.ts": 2805, - "2661-top-level-await-dynamic-runtime-root/main.ts": 2535, - "2662-top-level-await-cycle-external-wait/main.ts": 2399, - "2663-top-level-await-dependency-errors/main.ts": 2147, - "2664-top-level-await-same-checkpoint-rejection.ts": 2912, - "2665-top-level-await-unhandled-listener-liveness.ts": 2595, - "2666-array-to-sorted.ts": 5539, - "2668-stored-number-array-iterator.ts": 3042, - "2669-array-copying-methods.ts": 2580, - "2670-uint8array-copy-iterate.ts": 3366, - "2671-array-copying-js.cjs": 2250, - "2672-http-request-response-callback.ts": 2816, - "2673-top-level-await-implicit-module.ts": 2785, - "2674-top-level-for-await-implicit-module.ts": 1961, - "2675-create-require-nested-esm.js": 2652, - "2675-process-self-reexec.ts": 2948, - "2676-indexed-read-strict-equality.ts": 2688, - "2676-record-clone-overrides.ts": 2029, - "2676-top-level-await-ambiguous/main.ts": 2537, - "2677-runtime-optional-closure.ts": 3484, - "2677-top-level-await-module-scope/main.ts": 2041, - "2678-date-instances.ts": 2275, - "2678-large-string-sparse-index.ts": 2301, - "2678-util-parseargs.ts": 5332, - "2679-util-parseargs-cjs.cjs": 2235, - "2680-util-parseargs-default.ts": 2688, - "2681-util-parseargs-dynamic.js": 3031, - "2682-fs-rename.ts": 3590, - "2683-filter-truthy-predicate.ts": 3261, - "2683-fs-rename-js.cjs": 2894, - "2684-filter-no-predicate-dyn.cjs": 2218, - "2684-fs-rename-abort.ts": 2755, - "2685-array-unshift-reverse.ts": 2996, - "2685-fs-write-sync.ts": 3069, - "2686-fs-file-handle.ts": 4210, - "2687-fsp-write-file-options.ts": 2069, - "2687-process-write-args.ts": 2527, - "2688-fs-stats-disk-fields.ts": 2259, - "2689-http-server-timeout-properties.ts": 2541, - "2690-https-server-timeout-option.ts": 1835, - "2691-retained-lowering-record-order.ts": 3261, - "2692-inline-record-assert-index.ts": 2994, - "2692-string-accumulation.ts": 2802, - "2693-math-constants.ts": 2159, - "2700-array-sort-complexity.ts": 3020, - "2700-http-static-trailers.ts": 2315, - "2700-wasi-core.ts": 2595, - "2701-array-sort-snapshot.ts": 2502, - "2701-http-static-trailer-wire.ts": 2176, - "2701-import-meta/main.mjs": 3392, - "2702-http-static-trailer-end.ts": 2071, - "2702-type-import-link-static/main.ts": 2443, - "2702-uint8array-to-sorted.ts": 2965, - "2703-array-sparse-sort.ts": 3909, - "2703-type-import-link-static-reexport/main.ts": 2704, - "2704-array-sparse-to-sorted.ts": 3697, - "2704-type-import-link-static-success/main.ts": 2487, - "2705-array-sparse-sort-append.ts": 4843, - "2705-type-import-link-dynamic/main.ts": 2701, - "2706-array-search-missing-needle.ts": 2539, - "2706-type-import-link-dynamic-success/main.ts": 2462, - "2707-array-search-huge-sparse.ts": 45317, - "2707-type-import-link-static-default-reexport/main.ts": 2670, - "2708-type-import-link-dynamic/main.ts": 2350, - "2720-array-read-parity.ts": 1959, - "2721-array-nested-missing-receiver.ts": 2561, - "2750-array-sparse-foundation.ts": 2117, - "2751-buffer-concat-sparse-list.ts": 1676, - "2752-array-optional-stores.ts": 2649, - "2753-array-optional-method-values.ts": 2199, - "2754-array-property-undefined.ts": 2439, - "2755-array-optional-literal-forwarding.ts": 2745, - "2780-array-parity-composition.ts": 7200, - "2781-array-missing-value-escape.ts": 2902, - "2782-array-sparse-callbacks.ts": 3115, - "2783-array-defaults-rest.ts": 2837, - "2784-array-reduce-missing-result.ts": 2800, - "2785-array-missing-destructuring.ts": 3065, - "2786-array-sparse-serialization.ts": 2409, - "2787-array-missing-string-arithmetic.ts": 2854, - "2788-array-missing-builtin-conversions.ts": 2132, - "2789-array-missing-optional-tostring.ts": 1804, - "2790-dynamic-import-self-name/main.ts": 2534, - "2791-record-optional-keys.ts": 2401, - "2792-record-optional-spread-entries.ts": 2956, - "2793-union-conversion-identity-capture.ts": 3189, - "2794-array-generic-callback-values.ts": 2738, - "2795-array-optional-typedarray-source.ts": 3311, - "2796-array-sparse-class-value-instanceof.ts": 2925, - "2800-array-expression-consumers.ts": 2649, - "2801-array-switch-consumers.ts": 2865, - "2820-array-missing-method-receivers.ts": 1887, - "2821-array-optional-numeric-comparisons.ts": 2197, - "2830-cjs-require-self-name/main.cjs": 2632, - "2840-finally-completions.ts": 3271, - "2841-using-sync.ts": 2134, - "2842-await-using.ts": 1855, - "2843-using-suppressed-error.ts": 1631, - "2844-node-disposable-resources.ts": 2377, - "2845-for-using-of.ts": 2775, - "2846-generator-using.ts": 2854, - "2850-async-generators-protocol.ts": 2671, - "2851-async-generators-values.ts": 2378, - "2852-timers-promises-interval.ts": 2688, - "2854-leading-bom-literals.ts": 2637, - "2855-searchparams-sort-complexity.ts": 1784, - "2856-dynamic-any-local-operators.ts": 2953, - "2857-branded-primitives.ts": 2640, - "2858-import-meta-resolve/main.mjs": 2725, - "2859-import-meta-resolve-dynamic/main.mjs": 1820, + "001-hello.ts": 3069, + "002-log-args.ts": 2728, + "100-number-format.ts": 3733, + "1000-json-stringify-basics.ts": 4746, + "1001-json-escapes-unicode.ts": 3114, + "1002-json-parse-cast.ts": 4816, + "1003-json-parse-unions.ts": 3373, + "1004-json-parse-errors.ts": 2257, + "1005-json-nested.ts": 3430, + "1006-json-fs-config.ts": 3508, + "1007-json-rc-stress.ts": 4738, + "1008-json-null-arms.ts": 3237, + "1009-json-optional-fields.ts": 3598, + "101-arithmetic.ts": 2904, + "1010-json-stringify-space.ts": 4663, + "1011-json-unknown-typeof.ts": 2914, + "102-comparisons.ts": 2408, + "1020-async-basics.ts": 2514, + "1021-async-ordering.ts": 2150, + "1022-async-exceptions.ts": 2155, + "1023-async-rc-stress.ts": 3249, + "1024-async-pending-exit.ts": 3248, + "1025-async-promise-capture.ts": 4134, + "1026-throw-promise.ts": 2862, + "1027-async-return-promise.ts": 3195, + "1028-async-return-record-literals.ts": 2979, + "1029-async-eager-chains.ts": 3200, + "103-ternary.ts": 2586, + "104-ternary-empty-arrays.ts": 3925, + "1050-comptime-tables.ts": 3449, + "1051-comptime-strings.ts": 4033, + "1052-comptime-records.ts": 4539, + "1053-comptime-json.ts": 2953, + "1054-comptime-modules/main.ts": 2477, + "110-number-radix.ts": 2253, + "111-record-entries.ts": 4124, + "1110-math-members.ts": 3859, + "1111-math-random.ts": 2956, + "1113-string-methods.ts": 3292, + "1114-string-unicode-island.ts": 2830, + "1115-parse-globals.ts": 2990, + "1116-island-static-mix.ts": 3032, + "1117-typeof-static-union.ts": 2965, + "1118-object-spread-conditional.ts": 2667, + "1119-switch-union.ts": 3067, + "112-class-descriptor-key.js": 2522, + "1121-infinity-number-tostring.ts": 3370, + "1122-any-captures.ts": 3176, + "1124-union-narrowed-retag.ts": 2492, + "113-promise-checked-exits.ts": 2859, + "114-live-record-delete.ts": 2500, + "115-array-compound.js": 3135, + "116-text-decoder-runtime.js": 2862, + "117-weak-cache-cycle.js": 2266, + "118-fs-stored-callbacks.cjs": 3485, + "119-native-patterns.js": 3500, + "1200-regex-test-basics.ts": 3223, + "1201-regex-replace.ts": 3086, + "1202-regex-substitutions.ts": 3684, + "1203-regex-split.ts": 3320, + "1204-regex-empty-unicode.ts": 2968, + "1205-regex-rc-stress.ts": 2448, + "1300-errors-basics.ts": 2709, + "1301-errors-subclass.ts": 3447, + "1302-errors-typed-catch.ts": 3128, + "1303-errors-rc-stress.ts": 2776, + "1304-errors-uncaught.ts": 2907, + "1305-errors-async-rejections.ts": 2863, + "1306-errors-runtime-instances.ts": 2803, + "1350-path-normalize-join.ts": 2394, + "1351-path-parts.ts": 2228, + "1352-path-resolve-relative.ts": 3019, + "1353-os-basics.ts": 2682, + "1354-builtin-bare-specifiers.ts": 2284, + "1355-url-parse.ts": 2467, + "1356-url-file-bridge.ts": 3063, + "1357-fsp-roundtrip.ts": 3440, + "1358-crypto-random.ts": 2124, + "1359-json-module/main.ts": 2889, + "1360-spawn-sync.ts": 3158, + "1361-spawn-events.ts": 3000, + "1362-spawn-timers.ts": 8505, + "1363-spawn-unhandled-error.ts": 2724, + "1364-union-truthiness.ts": 2131, + "1365-union-logical.ts": 2948, + "1366-union-equality.ts": 2233, + "1367-destructuring.ts": 3492, + "1368-constructor-functions.ts": 2941, + "1369-promise-union.ts": 2048, + "1370-spread.ts": 2658, + "1371-union-template-tostring.ts": 2681, + "1372-loose-null-tests.ts": 2819, + "1373-union-array-arms.ts": 2414, + "140-bitwise-operators.ts": 3378, + "1400-typedarray-basics.ts": 3056, + "1401-typedarray-slice-set.ts": 2697, + "1402-buffer-encodings.ts": 3146, + "1403-buffer-fs.ts": 3327, + "1404-zlib-crypto-bytes.ts": 3318, + "1405-bytes-unions-arrays.ts": 2463, + "1406-dataview-mp4.ts": 2536, + "1407-dataview-bounds.ts": 3301, + "1408-string-indexing.ts": 2027, + "1409-typedarray-integer-loops.ts": 2940, + "1420-number-statics.ts": 2894, + "1421-number-parse-strings.ts": 2645, + "1422-date-iso.ts": 2686, + "1423-text-codec.ts": 4188, + "1424-fs-options.ts": 2662, + "1425-stdin-tty.ts": 2638, + "1426-stdin-read.ts": 2379, + "1427-fromcharcode-lastindexof.ts": 2109, + "1428-settled-await-order.ts": 2663, + "1429-promise-catch-finally.ts": 3486, + "1430-promise-race.ts": 4032, + "1431-caught-tostring.ts": 2082, + "1432-destructured-params.ts": 3251, + "1433-filter-narrow.ts": 3353, + "1434-async-never.ts": 2711, + "1435-math-spread.ts": 2665, + "1436-default-undef-param.ts": 2896, + "1437-pad-default.ts": 3003, + "1438-promise-all.ts": 6347, + "1440-interval-basics.ts": 3004, + "1441-interval-clear-cross.ts": 5524, + "1442-interval-throw.ts": 3148, + "1443-signal-handlers.ts": 5739, + "1444-exit-listeners.ts": 3270, + "1445-exit-process-exit.ts": 2515, + "1446-exit-uncaught.ts": 2709, + "1447-stdin-closed-events.ts": 2034, + "1448-stream-columns.ts": 2668, + "1450-incdec-expression.ts": 3189, + "1451-instanceof-uint8array-unknown.ts": 3003, + "1452-return-through-finally.ts": 2097, + "1453-pmap-settled.ts": 3863, + "1454-nonnull-narrow-and-fcc-bytes.ts": 2192, + "1455-lambda-union-return-adoption.ts": 3144, + "1460-console-error-warn.ts": 2229, + "1461-process-pid-getuid-kill.ts": 2853, + "1462-exec-sync.ts": 3145, + "1463-timeout-unref.ts": 2935, + "1464-env-writes.ts": 2594, + "1465-env-value.ts": 3233, + "1466-child-containers.ts": 2674, + "1467-string-match.ts": 2677, + "1468-exec-path.ts": 2974, + "1469-remove-listener.ts": 4038, + "1470-child-lifecycle.ts": 1948, + "1471-child-unref.ts": 6913, + "1472-errno-code.ts": 2768, + "1473-promisify-execfile.ts": 3155, + "1474-string-decoder.ts": 3057, + "1475-readline-closed-stdin.ts": 2826, + "1476-assign-expression.ts": 2557, + "1477-in-expressions.ts": 2740, + "1478-promise-reject.ts": 3143, + "1479-destructuring-assign.ts": 2933, + "1480-os-network-interfaces.ts": 3749, + "1481-string-case-static.ts": 1949, + "1482-spawnsync-error.ts": 2332, + "1483-array-slice.ts": 3329, + "1520-fs-wider-surface.ts": 3206, + "1520-string-split-static.ts": 2787, + "1521-fs-lstat-lock.ts": 2868, + "1521-string-trim-pad-static.ts": 2727, + "1522-parseint-static.ts": 2059, + "1522-spawnsync-options.ts": 3990, + "1523-isnan-floor-static.ts": 2552, + "1523-spawn-options.ts": 2955, + "1524-atomics-sleep-static.ts": 3221, + "1524-catch-narrowing.ts": 2221, + "1525-child-exit-signal.ts": 2022, + "1525-unknown-typeof-validation.ts": 2311, + "1526-set-spread.ts": 3277, + "1527-logical-mixed-operands.ts": 2920, + "1528-delete-records-env.ts": 3318, + "1529-class-with-statics.ts": 2626, + "1530-array-push-variadic.ts": 2272, + "1530-spread-override-completion.ts": 2333, + "1531-delete-optional-fields.ts": 2822, + "1531-process-arch-versions.ts": 2409, + "1532-array-splice-shift.ts": 2440, + "1532-union-shared-field-read.ts": 2449, + "1533-bool-equality.ts": 3130, + "1533-path-platform-namespaces.ts": 2472, + "1534-crypto-hash-chain.ts": 3303, + "1534-union-as-arm-cast.ts": 2773, + "1535-spawn-fd-stdio.ts": 3617, + "1535-union-param-defaults.ts": 2848, + "1536-destructuring-defaults.ts": 2783, + "1536-string-array-sweep.ts": 2930, + "1537-chalk-hybrid/main.ts": 3161, + "1537-os-release-spawnsync-stdio.ts": 2411, + "1538-await-promiselike-return.ts": 2433, + "1538-math-static-scalar.ts": 2674, + "1539-readonly-set-map.ts": 2573, + "1539-unknown-truthiness.ts": 2629, + "1540-os-userinfo.ts": 2636, + "1540-void-statement.ts": 2658, + "1541-fs-readdir-dirent.ts": 3093, + "1541-union-keyed-reads.ts": 4144, + "1542-map-promise-values.ts": 2657, + "1542-record-literal-into-union.ts": 3004, + "1543-rest-destructuring.ts": 2897, + "1543-set-server-handles.ts": 2927, + "1544-dyn-json-reads.ts": 3602, + "1544-string-matchall.ts": 2940, + "1545-spread-order-and-optional.ts": 2963, + "1546-union-element-reads.ts": 2716, + "1547-computed-key-fold.ts": 4334, + "1548-boolean-condition-forms.ts": 4675, + "1549-array-isarray-unions.ts": 3420, + "1550-param-defaults-func-set.ts": 3314, + "1551-dyn-receiver-methods.ts": 4271, + "1552-exec-options-record.ts": 3353, + "1553-truthy-hof-predicates.ts": 2475, + "1554-caught-into-unknown.ts": 2996, + "1555-index-spread-into-declared.ts": 3100, + "1556-union-retag-width-arms.ts": 2198, + "1557-url-host.ts": 2745, + "1558-any-joins-and-dyn-validation.ts": 2600, + "1559-conditional-spread-index-merge.ts": 3037, + "1560-forof-homogeneous-tuples.ts": 2478, + "1561-forof-strings.ts": 2503, + "1561-promise-then.ts": 3156, + "1562-optional-chain-tails.ts": 3390, + "1562-spawn-conditional-spread.ts": 3006, + "1563-forof-iterator-projections.ts": 3054, + "1563-string-raw-fold.ts": 2666, + "1564-fs-watch.ts": 3415, + "1564-string-raw.ts": 2651, + "1565-spawn-pipe-streams.ts": 3154, + "1565-union-element-join.ts": 2733, + "1566-child-duck-interface.ts": 2463, + "1567-server-close-override.ts": 2863, + "1568-x509-fingerprint.ts": 2419, + "1569-fsp-mkdir-unlink-chmod.ts": 2704, + "1570-child-unref-kill-reffed.ts": 8818, + "1571-optional-call-tostring-tail.ts": 4280, + "1571-stdin-set-raw-mode-non-tty.ts": 2435, + "1572-promise-reject-all-tuple.ts": 3046, + "1572-x509-validity-date-gettime.ts": 2933, + "1573-promisify-execfile-env-spread.ts": 3140, + "1573-tdz-scalar-forward-capture.ts": 2068, + "1574-dyn-optional-method-number-keys.ts": 3318, + "1574-promise-all-tuple-literal.ts": 3025, + "1575-unknown-assert-into-record.ts": 3248, + "1576-width-coercions.ts": 2888, + "1577-url-hostname.ts": 2352, + "1578-exec-input-optional.ts": 3178, + "1579-matchall-index.ts": 3025, + "1580-exec-env-conditional-spread.ts": 3275, + "1581-declare-const-read.ts": 2341, + "1582-timer-sleep-resolve.ts": 2315, + "1583-loops-and-stream-captures.ts": 3154, + "1584-union-field-unassigned.ts": 2858, + "1585-union-field-conditional-ctor.ts": 2073, + "1586-derived-field-before-super-init.ts": 2823, + "1590-js-unannotated.js": 2965, + "1591-js-closures.js": 2113, + "1592-js-classes.js": 4260, + "1593-js-jsdoc-records.js": 3366, + "1594-js-async.js": 2772, + "1595-js-island-gap/main.js": 2168, + "1596-cjs-modules/main.js": 2751, + "1597-mjs-graph/main.mjs": 2858, + "1598-cjs-builtin-require/main.js": 2109, + "1599-js-uncaught-throw.js": 1870, + "1600-assert-passing.ts": 3321, + "1601-assert-fail-exit.ts": 2842, + "1602-assert-caught-error.ts": 2041, + "1603-assert-scalar-messages.ts": 2650, + "1604-assert-deep-structures.ts": 3035, + "1605-assert-import-forms.ts": 3128, + "1606-assert-strict-module.ts": 2927, + "1607-assert-throws-match.ts": 2731, + "1608-cjs-assert/main.js": 3193, + "1609-assert-async.ts": 1990, + "1610-path-win32-full.ts": 1939, + "1611-url-file-bridge-neutral.ts": 2575, + "1612-cjs-module-globals.cjs": 2846, + "1613-cjs-esm-proxy-named/main.mjs": 2282, + "1614-js-fence-dodges.cjs": 2910, + "1615-cjs-export-shapes/main.cjs": 3349, + "1616-cjs-esm-lexer-invisible/main.mjs": 2499, + "1617-cjs-esm-lexer-visible/main.mjs": 2355, + "1618-cjs-esm-poisoned-tail/main.mjs": 2404, + "1619-cjs-esm-reexport-invisible/main.mjs": 2675, + "1620-cjs-require-effects-order/main.js": 2586, + "1621-cjs-require-cache-hit/main.js": 2101, + "1622-cjs-require-conditional/main.js": 2194, + "1623-cjs-require-diamond/main.js": 2241, + "1624-cjs-require-dir-mid-file/main.js": 2559, + "1625-cjs-require-lazy-fn/main.js": 2333, + "1626-cjs-require-mjs/main.js": 2430, + "1627-mjs-import-cjs-requires/main.mjs": 2803, + "1628-checked-dynamic-builtin-args.cjs": 2085, + "1629-require-main-filename.cjs": 2419, + "1630-inspect-scalars.ts": 2701, + "1630-rmsync-retry-options.cjs": 2427, + "1631-inspect-arrays.ts": 3949, + "1632-inspect-records.ts": 3013, + "1633-inspect-map-set.ts": 2316, + "1634-inspect-classes.ts": 3062, + "1635-inspect-buffer.ts": 2271, + "1636-util-format.ts": 2132, + "1637-inspect-dyn.ts": 3164, + "1638-inspect-cjs.cjs": 2023, + "1639-versions-openssl-probe.ts": 2845, + "1640-fd-read-decode.ts": 3219, + "1641-string-search.ts": 3172, + "1642-object-fromentries-rows.ts": 2713, + "1643-metadata-dyn-return.cjs": 3460, + "1644-ee-basics.ts": 2495, + "1645-ee-extends.ts": 2603, + "1646-ee-once-remove.ts": 2849, + "1647-ee-meta-events.ts": 2040, + "1648-ee-error-event.ts": 2703, + "1649-ee-names-counts.ts": 2487, + "1650-ee-prepend.ts": 2672, + "1651-ee-max-listeners.ts": 2331, + "1652-ee-snapshot.ts": 2031, + "1653-ee-cjs.cjs": 2472, + "1654-ee-namespace.ts": 2390, + "1655-spawnsync-neutral.ts": 4056, + "1656-execsync-neutral.ts": 2824, + "1657-spawn-async-neutral.ts": 3268, + "1660-buffer-read-write-num.ts": 3727, + "1661-buffer-encodings-full.ts": 2670, + "1662-string-decoder-encodings.ts": 2362, + "1663-buffer-compare-search-fill.ts": 3956, + "1664-dyn-fn-boundary.cjs": 2792, + "1665-dyn-fn-mustcall/main.cjs": 2827, + "1666-dyn-fn-identity.ts": 2623, + "1667-dyn-fn-not-callable.cjs": 2618, + "1668-dyn-fn-throws.cjs": 2216, + "1669-symbol-identity.ts": 2335, + "1670-symbol-registry.ts": 1852, + "1671-symbol-typeof.ts": 2343, + "1672-symbol-containers.ts": 2800, + "1673-symbol-cjs.cjs": 2407, + "1674-symbol-inspect.ts": 1818, + "1676-func-array-surface.ts": 2784, + "1677-emitter-listeners.ts": 2400, + "1678-emitter-dyn-listeners.cjs": 2358, + "1679-console-dyn.js": 2880, + "1680-assert-bytes.ts": 3465, + "1681-assert-funcs.ts": 2454, + "1685-stream-readable-basics.ts": 2506, + "1686-stream-readable-paused.ts": 2711, + "1687-stream-readable-flow-control.ts": 2359, + "1688-stream-writable-basics.ts": 2613, + "1689-stream-writable-async-drain.ts": 2671, + "1690-stream-duplex.ts": 2112, + "1691-stream-transform.ts": 1780, + "1692-stream-pipe.ts": 3345, + "1693-stream-pipe-backpressure.ts": 2344, + "1694-stream-destroy.ts": 1870, + "1695-stream-props.ts": 2766, + "1696-stream-read-inside-read.ts": 3023, + "1697-stream-tick-vs-timer.ts": 2275, + "1698-stream-uncaught-error.ts": 2523, + "1699-stream-callback-shapes.ts": 1972, + "1700-mustcall-common/main.cjs": 3401, + "1701-mustcall-exit-report/main.cjs": 3316, + "1702-dyn-proto-dispatch.cjs": 2744, + "1703-arguments-rest-props.cjs": 2431, + "1710-cjs-export-class/main.js": 2997, + "1711-cjs-export-single-values/main.js": 2866, + "1712-field-incdec.ts": 1828, + "1713-js-dyn-fields.js": 2492, + "1720-assert-throws-shape.ts": 2372, + "1721-assert-throws-regex-class.ts": 2125, + "1722-assert-rejects.ts": 2761, + "1723-assert-does-not-reject.ts": 2536, + "1724-assert-iferror.ts": 2883, + "1725-assert-symbols.ts": 2626, + "1726-promise-with-resolvers.ts": 2320, + "1727-assert-throws-shape-exit.ts": 2580, + "1730-countdown-symbol-keys/main.js": 2657, + "1731-symbol-field-shapes.cjs": 3005, + "1732-symbol-field-cross-module/main.js": 2509, + "1740-stream-extends-readable.ts": 2167, + "1741-stream-extends-writable.ts": 2479, + "1742-stream-extends-duplex-transform.ts": 2640, + "1743-stream-extends-vt-dispatch.ts": 2388, + "1744-stream-set-encoding.ts": 2886, + "1745-stream-encoding-js.cjs": 2861, + "1746-stream-for-await.ts": 2864, + "1747-stream-for-await-js.cjs": 2685, + "1750-http-agent-options.ts": 2435, + "1751-options-record-stance.ts": 3010, + "1760-surplus-args-drop.cjs": 2845, + "1761-emitter-special-event-names.cjs": 2672, + "1770-assert-dyn-strict.ts": 2841, + "1771-assert-dyn-deep.ts": 2098, + "1772-assert-dyn-js.cjs": 2493, + "1773-assert-dyn-exit.ts": 2809, + "1780-http-res-surface.ts": 3019, + "1781-http-server-shapes.cjs": 2697, + "1790-computed-key-folds.ts": 2567, + "1791-searchparams-core.ts": 2632, + "1792-searchparams-encoding.ts": 2548, + "1793-searchparams-iteration.ts": 2977, + "1794-searchparams-url-live.ts": 2027, + "1795-dyn-handle-request.cjs": 2079, + "1796-dyn-handle-body.cjs": 3120, + "1797-dyn-handle-socket.cjs": 2724, + "1798-dyn-handle-typed-box.ts": 2104, + "1800-immediate-basics.ts": 2313, + "1801-immediate-handle.ts": 2272, + "1802-immediate-unref-exit.ts": 2368, + "1803-timeout-refresh.ts": 2346, + "1804-timers-module.ts": 2379, + "1805-timer-callback-args.ts": 2475, + "1806-timer-delay-trunc.ts": 2847, + "1810-stream-options-const-record.ts": 2576, + "1811-stream-option-value-callbacks.cjs": 2945, + "1812-stream-super-options-forwarding.cjs": 3075, + "1813-stream-finished.ts": 2644, + "1814-stream-pipeline.cjs": 2915, + "1815-stream-state-reads.cjs": 2499, + "1820-static-block-basics.ts": 2475, + "1821-static-block-order.ts": 2605, + "1822-static-block-js.js": 1831, + "1823-static-instance-method-names.ts": 2522, + "1824-for-of-destructuring-defaults.ts": 2238, + "1825-exhaustive-typeof-switch.ts": 1814, + "1826-settimeout-arguments-callback.js": 2356, + "1830-enum-numeric-basics.ts": 2431, + "1831-enum-string-const-reverse.ts": 2780, + "1832-enum-modules/main.ts": 2343, + "1835-var-basics.ts": 2924, + "1836-var-loop-capture.ts": 2857, + "1837-var-undefined-hoisting.ts": 2785, + "1838-var-modules/main.ts": 2572, + "1839-var-js/main.cjs": 2766, + "1840-jsdoc-import-type-only/main.js": 2328, + "1850-overload-basics.ts": 2354, + "1851-overload-return-narrowing.ts": 2268, + "1852-overload-class-members.ts": 2874, + "1853-overload-modules/main.ts": 2339, + "1854-ambient-declare-fn.ts": 2384, + "1855-ambient-declare-fn-uncaught.ts": 2441, + "1870-unit-type-values.ts": 2730, + "1871-empty-array-never.ts": 2177, + "1872-template-tostring-composite.ts": 2526, + "1880-json-declared-field-order.ts": 2276, + "1881-default-anon/main.ts": 2233, + "1882-default-cjs-interop/main.ts": 2407, + "1883-default-exports/main.ts": 2358, + "1890-ns-imports/main.ts": 2428, + "1891-ns-reexport/main.ts": 2422, + "1940-class-values-basics.ts": 2483, + "1941-class-values-registry.ts": 2632, + "1942-class-expressions.ts": 2765, + "1943-class-statics-expanded.ts": 2459, + "1944-class-values-modules/main.ts": 2440, + "1950-generic-fn-values.ts": 2561, + "1951-generic-classes-basics.ts": 2197, + "1952-generic-class-statics-values.ts": 2662, + "1953-generic-class-hierarchy.ts": 3001, + "1954-generic-modules/main.ts": 2756, + "1960-namespace-basics.ts": 2647, + "1961-namespace-nested.ts": 2257, + "1962-namespace-classes.ts": 2660, + "1963-namespace-aliases.ts": 2070, + "1964-namespace-type-only.ts": 2445, + "1965-namespace-ambient.ts": 2332, + "1966-namespace-modules/main.ts": 2434, + "1967-namespace-alias-typeonly.ts": 2455, + "1968-namespace-import-eq-snapshot.ts": 2251, + "1970-decorators-basics.ts": 2885, + "1971-decorators-rebinding.ts": 2022, + "1972-decorators-throwing.ts": 2312, + "1973-decorators-ambient.ts": 2390, + "1980-primitive-proto-statics.ts": 3122, + "1981-date-utc.ts": 3440, + "1982-freeze-resolve-passthrough.ts": 2302, + "1983-array-tuple-surfaces.ts": 3057, + "1990-labels-basics.ts": 2548, + "1991-for-in-loops.ts": 2966, + "1992-small-syntax.ts": 1927, + "200-strings.ts": 2314, + "2000-generic-methods-basic.ts": 2743, + "2001-generic-methods-generic-class.ts": 2632, + "2002-generic-methods-inheritance.ts": 3264, + "2003-generic-methods-object-literal.ts": 2644, + "2004-generic-methods-statics.ts": 2578, + "201-templates.ts": 2516, + "2010-generators-basics.ts": 1908, + "2011-generators-forof.ts": 2574, + "2012-generators-return-throw.ts": 2779, + "2013-generators-sent-values.ts": 2065, + "2014-generators-values.ts": 2940, + "2015-generators-yieldstar.ts": 1953, + "2016-generators-rc-stress.ts": 2595, + "2017-generators-async.ts": 2715, + "2018-generators-uncaught.ts": 2356, + "2019-generators-loops.ts": 2496, + "2020-generic-value-bindings.ts": 2351, + "2021-generic-value-binding-modules/main.ts": 2687, + "2022-width-index-capture.ts": 2751, + "2023-width-readonly.ts": 2800, + "2024-width-array-elems.ts": 2726, + "2025-width-union-compose.ts": 2851, + "2026-width-spread.ts": 2485, + "2030-width-nested.ts": 2774, + "2031-width-tuples.ts": 2693, + "2032-cjs-export-assigned-class-expression/main.cjs": 2477, + "2033-property-assigned-class-extends.cjs": 2618, + "2035-ternary-array-retag.cjs": 2404, + "2036-evolving-array-decl.cjs": 2542, + "2037-fn-decl-hoisting.cjs": 2645, + "2038-evolving-array-js.cjs": 3054, + "2040-any-bindings.ts": 2984, + "2040-mixin-heritage.ts": 2131, + "2041-any-params-returns.ts": 2687, + "2041-mixin-values.ts": 2744, + "2042-any-flow-loops.ts": 2769, + "2042-mixin-modules/main.ts": 1924, + "2043-any-dom-values.ts": 2778, + "2043-mixin-rc-stress.ts": 2775, + "2044-vtable-sibling-slots.ts": 2571, + "2045-objlit-accessors-basic.ts": 2640, + "2045-parameter-properties.ts": 2113, + "2046-abstract-classes.ts": 3000, + "2046-objlit-accessors-effects.ts": 2795, + "2047-objlit-accessors-shapes.ts": 2983, + "2047-optional-class-fields.ts": 2949, + "2050-dynamic-import-own-module/main.ts": 2608, + "2051-dynamic-import-then/main.ts": 2467, + "2052-dynamic-import-self.ts": 2449, + "2053-typeof-static-fold.ts": 2181, + "2054-destructuring-island-source.ts": 2707, + "2060-empty-tuple.ts": 2373, + "2070-computed-key-folds.ts": 2645, + "2071-integer-key-enumeration-order.ts": 3006, + "2072-expando-function-members.ts": 2512, + "2073-destructuring-assignment.ts": 2535, + "2074-island-destructuring.ts": 2609, + "2075-index-signature-runtime-keys.ts": 1981, + "2080-destructuring-defaults.ts": 2417, + "2081-destructuring-rest.ts": 2774, + "2082-destructuring-assignment.ts": 2489, + "2085-destructuring-heads-rest-params.ts": 2668, + "2087-destructuring-for-heads.ts": 2521, + "2090-index-signature-number-keys.ts": 1958, + "2091-index-signature-string-intersection.ts": 2567, + "2092-package-imports/main.ts": 2340, + "2093-timers-promises.ts": 2743, + "2094-diagnostics-channel.ts": 1983, + "2095-js-catch-unknown.js": 2499, + "2096-os-type.ts": 2709, + "2097-js-evolving-globals.js": 2560, + "210-string-methods.ts": 2593, + "2100-stream-default-hwm.ts": 2961, + "2101-dyn-param-defaults.ts": 2737, + "2102-empty-pattern-decls.ts": 2787, + "2105-computed-key-static-folds.ts": 2507, + "2106-comma-expressions.ts": 2500, + "211-string-unicode.ts": 1823, + "2110-top-object-types.ts": 1971, + "2111-json-stringify-unknown.ts": 2830, + "2112-array-at-findlast.ts": 2001, + "2113-string-index-methods.js": 2989, + "212-string-aliasing-append.ts": 1909, + "2120-package-self-import/main.ts": 1825, + "2121-esm-cycle-inert-backedge/main.ts": 1748, + "2123-ambient-import-crash/main.ts": 1870, + "2124-imports-field-wildcard/main.ts": 2082, + "2140-uri-component-codecs.ts": 1955, + "2160-dc-tracing-channel.cjs": 2212, + "2161-js-object-literal-identity.cjs": 2587, + "2162-js-dyn-destructure.cjs": 2628, + "2163-js-selfref-const.cjs": 2533, + "2164-js-then-dyn-handler.cjs": 2503, + "2165-js-throw-dyn.cjs": 2509, + "2166-cjs-getter-this/main.cjs": 2420, + "2170-island-array-exits.ts": 3096, + "2171-island-json-stringify.ts": 2652, + "2172-island-regexp-boundary.ts": 2763, + "2190-new-object-and-string-wrappers.ts": 1860, + "2191-uri-encoders.ts": 2586, + "2192-object-default-tostring.ts": 2607, + "2193-discarded-stdlib-reads.ts": 2445, + "2194-ambient-undef-chains.ts": 2022, + "2195-require-missing-package/main.mjs": 2412, + "2196-island-computed-key-chain.ts": 2831, + "2210-dyn-promise-crossing.cjs": 1918, + "2211-dc-trace-promise.cjs": 2793, + "2212-unhandled-rejection-listener.cjs": 2511, + "2213-async-local-storage.cjs": 2825, + "2214-dc-bind-store.cjs": 2651, + "2215-process-emit-warning-exit.cjs": 2666, + "2240-width-class-into-record.ts": 2573, + "2241-width-record-into-class.ts": 2686, + "2242-width-statics-into-record.ts": 2654, + "2243-width-assert-satisfies-shapes.ts": 2411, + "2250-tagged-templates.ts": 2617, + "2252-class-iterators.ts": 3448, + "2253-union-coercions.ts": 2899, + "2260-http2-constants.cjs": 2471, + "2280-builtin-namespace-destructure.cjs": 2645, + "2281-domexception-atob-btoa.cjs": 2853, + "2282-queue-microtask.cjs": 2526, + "2283-structured-clone.cjs": 3050, + "2284-regexp-constructor.cjs": 1945, + "2285-iferror-dyn.cjs": 2665, + "2286-dyn-object-walks.cjs": 2662, + "2300-dyn-record-spread-and-keyed-access.cjs": 2261, + "2301-cjs-export-table-dom-attach.cjs": 2384, + "2310-process-next-tick.ts": 2843, + "2311-next-tick-js-callbacks.js": 2254, + "2312-stream-underscore-assign.ts": 2790, + "2313-stream-underscore-assign-js.cjs": 2842, + "2314-process-introspection.ts": 2971, + "2320-await-unit.ts": 2748, + "2321-emitter-static-setmax.cjs": 2272, + "2322-dyn-array-sort.cjs": 1886, + "2323-timer-callback-returns.ts": 2523, + "2330-tls-server-runtime-options.cjs": 2677, + "2331-tls-server-options-typed.ts": 2790, + "2350-nan-global.ts": 2734, + "2351-async-methods.ts": 2622, + "2352-void-coercions.ts": 1788, + "2353-decorators-member-ambient.ts": 2547, + "2354-decorators-expression-ambient.ts": 2465, + "2360-tuple-to-array.ts": 2471, + "2361-assign-index-record.ts": 3021, + "2362-execsync-inherit.ts": 2693, + "2363-nullish-retag.ts": 2801, + "2364-in-runtime-key.ts": 2572, + "2365-dyn-into-island.ts": 1996, + "2366-string-well-formed.ts": 2147, + "2367-regexp-escape.ts": 2470, + "2368-set-methods.ts": 2846, + "2369-promise-try.ts": 2170, + "2370-group-by.ts": 2298, + "2371-iterator-helpers.ts": 2730, + "2380-buffer-module-named-import.ts": 2400, + "2381-builtin-default-imports.js": 2365, + "2382-cycle-two-decl/main.ts": 1682, + "2383-cycle-assertdoc/main.js": 2760, + "2384-cycle-mixed-bindings/main.ts": 1815, + "2385-builtin-reexport-facade/main.ts": 1834, + "2386-string-to-chars.ts": 2748, + "2387-tonumber-argv.ts": 2345, + "2388-tonumber-grammar-zoo.ts": 2619, + "2389-tonumber-unary-plus.ts": 2473, + "2390-dot-requires/main.cjs": 2365, + "2391-default-builtin-imports/main.ts": 3036, + "2392-block-guard-alias-scope.ts": 2477, + "2393-loop-exit-guard-narrow.ts": 2791, + "2394-loop-narrow-containment.ts": 2749, + "2395-while-cond-guard.ts": 2574, + "2396-born-narrowed-decl.ts": 2435, + "2397-branch-kill-merge.ts": 2334, + "2398-switch-arm-kill.ts": 2438, + "2399-reassign-kill-polarity.ts": 2238, + "240-stdout-write.ts": 2820, + "2400-kill-return-edge.ts": 2315, + "2401-kill-break-staging.ts": 2347, + "2402-labeled-break-kill.ts": 2610, + "2403-kill-continue-backedge.ts": 2391, + "2404-kill-throw-catch.ts": 2611, + "2405-sibling-arm-narrow.ts": 2300, + "2406-switch-clause-sibling-narrow.ts": 1885, + "2407-infinite-loop-seal.ts": 2596, + "2408-loop-terminality-reopen.ts": 2452, + "2409-loop-body-return-not-terminal.ts": 1860, + "2410-stacked-cases-terminality.ts": 2588, + "2411-exhaustive-switch-terminality.ts": 2704, + "2412-dowhile-guard-trailing-test.ts": 2401, + "2413-dowhile-kill-renarrow.ts": 2389, + "2414-dowhile-continue-kill.ts": 2546, + "2415-dowhile-break-trailing-test.ts": 2461, + "2416-spread-ternary-positions.ts": 2790, + "2417-ternary-local-inference.ts": 2737, + "2418-wrapped-ternary-arms.ts": 2485, + "2419-selector-ternary-union.ts": 2554, + "2420-nullish-null-identity.ts": 2418, + "2421-float-lane-inference.ts": 2337, + "2422-ieee-div-rem-corners.ts": 2498, + "2423-param-null-reassign.ts": 2447, + "2424-ternary-miss-first-narrowing.ts": 2373, + "2425-elseif-head-exit-narrow.ts": 2194, + "2426-default-snapshot-mutable/main.ts": 2194, + "2427-perf-hooks-now.ts": 2489, + "2428-field-redeclare-inherited.ts": 2204, + "2429-destructure-class-instance.ts": 2362, + "2430-empty-literal-unknown-field.js": 2633, + "2431-primitive-ctor-values.ts": 2702, + "2432-generic-member-fields-async.ts": 2679, + "2433-as-const-command-tables.ts": 2271, + "2434-deferred-init-fields.ts": 2673, + "2435-loose-same-kind-equality.ts": 2441, + "2440-console-inspect-args.ts": 3150, + "2441-console-process-argv.ts": 2027, + "2442-union-literal-arm-widening.ts": 2300, + "2443-union-literal-shadow-narrowing.ts": 2799, + "2444-union-literal-reducer-spread.ts": 2545, + "2445-math-minmax-nary.ts": 2355, + "2446-performance-global.ts": 2453, + "2447-island-boundary-slots/main.ts": 3241, + "2448-entries-null-arms-regex-arrays.ts": 3215, + "2450-private-instance-methods.ts": 2581, + "2451-private-fields.ts": 2918, + "2452-private-statics.ts": 2431, + "2453-private-accessors.ts": 2589, + "2454-private-generator-methods.ts": 2809, + "2455-private-brand-checks.ts": 2369, + "2456-private-async-methods.ts": 2625, + "2457-private-members.js": 2014, + "2460-qs-parse-grammar.ts": 2706, + "2461-qs-parse-options.ts": 2139, + "2462-qs-stringify.ts": 2756, + "2463-qs-escape-unescape.ts": 2677, + "2464-qs-require-forms.cjs": 2768, + "2470-mockable-module-shape.js": 3152, + "2471-record-keyed-write-hasown.js": 2699, + "2472-string-regexp-union.ts": 2532, + "2473-option-table-widths.js": 2095, + "2474-island-literal-forms.ts": 2881, + "2475-variadic-wrapper-island.js": 2240, + "2476-map-regex-values.ts": 2431, + "2480-recursive-record-tree.ts": 2075, + "2481-mutual-recursive-records.ts": 2525, + "2482-recursive-union-tree.ts": 2633, + "2483-recursive-record-cycles.ts": 2479, + "2484-json-stringify-circular.ts": 2869, + "2485-inspect-circular-refs.ts": 2957, + "2486-recursive-record-boundaries.ts": 2857, + "2487-recursive-deep-equal.ts": 2516, + "2488-ast-walker.ts": 2925, + "2490-find-miss-null-compare.ts": 2051, + "2491-strict-unit-compare-no-arm.ts": 2381, + "2492-loose-null-compare-unions.ts": 2451, + "2493-switch-unit-cases.ts": 2503, + "2494-no-arm-compare-effects.ts": 2501, + "2500-net-autosel-timeout.ts": 2202, + "2510-dyn-evolving-array-map.ts": 2611, + "2511-dyn-evolving-array-filter-foreach.ts": 2729, + "2512-dyn-evolving-array-mixed-push.ts": 2656, + "2520-private-statics-class-name-calls.ts": 2568, + "2521-private-statics-class-expression.ts": 2429, + "2522-private-statics-decorated.ts": 2492, + "2523-private-statics-aliased-class.ts": 2618, + "2530-object-destructuring-decl.ts": 2513, + "2531-array-tuple-destructuring-decl.ts": 2504, + "2532-param-destructuring-options.ts": 2714, + "2533-forof-destructuring.ts": 2583, + "2534-object-rest-decl.ts": 2277, + "2535-destructuring-assign-basics.ts": 2758, + "2536-destructuring-assign-nested.ts": 2761, + "2537-destructuring-assign-member-targets.ts": 2552, + "2538-destructuring-assign-class-source.ts": 2658, + "2539-class-instance-rest.ts": 2852, + "2540-accessor-destructuring-defaults.ts": 2732, + "2541-destructuring-eval-order.ts": 2121, + "2550-generics-keyof-pick.ts": 2790, + "2551-generics-value-aliases.ts": 2489, + "2552-generics-iface-methods.ts": 2118, + "2553-generics-signature-bindings.ts": 2838, + "2554-generics-frontier-mix.ts": 2857, + "2555-generics-keyof-writes.ts": 2600, + "2556-crypto-introspection.ts": 2362, + "2556-width-hybrid-shapes.ts": 3063, + "2557-tls-ca-store.ts": 2877, + "2557-width-field-lifts.ts": 2899, + "2558-index-signature-func-values.ts": 2980, + "2558-rejection-events.cjs": 2741, + "2559-index-signature-container-values.ts": 2921, + "2560-arraybuffer-dataview-set.ts": 2985, + "2561-object-is.ts": 3314, + "2562-intl-numberformat-en-us.ts": 1713, + "2563-stream-promises-pipeline.ts": 2673, + "2564-stream-promises-finished.ts": 2596, + "2565-stream-promises-js.cjs": 2121, + "2566-promise-reject-dyn-reason.js": 2527, + "2567-rest-spread-forward.js": 3263, + "2568-rest-spread-forward-dynamic.js": 2990, + "2569-upcast-identity.ts": 1878, + "2570-buffer-arg-validation.cjs": 4190, + "2571-searchparams-arg-validation.cjs": 2897, + "2572-readable-emitted-readable-flag.cjs": 2583, + "2573-fs-url-arg-ladders.cjs": 2789, + "2574-emitter-max-listeners-ladders.cjs": 2728, + "2575-string-destructuring-decl.ts": 2831, + "2576-string-destructuring-assign.ts": 2718, + "2577-builtin-global-destructuring.js": 2482, + "2578-jsval-into-unknown-rows.ts": 2821, + "2579-jsval-object-param-crossing.js": 2723, + "2580-jsval-routed-keyed-ops.js": 2125, + "2581-jsval-routed-calls.js": 3090, + "2582-jsval-object-statics.js": 2972, + "2582-jsval-routed-keyed-ops.js": 2851, + "2583-dyn-nullish-coalesce.js": 2185, + "2583-jsval-routed-calls.js": 2972, + "2584-jsval-object-statics.js": 2832, + "2584-union-dyn-collapse.ts": 2220, + "2585-dyn-nullish-coalesce.js": 2398, + "2585-unknown-array.ts": 2751, + "2586-object-assign-spread.js": 3004, + "2587-array-entries-forof.ts": 2555, + "2588-array-entries-chains.ts": 3001, + "2589-object-create-null.cjs": 2994, + "2590-object-create-dynamic.js": 3188, + "2591-ambient-generic-traps.ts": 2461, + "2592-ambient-trap-uncaught.ts": 2508, + "2593-generic-inert-bindings.ts": 2003, + "2594-nullish-generic-bindings.ts": 2473, + "2595-fs-arg-ladders.cjs": 3590, + "2596-net-arg-ladders.cjs": 2708, + "2597-dgram-send-ladders.cjs": 3185, + "2598-tls-arg-ladders.cjs": 3457, + "2599-stream-arg-ladders.cjs": 2639, + "2600-dyn-keyed-write-harness.js": 2645, + "2601-dyn-keyed-write-ops.js": 2850, + "2602-dyn-array-destructure.js": 3140, + "2603-island-keyed-write-dyn.js": 2307, + "2604-cycle-classes-mutual/main.ts": 2453, + "2605-cycle-three-module/main.ts": 2707, + "2606-dynamic-import-cycle/main.ts": 2783, + "2608-regex-named-groups.ts": 3177, + "2609-regex-named-replace.ts": 2707, + "2610-regex-named-matchall.ts": 2590, + "2611-regex-named-groups-js.cjs": 2302, + "2613-for-init-uninitialized-let.ts": 2413, + "2614-trap-binding-later-writes.ts": 2362, + "2615-nullish-field-record-binding.ts": 2480, + "2616-js-collect-probe-defers.js": 2756, + "2617-enum-static-field-import/main.ts": 2551, + "2618-ee-emit-override.ts": 2613, + "2619-ee-override-chain.ts": 2034, + "2620-ee-override-once-order.ts": 2930, + "2621-ee-override-error-throw.ts": 2533, + "2622-ee-override-filter.ts": 2677, + "2623-ee-job-queue.ts": 2500, + "2624-ee-override-js.cjs": 2183, + "2625-bytes-views.ts": 2152, + "2626-stream-event-names.ts": 2499, + "2627-stream-ticks-are-nextticks.ts": 2708, + "2628-stream-push-encodings.cjs": 2440, + "2629-stream-consumers.ts": 2913, + "2630-stream-consumers-errors.ts": 2991, + "2631-create-require/main.ts": 3044, + "2632-dyn-jsval-iterate.js": 2878, + "2633-island-promise-crossing.js": 3370, + "2634-stream-pipeline-arg-ladders.cjs": 2714, + "2635-trap-binding-unmappable-written.ts": 2160, + "2636-trap-binding-ambient-rooted-rewrite.ts": 2374, + "2637-create-require-bare/main.ts": 2239, + "2638-http-dyn-res-compat.cjs": 3131, + "2639-http-dyn-req-pause.cjs": 2921, + "2640-net-dyn-socket-compat.cjs": 2968, + "2641-http-agent-surface.cjs": 3429, + "2642-http-agent-maxsockets.cjs": 2699, + "2643-or-default-retag.ts": 2845, + "2644-http-client-url-argument.ts": 2453, + "2645-https-client-url-argument.ts": 2836, + "2646-top-level-await.ts": 2403, + "2647-top-level-await-modules/main.ts": 2235, + "2648-top-level-await-rejection.ts": 1959, + "2649-top-level-await-pending.ts": 2384, + "2650-top-level-await-self-import.ts": 1987, + "2651-top-level-await-pending-unhandled.ts": 2002, + "2652-top-level-await-dynamic/main.ts": 2598, + "2653-top-level-await-rejection-stops-loop.ts": 2523, + "2654-top-level-await-unrelated-rejection.ts": 2015, + "2655-top-level-await-cycle/main.ts": 2308, + "2656-top-level-await-cycle-order/main.ts": 4054, + "2657-top-level-await-cycle-dynamic/main.ts": 2392, + "2658-top-level-await-sync-completion/main.ts": 2314, + "2659-top-level-await-dynamic-cycle/main.ts": 2467, + "2660-top-level-await-cycle-rejection/main.ts": 2494, + "2661-top-level-await-dynamic-runtime-root/main.ts": 2327, + "2662-top-level-await-cycle-external-wait/main.ts": 2397, + "2663-top-level-await-dependency-errors/main.ts": 2080, + "2664-top-level-await-same-checkpoint-rejection.ts": 2543, + "2665-top-level-await-unhandled-listener-liveness.ts": 2570, + "2666-array-to-sorted.ts": 6667, + "2668-stored-number-array-iterator.ts": 2876, + "2669-array-copying-methods.ts": 3089, + "2670-uint8array-copy-iterate.ts": 2885, + "2671-array-copying-js.cjs": 2315, + "2672-http-request-response-callback.ts": 2962, + "2673-top-level-await-implicit-module.ts": 2333, + "2674-top-level-for-await-implicit-module.ts": 2353, + "2675-create-require-nested-esm.js": 2188, + "2675-process-self-reexec.ts": 2836, + "2676-indexed-read-strict-equality.ts": 2408, + "2676-record-clone-overrides.ts": 2543, + "2676-top-level-await-ambiguous/main.ts": 2576, + "2677-runtime-optional-closure.ts": 4255, + "2677-top-level-await-module-scope/main.ts": 2463, + "2678-date-instances.ts": 2194, + "2678-large-string-sparse-index.ts": 2586, + "2678-util-parseargs.ts": 4462, + "2679-util-parseargs-cjs.cjs": 4905, + "2680-util-parseargs-default.ts": 1889, + "2681-util-parseargs-dynamic.js": 2618, + "2682-fs-rename.ts": 3414, + "2683-filter-truthy-predicate.ts": 3055, + "2683-fs-rename-js.cjs": 4058, + "2684-filter-no-predicate-dyn.cjs": 2608, + "2684-fs-rename-abort.ts": 2639, + "2685-array-unshift-reverse.ts": 3540, + "2685-fs-write-sync.ts": 2779, + "2686-fs-file-handle.ts": 3096, + "2687-fsp-write-file-options.ts": 2864, + "2687-process-write-args.ts": 2396, + "2688-fs-stats-disk-fields.ts": 3953, + "2689-http-server-timeout-properties.ts": 2717, + "2690-https-server-timeout-option.ts": 2702, + "2691-retained-lowering-record-order.ts": 2988, + "2692-inline-record-assert-index.ts": 2526, + "2692-string-accumulation.ts": 2081, + "2693-math-constants.ts": 1991, + "2700-array-sort-complexity.ts": 2921, + "2700-http-static-trailers.ts": 2864, + "2700-wasi-core.ts": 2423, + "2701-array-sort-snapshot.ts": 2953, + "2701-http-static-trailer-wire.ts": 4541, + "2701-import-meta/main.mjs": 2520, + "2702-http-static-trailer-end.ts": 2827, + "2702-type-import-link-static/main.ts": 2535, + "2702-uint8array-to-sorted.ts": 2284, + "2703-array-sparse-sort.ts": 4504, + "2703-type-import-link-static-reexport/main.ts": 3626, + "2704-array-sparse-to-sorted.ts": 4339, + "2704-type-import-link-static-success/main.ts": 2363, + "2705-array-sparse-sort-append.ts": 4401, + "2705-type-import-link-dynamic/main.ts": 1851, + "2706-array-search-missing-needle.ts": 2603, + "2706-type-import-link-dynamic-success/main.ts": 2413, + "2707-array-search-huge-sparse.ts": 45742, + "2707-type-import-link-static-default-reexport/main.ts": 2437, + "2708-type-import-link-dynamic/main.ts": 2892, + "2720-array-read-parity.ts": 3049, + "2721-array-nested-missing-receiver.ts": 2315, + "2750-array-sparse-foundation.ts": 3742, + "2751-buffer-concat-sparse-list.ts": 4185, + "2752-array-optional-stores.ts": 2347, + "2753-array-optional-method-values.ts": 3965, + "2754-array-property-undefined.ts": 2255, + "2755-array-optional-literal-forwarding.ts": 2583, + "2780-array-parity-composition.ts": 6251, + "2781-array-missing-value-escape.ts": 2554, + "2782-array-sparse-callbacks.ts": 3284, + "2783-array-defaults-rest.ts": 2724, + "2784-array-reduce-missing-result.ts": 2691, + "2785-array-missing-destructuring.ts": 2806, + "2786-array-sparse-serialization.ts": 2888, + "2787-array-missing-string-arithmetic.ts": 1877, + "2788-array-missing-builtin-conversions.ts": 1930, + "2789-array-missing-optional-tostring.ts": 1731, + "2790-dynamic-import-self-name/main.ts": 2308, + "2791-record-optional-keys.ts": 2478, + "2792-record-optional-spread-entries.ts": 2703, + "2793-union-conversion-identity-capture.ts": 1753, + "2794-array-generic-callback-values.ts": 2420, + "2795-array-optional-typedarray-source.ts": 1737, + "2796-array-sparse-class-value-instanceof.ts": 2296, + "2800-array-expression-consumers.ts": 2565, + "2801-array-switch-consumers.ts": 2471, + "2820-array-missing-method-receivers.ts": 2123, + "2821-array-optional-numeric-comparisons.ts": 2408, + "2830-cjs-require-self-name/main.cjs": 2633, + "2840-finally-completions.ts": 2505, + "2841-using-sync.ts": 2632, + "2842-await-using.ts": 1790, + "2843-using-suppressed-error.ts": 2235, + "2844-node-disposable-resources.ts": 2658, + "2845-for-using-of.ts": 4410, + "2846-generator-using.ts": 2392, + "2850-async-generators-protocol.ts": 3002, + "2851-async-generators-values.ts": 4379, + "2852-timers-promises-interval.ts": 2511, + "2854-leading-bom-literals.ts": 2528, + "2855-searchparams-sort-complexity.ts": 2416, + "2856-dynamic-any-local-operators.ts": 1839, + "2857-branded-primitives.ts": 1736, + "2858-import-meta-resolve/main.mjs": 2679, + "2859-import-meta-resolve-dynamic/main.mjs": 2295, "2860-require-resolve/main.cjs": 2780, - "2861-readable-iterator-close.ts": 3397, - "2862-web-readable-async-iteration.ts": 3414, - "2863-class-async-iterator.ts": 2684, - "2864-array-class-method-receivers.ts": 2886, - "2865-cjs-process-alias.cjs": 2940, - "2866-dyn-switch.ts": 2042, - "2867-array-shift-length.js": 1841, - "2868-empty-record-promise-presence.js": 1948, - "2869-nullish-mixed-lazy.ts": 2998, - "2870-and-dropped-truthy-arm.ts": 1701, - "2871-optional-promise-to-unknown.ts": 2708, - "2872-unobserved-dynamic-event.ts": 1982, - "2873-optional-receiver-loop-lifetime.js": 2129, - "2874-nullable-callback-field-cycle.js": 2941, - "2875-evolving-let-read-before-write.js": 2038, - "2876-class-unknown-roundtrip.ts": 3117, - "2877-child-unknown-roundtrip.ts": 2838, - "2878-class-private-unknown.cjs": 2816, - "2880-cjs-module-graph/main.cjs": 2623, - "2890-crypto-static-utility.ts": 3216, - "2891-json-record-key-escapes.ts": 3136, - "2892-windows-console-unicode.ts": 2711, - "2893-child-stdin-duplex.ts": 2652, - "2894-child-stdin-backpressure.ts": 3049, - "2895-child-stdin-write-after-end.ts": 2813, - "2896-child-stdin-write-after-finish.ts": 1947, - "2897-child-stdin-destroy.ts": 3101, - "2898-child-stdin-spawn-failure.ts": 3024, - "2899-nested-mutual-recursion.ts": 2834, - "2900-float64array-static.ts": 2695, - "2900-void-conditional-arrow.ts": 2641, - "2901-bigint-core.ts": 2912, - "2902-bigint-bytes.ts": 2182, - "2903-bigint-storage.ts": 2897, - "2904-bigint-errors.ts": 2971, - "2905-bigint-edges.ts": 2917, - "2906-bigint-wasi-width.ts": 2941, - "2910-overloaded-callable-alias.ts": 2710, - "2911-execfile-callback.ts": 3076, - "2912-execfile-callback-options.ts": 1918, - "2912-promisify-fs-readfile.ts": 2767, - "2913-builtin-callable-alias.ts": 2872, - "2914-fixed-tuple-call-spread.ts": 2555, - "2915-path-function-values.ts": 2085, - "2916-path-function-values-cjs.ts": 2881, - "2917-builtin-callable-widths.ts": 2912, - "2918-builtin-callable-widths-cjs.ts": 1902, - "2919-fs-function-values.ts": 2935, - "2920-fs-promises-function-values.ts": 2882, - "2921-zlib-callbacks.ts": 2124, - "2922-dyn-bitwise-not.cjs": 2707, - "2923-cjs-factory-export/main.cjs": 2830, - "2930-union-receiver-calls.ts": 2484, - "2931-union-dynamic-field-call.js": 2846, - "2932-create-require-program/main.ts": 3067, - "2933-static-dynamic-import/main.ts": 2168, - "2934-static-import-stored.ts": 3004, - "2935-module-namespace-values/main.ts": 2141, - "2936-static-loose-equality.ts": 3392, - "2937-bitwise-hot-loop.ts": 2114, - "2938-fs-sync-overloads.cjs": 1863, - "2939-child-shell-text.ts": 3119, - "2940-date-parse.ts": 2606, - "2940-fsp-realpath.ts": 2319, - "2941-fsp-lstat-identity.ts": 3102, - "2941-process-exit-code.ts": 2025, - "2942-fsp-readdir-dirent.ts": 2835, - "2942-process-exit-code-override.ts": 2255, - "2943-process-exit-code-invalid.ts": 2733, - "2944-process-exit-code-wrap.ts": 1969, - "2945-url-origin-username.ts": 1974, - "2946-child-fork-ipc/main.ts": 3772, - "2946-url-port-hash.ts": 2074, - "2947-set-readonly-seeds.ts": 3071, - "2948-child-fork-eof-callback/main.ts": 3013, - "2948-stdio-callback-record.ts": 2065, - "2949-child-fork-default/main.mjs": 2829, - "2949-url-password.ts": 2408, - "2950-fs-descriptor-publication.ts": 2677, - "2951-math-static-analytic.ts": 2349, - "2952-math-static-remaining.ts": 2335, - "2953-http-header-validation.ts": 2772, - "2954-http-outgoing-headers.ts": 3428, - "2955-http-static-state.ts": 2945, - "2956-http-static-informational.ts": 2218, - "2957-http-static-response-controls.ts": 2590, - "2961-emitter-computed-names.cjs": 2830, - "2962-emitter-computed-optional.ts": 2777, - "2963-child-fork-dispatch/main.ts": 3250, - "2964-indexed-compound.ts": 3270, - "2966-numeric-array-read-fusion.ts": 2442, - "2967-numeric-array-read-lifetime.ts": 2772, - "2968-numeric-array-borrow.ts": 3227, - "2969-scalar-record-results.ts": 3038, - "2970-constant-numeric-tables.ts": 2771, - "2971-constant-table-modules/main.ts": 1871, - "2972-http-static-distinct-snapshots.ts": 3053, - "2972-math-receiver-borrow.ts": 2947, - "2973-http-static-agent.ts": 3397, - "2973-integer-bitwise-arithmetic.ts": 2920, - "2974-array-search-from-index.ts": 124091, - "2974-http-static-module-values.ts": 2984, - "2974-numeric-remainder.ts": 3296, - "2975-bigint-default-radix.ts": 2470, - "2975-http-static-client-controls.ts": 2919, - "2976-http-static-incoming-state.ts": 2589, - "2976-json-stringify-no-arguments.js": 2303, - "2977-http-static-incoming-timeout.ts": 2944, - "2977-nested-array-binding-defaults.js": 2175, - "2978-http-static-client-timeout.ts": 2391, - "2978-regexp-optional-subject.js": 2308, - "2979-array-search-mixed-needles.js": 2358, - "2979-http-static-server-timeout.ts": 1739, - "2980-http-static-server-timeout-default.ts": 2883, - "2980-string-position-arguments.js": 2832, - "2981-http-static-events.ts": 2774, - "2981-string-optional-positions.ts": 2352, - "2982-http-static-close-all.ts": 2171, - "2982-string-position-coercion-order.js": 2155, - "2983-http-static-close-idle.ts": 3021, - "2984-http-static-close-upgrade.ts": 2125, - "2985-http-static-message-destroy.ts": 2402, - "2986-http-static-client-socket-finish.ts": 2843, - "2987-http-static-timeout-errors.ts": 3151, - "2988-http-static-client-abort.ts": 2768, - "2989-http-static-response-timeout-handled.ts": 2766, - "2990-http-static-request-timeout-handled.ts": 3159, - "2991-array-indexed-equality.ts": 2285, - "2992-stream-rows.ts": 2873, - "2993-fiber-stack-lifetimes.ts": 3425, - "2994-fromcharcode-scalar.ts": 3028, - "2995-math-hyperbolic.ts": 2938, - "2996-math-near-one.ts": 3222, - "2997-math-integer-float.ts": 2299, - "300-if-else.ts": 2867, - "3001-caught-typeof-object.js": 2563, - "3002-promise-then-two.ts": 3204, - "301-while.ts": 2926, - "302-for.ts": 2606, - "3020-string-last-index-position.ts": 2319, - "3021-buffer-union-narrow-callback.ts": 2195, - "3022-string-affix-positions.ts": 2341, - "3023-string-affix-position-coercion.js": 2752, - "3024-string-number-narrow-for-in.ts": 1609, - "3025-string-search-position-coercion.js": 2728, - "3026-array-last-index-of.js": 2413, - "3027-array-last-index-of-records.ts": 2116, - "3028-string-search-dynamic-needle.js": 1998, - "3029-string-search-union-needle.js": 2405, - "303-break-continue.ts": 2031, - "3030-array-search-no-arg.js": 3128, - "3031-array-relative-index-coercion.js": 2454, - "3031-string-last-index-search-value.js": 2375, - "3032-string-search-value.js": 2888, - "3033-string-search-needle-coercion.js": 2002, - "3034-arguments-with-parameters.js": 3443, - "3035-string-positioned-search-value.js": 2991, - "3036-string-object-search-value.js": 2678, - "3037-number-nullish-conversion.js": 2958, - "3038-number-scalar-unions.ts": 2263, - "3039-string-repeat-count.js": 2105, - "304-compound-incdec.ts": 2747, - "3040-string-prototype-call.js": 3083, - "3041-string-prototype-object-call.js": 2578, - "3042-string-padding-coercion.js": 2198, - "3043-string-split-arguments.js": 2450, - "3044-array-slice-splice-positions.js": 3038, - "3045-array-indexed-mutation.js": 3285, - "3046-array-indexed-ref-identity.ts": 1964, - "3047-object-prototype-tag.js": 2750, - "3048-object-own-prototype.ts": 3516, - "3049-array-flat-depth.ts": 2507, - "305-truthiness.ts": 3022, - "3050-array-splice-insert.ts": 3679, - "3051-array-join-default.ts": 2848, - "3052-array-construction.ts": 2982, - "3053-array-construction-js.js": 3024, - "3054-dynamic-abort-record.ts": 2146, - "3055-default-builtin-nodenext/main.ts": 2904, - "3056-default-builtin-bundler/main.ts": 2933, - "3057-default-builtin-nodenext-dynamic/main.ts": 2973, - "3058-optional-array-chain-join.ts": 2285, - "3059-arguments-property-names.ts": 2296, - "3061-concurrent-fiber-stacks.ts": 1843, - "3062-runtime-optional-record-guards.ts": 3177, - "3063-runtime-optional-class-guards.ts": 2891, - "3064-installed-entry-imports/main.ts": 2942, - "3065-installed-entry-js/main.js": 2574, - "3066-source-debugging/main.ts": 2037, - "3067-cjs-function-export-require/main.cjs": 2917, - "3068-debug-variables/main.ts": 2538, - "3068-url-checked-identity.ts": 2749, - "3069-set-checked-seed.js": 2271, - "3069-tuple-spread.ts": 2404, - "3070-checked-object-accessors.js": 3199, - "3070-collection-views.ts": 3106, - "3071-checked-specialization-narrowing.js": 2927, - "3071-map-contextual-record-seeds.ts": 3315, - "3072-optional-union-receivers.ts": 3294, - "3072-weak-process-streams.js": 2924, - "3073-optional-callable-module.js": 2944, - "3073-union-keyed-reads.ts": 2310, - "3074-discriminated-intersections.ts": 2137, - "3075-recursive-contextual-literals.ts": 3075, - "3076-nullish-record-defaults.ts": 2013, - "3077-optional-union-array-reads.ts": 3340, - "3078-forward-mutable-captures.ts": 3407, - "3079-forward-mutable-tdz.ts": 3267, - "3080-exhaustive-never-bindings.ts": 2952, - "3081-recursive-array-destinations.ts": 2842, - "3082-forward-write-unwind.ts": 2956, - "3083-set-string-seed.ts": 2684, - "3084-record-own-membership.ts": 3434, - "3085-conditional-record-construction.ts": 2128, - "3086-error-constructor-options.ts": 2138, - "3087-error-options-lifetime.ts": 2004, - "3088-array-wide-callbacks.ts": 2257, - "3089-array-find-narrowing.ts": 2620, - "3090-json-discriminated-records.ts": 2285, - "3091-json-recursive-discriminants.ts": 2190, - "3092-number-union-predicates.ts": 2281, - "3093-error-option-data.ts": 2642, - "3094-json-replacer-traversal.ts": 3187, - "3095-json-reviver-traversal.ts": 2938, - "3096-json-callback-nonfinite.ts": 2858, - "3097-json-callback-reentrancy.ts": 2787, - "3098-json-callback-space.ts": 3229, - "3099-json-callback-functions.ts": 3214, - "3100-json-callback-holder.js": 2206, - "3101-json-callback-bytes.ts": 2646, - "3102-json-unknown-fields.ts": 3086, - "3103-scalar-record-nested-control-flow.ts": 2112, - "3104-native-analysis-tables-loops.ts": 2780, - "3105-nullable-collections.ts": 3028, - "3106-mixed-insertion-spreads.ts": 2007, - "3107-nullable-collection-lifetimes.ts": 3338, - "3108-for-await-sync-arrays.js": 2682, - "3108-identity-map-keys.ts": 2227, - "3109-destructuring-unknown-defaults.js": 2915, - "3109-identity-union-collections.ts": 3423, - "3110-builtin-error-families.ts": 2570, - "3110-identity-collection-mutation.ts": 2678, - "3111-identity-collection-cycles.ts": 2997, - "3112-union-switch-control-flow.ts": 2901, - "3113-union-array-removal.ts": 3399, - "3114-union-record-field-write.ts": 2336, - "3115-zlib-static-compression-levels.ts": 2528, - "3116-sequence-expression-lifetimes.ts": 3297, - "3117-unknown-switch-control-flow.ts": 2618, - "3118-recursive-union-spread.ts": 3545, - "3119-runtime-optional-spread.ts": 2406, - "3120-dynamic-property-descriptors.js": 3089, - "3120-generator-method-loop-bindings.ts": 3317, - "3120-ir-nonfinite-numbers.ts": 1849, - "3121-compound-assignment-values.js": 2286, - "3121-dynamic-accessor-descriptors.js": 4553, - "3122-dynamic-delete-descriptors.cjs": 1796, - "3122-dynamic-delete-descriptors.js": 2168, - "3122-js-async-class-methods.js": 2287, - "3123-destructured-global-tdz.js": 2851, - "3124-array-prototype-borrow.js": 3706, - "3125-regex-global-match.ts": 3004, - "3126-js-number-radix/main.ts": 3034, - "3127-spawn-runtime-options.ts": 2691, - "3128-regex-last-index.ts": 2151, - "3129-js-token-union/main.ts": 2990, - "3130-child-generic-streams.ts": 3199, - "3131-child-rest-listeners.js": 1690, - "3132-child-generic-stream-completion.ts": 5607, - "3133-text-decoder-streaming.ts": 3055, - "3134-fs-vectors.ts": 3055, - "3135-fs-file-handle-controls.ts": 3371, - "3136-fs-file-handle-options.ts": 2897, - "3137-fs-vector-callbacks.cjs": 3277, - "3138-array-large-storage.ts": 3756, - "3139-regex-native-deep-alternatives.ts": 28435, - "3140-array-dense-access.ts": 3894, - "3141-map-string-key-hash.ts": 3167, - "3150-integer-remainder.ts": 3353, - "3151-array-push-writes.ts": 3497, - "3170-number-conversion-fast-paths.ts": 3302, - "3171-method-census-data-writes.ts": 2848, - "400-fib.ts": 2397, - "401-mutual-recursion.ts": 2469, - "402-string-functions.ts": 2915, - "403-void-and-params.ts": 1930, - "4030-runtime-object-truthiness.ts": 2360, - "4031-event-emitter-long-tuples.ts": 1978, - "4032-inline-rc-fast-paths.ts": 4391, - "404-rc-stress.ts": 2580, - "4040-adapted-function-identity.ts": 3640, - "4041-adapted-function-properties.ts": 3228, - "4042-object-is-union-subclass.ts": 1738, - "4043-nonnull-missing-element.ts": 3185, - "4044-adapted-callback-modules/main.ts": 2445, - "4045-optional-element-projections.ts": 2663, - "4046-captured-parameter-values.ts": 3523, - "4047-captured-parameter-rebinding.ts": 2990, - "405-params-optional.ts": 2128, - "406-params-defaults.ts": 2785, - "4060-cycle-shared-instance/main.ts": 2724, - "4060-stack-union-reads.ts": 3544, - "4061-cycle-evaluation-order/main.ts": 2941, - "4061-nullable-ref-fields.ts": 4633, - "4062-cycle-tdz-read/main.ts": 2132, - "4063-cycle-hoisted-calls/main.ts": 2837, - "4064-cycle-classes-after-init/main.ts": 2919, - "4065-cycle-init-throws/main.ts": 2003, - "4066-cycle-top-level-tdz/main.ts": 2633, - "4067-dynamic-import-cycle-tdz/main.ts": 2814, - "407-params-rest.ts": 3063, - "408-params-ctors-inheritance.ts": 2314, - "4080-optional-read-presence-tests.ts": 2434, - "4080-string-index-bounds.ts": 2754, - "4081-hoisted-function-tdz.ts": 3289, - "4081-string-index-unproven.ts": 2424, - "4082-hoisted-function-tdz-uncaught.ts": 2711, - "4083-dynamic-import-failure/main.ts": 3307, - "4084-record-optional-field-copies.ts": 3992, - "4085-generator-loop-close.ts": 2360, - "4086-optional-capture-defaults.ts": 2000, - "4088-class-static-tdz.ts": 2016, - "4089-class-wrapper-tdz.js": 2230, - "409-params-async-generics.ts": 2900, - "4090-computed-key-tdz.js": 2345, - "4091-class-evaluation-deferred.ts": 2676, - "410-params-rc-stress.ts": 2904, - "4140-array-callback-split-visit.ts": 4145, - "4141-array-callback-ambient-receiver/main.ts": 3151, - "4142-array-callback-factories.ts": 3774, - "4143-union-refinement-intersection-arms.ts": 1858, - "420-dead-strip-modules/main.ts": 2735, - "4290-acyclic-immutable-trees.ts": 3335, - "4291-acyclic-constructor-escapes.ts": 2796, - "4292-acyclic-readonly-bypass.ts": 2522, - "4293-acyclic-dynamic-writes.ts": 2365, - "4294-console-line-sizes.ts": 6187, - "4295-console-template-parts.ts": 2942, - "4296-console-glued-long-parts.ts": 4142, - "4410-inline-object-allocation.ts": 2124, - "4411-nullable-ref-values.ts": 4400, - "4412-nullable-record-values.ts": 4209, - "4413-cycle-old-late-death.ts": 2986, - "4413-nullable-null-and-undefined.ts": 2888, - "4414-cycle-old-weak-keys.ts": 3194, - "4414-nullable-string-values.ts": 4815, - "4415-identity-borrowed-operands.ts": 2337, - "4415-nullable-container-values.ts": 4436, - "4431-exception-pending-contexts.ts": 2184, - "4432-checked-downcast-failures.ts": 3797, - "4451-int32-field-storage.ts": 3817, - "4452-int32-field-dynamic-writes.ts": 3773, - "4453-int32-closed-locals.ts": 2395, + "2861-readable-iterator-close.ts": 3207, + "2862-web-readable-async-iteration.ts": 3375, + "2863-class-async-iterator.ts": 2531, + "2864-array-class-method-receivers.ts": 1837, + "2865-cjs-process-alias.cjs": 2734, + "2866-dyn-switch.ts": 1772, + "2867-array-shift-length.js": 2411, + "2868-empty-record-promise-presence.js": 2531, + "2869-nullish-mixed-lazy.ts": 2433, + "2870-and-dropped-truthy-arm.ts": 2606, + "2871-optional-promise-to-unknown.ts": 2387, + "2872-unobserved-dynamic-event.ts": 2191, + "2873-optional-receiver-loop-lifetime.js": 2453, + "2874-nullable-callback-field-cycle.js": 2707, + "2875-evolving-let-read-before-write.js": 3668, + "2876-class-unknown-roundtrip.ts": 2817, + "2877-child-unknown-roundtrip.ts": 2660, + "2878-class-private-unknown.cjs": 4040, + "2880-cjs-module-graph/main.cjs": 2924, + "2890-crypto-static-utility.ts": 2261, + "2891-json-record-key-escapes.ts": 2705, + "2892-windows-console-unicode.ts": 2266, + "2893-child-stdin-duplex.ts": 3340, + "2894-child-stdin-backpressure.ts": 3131, + "2895-child-stdin-write-after-end.ts": 2384, + "2896-child-stdin-write-after-finish.ts": 2871, + "2897-child-stdin-destroy.ts": 2871, + "2898-child-stdin-spawn-failure.ts": 2549, + "2899-nested-mutual-recursion.ts": 2721, + "2900-float64array-static.ts": 2799, + "2900-void-conditional-arrow.ts": 2537, + "2901-bigint-core.ts": 2424, + "2902-bigint-bytes.ts": 2498, + "2903-bigint-storage.ts": 2708, + "2904-bigint-errors.ts": 2577, + "2905-bigint-edges.ts": 2439, + "2906-bigint-wasi-width.ts": 1786, + "2910-overloaded-callable-alias.ts": 2648, + "2911-execfile-callback.ts": 2191, + "2912-execfile-callback-options.ts": 2127, + "2912-promisify-fs-readfile.ts": 2460, + "2913-builtin-callable-alias.ts": 2481, + "2914-fixed-tuple-call-spread.ts": 2974, + "2915-path-function-values.ts": 2177, + "2916-path-function-values-cjs.ts": 2451, + "2917-builtin-callable-widths.ts": 2149, + "2918-builtin-callable-widths-cjs.ts": 2749, + "2919-fs-function-values.ts": 2635, + "2920-fs-promises-function-values.ts": 1999, + "2921-zlib-callbacks.ts": 2825, + "2922-dyn-bitwise-not.cjs": 2337, + "2923-cjs-factory-export/main.cjs": 2557, + "2930-union-receiver-calls.ts": 3403, + "2931-union-dynamic-field-call.js": 3002, + "2932-create-require-program/main.ts": 2467, + "2933-static-dynamic-import/main.ts": 2896, + "2934-static-import-stored.ts": 2404, + "2935-module-namespace-values/main.ts": 2608, + "2936-static-loose-equality.ts": 3140, + "2937-bitwise-hot-loop.ts": 2268, + "2938-fs-sync-overloads.cjs": 1857, + "2939-child-shell-text.ts": 3041, + "2940-date-parse.ts": 2483, + "2940-fsp-realpath.ts": 2587, + "2941-fsp-lstat-identity.ts": 2657, + "2941-process-exit-code.ts": 1743, + "2942-fsp-readdir-dirent.ts": 2911, + "2942-process-exit-code-override.ts": 1751, + "2943-process-exit-code-invalid.ts": 2583, + "2944-process-exit-code-wrap.ts": 2435, + "2945-url-origin-username.ts": 1863, + "2946-child-fork-ipc/main.ts": 3271, + "2946-url-port-hash.ts": 2587, + "2947-set-readonly-seeds.ts": 2456, + "2948-child-fork-eof-callback/main.ts": 3043, + "2948-stdio-callback-record.ts": 2421, + "2949-child-fork-default/main.mjs": 2736, + "2949-url-password.ts": 2744, + "2950-fs-descriptor-publication.ts": 2681, + "2951-math-static-analytic.ts": 3121, + "2952-math-static-remaining.ts": 2862, + "2953-http-header-validation.ts": 2956, + "2954-http-outgoing-headers.ts": 2822, + "2955-http-static-state.ts": 2955, + "2956-http-static-informational.ts": 3085, + "2957-http-static-response-controls.ts": 2273, + "2961-emitter-computed-names.cjs": 2632, + "2962-emitter-computed-optional.ts": 2051, + "2963-child-fork-dispatch/main.ts": 2809, + "2964-indexed-compound.ts": 2982, + "2966-numeric-array-read-fusion.ts": 2045, + "2967-numeric-array-read-lifetime.ts": 3048, + "2968-numeric-array-borrow.ts": 2914, + "2969-scalar-record-results.ts": 2620, + "2970-constant-numeric-tables.ts": 2078, + "2971-constant-table-modules/main.ts": 2587, + "2972-http-static-distinct-snapshots.ts": 2220, + "2972-math-receiver-borrow.ts": 3503, + "2973-http-static-agent.ts": 3163, + "2973-integer-bitwise-arithmetic.ts": 2756, + "2974-array-search-from-index.ts": 120636, + "2974-http-static-module-values.ts": 2696, + "2974-numeric-remainder.ts": 2784, + "2975-bigint-default-radix.ts": 1741, + "2975-http-static-client-controls.ts": 2204, + "2976-http-static-incoming-state.ts": 2949, + "2976-json-stringify-no-arguments.js": 2583, + "2977-http-static-incoming-timeout.ts": 2724, + "2977-nested-array-binding-defaults.js": 2760, + "2978-http-static-client-timeout.ts": 3060, + "2978-regexp-optional-subject.js": 2540, + "2979-array-search-mixed-needles.js": 2011, + "2979-http-static-server-timeout.ts": 2740, + "2980-http-static-server-timeout-default.ts": 2671, + "2980-string-position-arguments.js": 2246, + "2981-http-static-events.ts": 1817, + "2981-string-optional-positions.ts": 1836, + "2982-http-static-close-all.ts": 2421, + "2982-string-position-coercion-order.js": 3081, + "2983-http-static-close-idle.ts": 2006, + "2984-http-static-close-upgrade.ts": 2129, + "2985-http-static-message-destroy.ts": 2630, + "2986-http-static-client-socket-finish.ts": 1940, + "2987-http-static-timeout-errors.ts": 2737, + "2988-http-static-client-abort.ts": 2025, + "2989-http-static-response-timeout-handled.ts": 2928, + "2990-http-static-request-timeout-handled.ts": 2599, + "2991-array-indexed-equality.ts": 2993, + "2992-stream-rows.ts": 2556, + "2993-fiber-stack-lifetimes.ts": 3202, + "2994-fromcharcode-scalar.ts": 2833, + "2995-math-hyperbolic.ts": 2687, + "2996-math-near-one.ts": 2252, + "2997-math-integer-float.ts": 3190, + "300-if-else.ts": 2219, + "3001-caught-typeof-object.js": 2450, + "3002-promise-then-two.ts": 2484, + "301-while.ts": 2153, + "302-for.ts": 1918, + "3020-string-last-index-position.ts": 2434, + "3021-buffer-union-narrow-callback.ts": 2866, + "3022-string-affix-positions.ts": 2229, + "3023-string-affix-position-coercion.js": 3333, + "3024-string-number-narrow-for-in.ts": 2650, + "3025-string-search-position-coercion.js": 2447, + "3026-array-last-index-of.js": 2579, + "3027-array-last-index-of-records.ts": 2304, + "3028-string-search-dynamic-needle.js": 2564, + "3029-string-search-union-needle.js": 1657, + "303-break-continue.ts": 2442, + "3030-array-search-no-arg.js": 3027, + "3031-array-relative-index-coercion.js": 2940, + "3031-string-last-index-search-value.js": 2407, + "3032-string-search-value.js": 2579, + "3033-string-search-needle-coercion.js": 2232, + "3034-arguments-with-parameters.js": 2126, + "3035-string-positioned-search-value.js": 2449, + "3036-string-object-search-value.js": 1849, + "3037-number-nullish-conversion.js": 2478, + "3038-number-scalar-unions.ts": 1881, + "3039-string-repeat-count.js": 2372, + "304-compound-incdec.ts": 2266, + "3040-string-prototype-call.js": 2389, + "3041-string-prototype-object-call.js": 2679, + "3042-string-padding-coercion.js": 2923, + "3043-string-split-arguments.js": 3247, + "3044-array-slice-splice-positions.js": 2966, + "3045-array-indexed-mutation.js": 2960, + "3046-array-indexed-ref-identity.ts": 2358, + "3047-object-prototype-tag.js": 2265, + "3048-object-own-prototype.ts": 3162, + "3049-array-flat-depth.ts": 2904, + "305-truthiness.ts": 2588, + "3050-array-splice-insert.ts": 2779, + "3051-array-join-default.ts": 2220, + "3052-array-construction.ts": 2520, + "3053-array-construction-js.js": 2821, + "3054-dynamic-abort-record.ts": 2818, + "3055-default-builtin-nodenext/main.ts": 2044, + "3056-default-builtin-bundler/main.ts": 2874, + "3057-default-builtin-nodenext-dynamic/main.ts": 1912, + "3058-optional-array-chain-join.ts": 2986, + "3059-arguments-property-names.ts": 1856, + "3061-concurrent-fiber-stacks.ts": 2766, + "3062-runtime-optional-record-guards.ts": 3210, + "3063-runtime-optional-class-guards.ts": 2677, + "3064-installed-entry-imports/main.ts": 1867, + "3065-installed-entry-js/main.js": 2294, + "3066-source-debugging/main.ts": 2276, + "3067-cjs-function-export-require/main.cjs": 1963, + "3068-debug-variables/main.ts": 2578, + "3068-url-checked-identity.ts": 2207, + "3069-set-checked-seed.js": 2608, + "3069-tuple-spread.ts": 2969, + "3070-checked-object-accessors.js": 2496, + "3070-collection-views.ts": 2799, + "3071-checked-specialization-narrowing.js": 2715, + "3071-map-contextual-record-seeds.ts": 3095, + "3072-optional-union-receivers.ts": 2303, + "3072-weak-process-streams.js": 2885, + "3073-optional-callable-module.js": 2520, + "3073-union-keyed-reads.ts": 2905, + "3074-discriminated-intersections.ts": 2460, + "3075-recursive-contextual-literals.ts": 3335, + "3076-nullish-record-defaults.ts": 2894, + "3077-optional-union-array-reads.ts": 2500, + "3078-forward-mutable-captures.ts": 3097, + "3079-forward-mutable-tdz.ts": 2796, + "3080-exhaustive-never-bindings.ts": 2704, + "3081-recursive-array-destinations.ts": 2667, + "3082-forward-write-unwind.ts": 2538, + "3083-set-string-seed.ts": 2595, + "3084-record-own-membership.ts": 2879, + "3085-conditional-record-construction.ts": 2874, + "3086-error-constructor-options.ts": 2970, + "3087-error-options-lifetime.ts": 2675, + "3088-array-wide-callbacks.ts": 2690, + "3089-array-find-narrowing.ts": 2833, + "3090-json-discriminated-records.ts": 3066, + "3091-json-recursive-discriminants.ts": 2220, + "3092-number-union-predicates.ts": 2324, + "3093-error-option-data.ts": 2104, + "3094-json-replacer-traversal.ts": 2818, + "3095-json-reviver-traversal.ts": 2804, + "3096-json-callback-nonfinite.ts": 2753, + "3097-json-callback-reentrancy.ts": 2198, + "3098-json-callback-space.ts": 2839, + "3099-json-callback-functions.ts": 3102, + "3100-json-callback-holder.js": 2748, + "3101-json-callback-bytes.ts": 2087, + "3102-json-unknown-fields.ts": 2238, + "3103-scalar-record-nested-control-flow.ts": 2806, + "3104-native-analysis-tables-loops.ts": 2680, + "3105-nullable-collections.ts": 2913, + "3106-mixed-insertion-spreads.ts": 3159, + "3107-nullable-collection-lifetimes.ts": 3025, + "3108-for-await-sync-arrays.js": 3537, + "3108-identity-map-keys.ts": 3249, + "3109-destructuring-unknown-defaults.js": 2565, + "3109-identity-union-collections.ts": 3588, + "3110-builtin-error-families.ts": 2812, + "3110-identity-collection-mutation.ts": 2831, + "3111-identity-collection-cycles.ts": 2915, + "3112-union-switch-control-flow.ts": 2075, + "3113-union-array-removal.ts": 3111, + "3114-union-record-field-write.ts": 2886, + "3115-zlib-static-compression-levels.ts": 2667, + "3116-sequence-expression-lifetimes.ts": 2953, + "3117-unknown-switch-control-flow.ts": 2388, + "3118-recursive-union-spread.ts": 3091, + "3119-runtime-optional-spread.ts": 3563, + "3120-dynamic-property-descriptors.js": 2806, + "3120-generator-method-loop-bindings.ts": 2970, + "3120-ir-nonfinite-numbers.ts": 2756, + "3121-compound-assignment-values.js": 2784, + "3121-dynamic-accessor-descriptors.js": 2889, + "3122-dynamic-delete-descriptors.cjs": 2435, + "3122-dynamic-delete-descriptors.js": 2554, + "3122-js-async-class-methods.js": 2294, + "3123-destructured-global-tdz.js": 2755, + "3124-array-prototype-borrow.js": 2322, + "3125-regex-global-match.ts": 2783, + "3126-js-number-radix/main.ts": 2820, + "3127-spawn-runtime-options.ts": 3072, + "3128-regex-last-index.ts": 1823, + "3129-js-token-union/main.ts": 2769, + "3130-child-generic-streams.ts": 2981, + "3131-child-rest-listeners.js": 2627, + "3132-child-generic-stream-completion.ts": 5669, + "3133-text-decoder-streaming.ts": 2916, + "3134-fs-vectors.ts": 2782, + "3135-fs-file-handle-controls.ts": 3077, + "3136-fs-file-handle-options.ts": 3203, + "3137-fs-vector-callbacks.cjs": 3063, + "3138-array-large-storage.ts": 4112, + "3139-regex-native-deep-alternatives.ts": 26910, + "3140-array-dense-access.ts": 3431, + "3141-map-string-key-hash.ts": 3132, + "3150-integer-remainder.ts": 3203, + "3151-array-push-writes.ts": 3025, + "3170-number-conversion-fast-paths.ts": 2101, + "3171-method-census-data-writes.ts": 3216, + "400-fib.ts": 2634, + "401-mutual-recursion.ts": 2541, + "402-string-functions.ts": 2183, + "403-void-and-params.ts": 2239, + "4030-runtime-object-truthiness.ts": 2407, + "4031-event-emitter-long-tuples.ts": 2624, + "4032-inline-rc-fast-paths.ts": 3924, + "404-rc-stress.ts": 2608, + "4040-adapted-function-identity.ts": 3296, + "4041-adapted-function-properties.ts": 2613, + "4042-object-is-union-subclass.ts": 2694, + "4043-nonnull-missing-element.ts": 2672, + "4044-adapted-callback-modules/main.ts": 2828, + "4045-optional-element-projections.ts": 2963, + "4046-captured-parameter-values.ts": 3070, + "4047-captured-parameter-rebinding.ts": 2848, + "405-params-optional.ts": 1924, + "406-params-defaults.ts": 1978, + "4060-cycle-shared-instance/main.ts": 2198, + "4060-stack-union-reads.ts": 3362, + "4061-cycle-evaluation-order/main.ts": 2399, + "4061-nullable-ref-fields.ts": 4246, + "4062-cycle-tdz-read/main.ts": 2254, + "4063-cycle-hoisted-calls/main.ts": 2402, + "4064-cycle-classes-after-init/main.ts": 2048, + "4065-cycle-init-throws/main.ts": 2640, + "4066-cycle-top-level-tdz/main.ts": 2245, + "4067-dynamic-import-cycle-tdz/main.ts": 2515, + "407-params-rest.ts": 2698, + "408-params-ctors-inheritance.ts": 2092, + "4080-optional-read-presence-tests.ts": 2936, + "4080-string-index-bounds.ts": 2863, + "4081-hoisted-function-tdz.ts": 2788, + "4081-string-index-unproven.ts": 2335, + "4082-hoisted-function-tdz-uncaught.ts": 1949, + "4083-dynamic-import-failure/main.ts": 2717, + "4084-record-optional-field-copies.ts": 2527, + "4085-generator-loop-close.ts": 2591, + "4086-optional-capture-defaults.ts": 2395, + "4088-class-static-tdz.ts": 2363, + "4089-class-wrapper-tdz.js": 2402, + "409-params-async-generics.ts": 2098, + "4090-computed-key-tdz.js": 2605, + "4091-class-evaluation-deferred.ts": 2199, + "410-params-rc-stress.ts": 2565, + "4140-array-callback-split-visit.ts": 4386, + "4141-array-callback-ambient-receiver/main.ts": 2299, + "4142-array-callback-factories.ts": 3208, + "4143-union-refinement-intersection-arms.ts": 2685, + "420-dead-strip-modules/main.ts": 2527, + "4290-acyclic-immutable-trees.ts": 3246, + "4291-acyclic-constructor-escapes.ts": 2909, + "4292-acyclic-readonly-bypass.ts": 3024, + "4293-acyclic-dynamic-writes.ts": 2956, + "4294-console-line-sizes.ts": 5873, + "4295-console-template-parts.ts": 2597, + "4296-console-glued-long-parts.ts": 2868, + "4410-inline-object-allocation.ts": 3093, + "4411-nullable-ref-values.ts": 4434, + "4412-nullable-record-values.ts": 3635, + "4413-cycle-old-late-death.ts": 2102, + "4413-nullable-null-and-undefined.ts": 2783, + "4414-cycle-old-weak-keys.ts": 2960, + "4414-nullable-string-values.ts": 3874, + "4415-identity-borrowed-operands.ts": 2087, + "4415-nullable-container-values.ts": 3581, + "4431-exception-pending-contexts.ts": 3035, + "4432-checked-downcast-failures.ts": 3246, + "4451-int32-field-storage.ts": 3457, + "4452-int32-field-dynamic-writes.ts": 3861, + "4453-int32-closed-locals.ts": 2280, "4454-int32-field-reflection-reads.ts": 3951, "4455-live-view-reads-without-stores.ts": 3598, - "4471-unassigned-field-reads.ts": 2666, - "4476-string-ascii-header-fact.ts": 2214, - "4477-buffer-write-ascii-runs.ts": 3271, - "4478-string-large-index-reads.ts": 2510, - "4481-array-optional-push.ts": 3023, - "4482-instanceof-static-class-optional.ts": 2810, - "4483-array-splice-statement.ts": 3482, - "4484-array-length-reset.ts": 2127, - "4485-array-splice-optional-item.ts": 2800, - "4486-array-field-element-borrows.ts": 3650, - "4487-array-literal-optional-values.ts": 3286, - "4520-optional-guard-narrowing.ts": 2046, - "4521-array-callback-element-presence.ts": 4687, - "4522-captured-parameter-lifetimes.ts": 2497, - "4523-array-pop-removal.ts": 3081, - "4524-array-callback-supertype-params.ts": 3932, - "4541-nullable-wrap-borrows.ts": 2389, - "4542-preserving-call-borrows.ts": 3360, - "4543-walk-borrowed-locals.ts": 3391, - "4544-checked-cast-aliases.ts": 3252, - "4545-borrowed-returns.ts": 3896, - "4546-rebound-borrowed-params.ts": 1833, - "4560-field-store-borrowed-receivers.ts": 2735, - "4561-virtual-borrowed-parameters.ts": 3750, - "4562-string-self-concat-move.ts": 2152, - "4563-array-read-projection-receivers.ts": 2323, - "4564-literal-choice-strings.ts": 2445, - "4568-for-of-hole-elements.ts": 3409, - "4569-shorthand-missing-elements.ts": 2920, - "4570-map-lookup-default-record.ts": 3442, - "4591-weak-keys-union-records.ts": 3061, - "4592-cycle-const-from-import/main.ts": 2838, - "4593-weak-keys-empty-objects.ts": 3425, - "4594-union-class-field-mixed-types.ts": 3724, - "4595-union-class-field-optional-receiver.ts": 3074, - "4596-error-subclass-int-fields.ts": 2744, - "4596-tdz-nullable-forward-capture.ts": 3971, - "4597-callback-field-method-name.ts": 2791, - "4598-live-array-ref-element-access.ts": 5033, - "4598-map-set-clear-reuse.ts": 4347, - "4598-os-available-parallelism.ts": 2628, - "4598-publish-constructor-stores.ts": 3091, - "4599-construction-only-field-borrows.ts": 3355, - "4600-construction-only-fields-dynamic-writes.ts": 2213, - "4601-cycle-holders.ts": 2024, - "4602-constructor-escape-order.ts": 2992, - "4610-array-ext-dyn-refresh.ts": 3195, - "4620-optional-chain-borrowed-receivers.ts": 3095, - "4621-edge-preserving-callees/main.ts": 3779, - "4630-contract-int32.ts": 2865, - "4630-reference-write-call-arguments.ts": 2202, - "4631-contract-nothrow.ts": 2128, - "4631-reference-write-aliases.ts": 3078, - "4632-contract-immutable.ts": 2740, - "4632-reference-write-loops-and-walks.ts": 3256, - "4633-contract-program-lifetime.ts": 2525, - "4633-reference-write-callbacks-returns.ts": 3120, - "4634-contract-program-lifetime-publish.ts": 5678, - "4634-optional-element-borrowed-returns.ts": 2332, - "4640-bitwise-identity-ranges.ts": 3148, - "4641-nothrow-try-catch.ts": 3252, - "4642-acyclic-contract.ts": 2463, - "4650-stale-property-narrowing.ts": 3973, - "4651-map-string-get-entry.ts": 2471, - "4652-stale-closure-binding-narrowing.ts": 3516, - "4660-typed-rest-spread-forwarding.ts": 3181, - "4671-scoped-array-read-borrows.ts": 2667, - "4690-cycle-bypass-long-lived.ts": 4305, - "4691-publish-constructor-self-alias.ts": 2372, - "4692-borrowed-result-mutating-callees.ts": 1719, - "4720-cold-throw-paths.ts": 3494, - "4721-integer-induction-numbers.ts": 2519, - "4730-touint32-large-magnitudes.ts": 3115, - "4731-string-mixed-ascii-slices.ts": 3544, - "4732-buffer-write-utf16le-runs.ts": 3493, - "4733-typed-array-read-compares.ts": 3222, - "4750-map-string-absent-filter.ts": 2733, - "4751-string-search-multibyte-needles.ts": 2428, - "4795-published-untyped-member-reads.ts": 3850, - "4806-uint32-loop-accumulators.ts": 3676, - "4810-union-identity-retags.ts": 4908, - "4811-union-retag-checked-cast.ts": 2426, - "4812-int32-wrapping-sums.ts": 3340, - "4813-typed-array-read-equality-bindings.ts": 4912, - "4820-sort-comparator-lent-arguments.ts": 4229, - "4821-callback-lent-arguments.ts": 4442, - "4822-stable-capture-reads.ts": 3053, - "4823-array-store-receivers.ts": 3132, - "4830-typed-teardown-chains.ts": 2523, - "4831-cycle-bypass-probe-windows.ts": 2952, - "4840-array-hole-free-prefix.ts": 3114, - "4860-int32-local-storage.ts": 4294, - "4870-array-pipeline-fusion.ts": 4815, - "4871-array-pipeline-analytics.ts": 3642, - "4872-array-pipeline-temporaries.ts": 8318, - "4875-stream-consumers-array-buffer.ts": 2209, - "4876-array-buffer-inspect.ts": 3069, - "4880-await-call-turn-order.ts": 2111, - "4881-await-call-exceptions.ts": 3319, - "4882-await-call-request-chain.ts": 2496, - "4883-await-values-and-hops.ts": 2868, - "4884-await-call-unhandled-sibling.ts": 2184, - "4885-await-call-checkpoints.ts": 3054, - "4890-regex-literal-sites.ts": 2434, - "4891-regex-plain-text-patterns.ts": 2078, - "4892-regex-exec-read-captures.ts": 2821, - "4900-bigint-division-cross-check.ts": 3490, - "4900-console-instances.ts": 3829, - "4901-bigint-radix-text.ts": 2425, - "4901-console-instance-errors.ts": 2457, - "4902-bigint-compound-assign.ts": 2147, - "4903-bigint-fixed-width.ts": 2614, - "4904-bigint-large-products.ts": 3572, - "4905-bigint-fixed-width-fusion.ts": 3509, - "4906-bigint-small-value-trees.ts": 3794, - "4907-bigint-random-trees.ts": 4702, - "4910-hole-free-prefix-upkeep.ts": 2383, - "4920-string-literal-switch.ts": 2483, - "4930-typed-record-reflection.ts": 5024, - "4931-typed-data-generic-walks.ts": 4893, - "4932-typed-json-unknown.ts": 3278, - "4940-async-return-adoption.ts": 3536, - "4941-async-return-adoption-try.ts": 2995, - "4942-async-return-adoption-values.ts": 4513, - "4943-async-return-adoption-interleaved.ts": 2479, - "4950-regex-compiled-captures.ts": 4860, - "4951-regex-compiled-last-index.ts": 3606, - "4952-regex-compiled-anchors-classes.ts": 3738, - "4953-regex-compiled-backtracking.ts": 2856, - "4954-regex-log-report.ts": 4801, - "4955-regex-compiled-differential.ts": 24475, - "4970-int32-call-abi.ts": 3417, - "4980-generator-early-exit-finally.ts": 3144, - "4981-generator-delegation-iterables.ts": 4656, - "4982-generator-sent-values.ts": 2721, - "4983-generator-reuse-iterables.ts": 3420, - "4984-generator-exceptions.ts": 3409, - "4985-generator-lazy-pipeline.ts": 3627, - "4986-generator-default-channels.ts": 3616, - "4987-generator-closures-methods.ts": 2884, - "4988-generator-async-interplay.ts": 2217, - "4989-generator-step-drives.ts": 3530, - "4990-lone-surrogates.ts": 2833, - "4991-lone-surrogate-halves.ts": 2382, - "4992-lone-surrogate-search.ts": 2602, - "4993-lone-surrogate-json.ts": 2479, - "4994-lone-surrogate-uri.ts": 3069, - "4995-lone-surrogate-regex.ts": 3486, - "4996-lone-surrogate-stdio.ts": 3232, - "4997-lone-surrogate-stdout-patch.js": 2640, - "4998-lone-surrogate-buffers.ts": 2452, - "4999-lone-surrogate-io.ts": 2454, - "500-array-basics.ts": 2089, - "501-array-push-pop.ts": 2391, - "5010-lifetime-region-generations.ts": 2818, - "5011-lifetime-region-outside-references.ts": 3377, - "5012-lifetime-region-shapes.ts": 3312, - "5013-lifetime-region-async.ts": 3967, - "5014-lifetime-region-nesting.ts": 3224, - "5015-lifetime-region-publish.ts": 3866, - "5016-lifetime-region-weak-keys.ts": 2328, - "5017-lifetime-region-cycles.ts": 2417, - "5018-lifetime-region-hierarchies.ts": 4028, - "5019-lifetime-region-values.ts": 3115, - "502-array-for-of.ts": 2081, - "5020-lifetime-region-large.ts": 4189, - "5021-lifetime-region-opaque-holders.ts": 2035, - "5022-lifetime-region-workers.ts": 3716, + "4471-unassigned-field-reads.ts": 3309, + "4476-string-ascii-header-fact.ts": 2846, + "4477-buffer-write-ascii-runs.ts": 2125, + "4478-string-large-index-reads.ts": 3334, + "4481-array-optional-push.ts": 3059, + "4482-instanceof-static-class-optional.ts": 2994, + "4483-array-splice-statement.ts": 3331, + "4484-array-length-reset.ts": 2664, + "4485-array-splice-optional-item.ts": 2526, + "4486-array-field-element-borrows.ts": 2341, + "4487-array-literal-optional-values.ts": 2248, + "4520-optional-guard-narrowing.ts": 2281, + "4521-array-callback-element-presence.ts": 4131, + "4522-captured-parameter-lifetimes.ts": 2903, + "4523-array-pop-removal.ts": 2536, + "4524-array-callback-supertype-params.ts": 3251, + "4541-nullable-wrap-borrows.ts": 2882, + "4542-preserving-call-borrows.ts": 3130, + "4543-walk-borrowed-locals.ts": 3034, + "4544-checked-cast-aliases.ts": 2574, + "4545-borrowed-returns.ts": 3551, + "4546-rebound-borrowed-params.ts": 2811, + "4560-field-store-borrowed-receivers.ts": 3116, + "4561-virtual-borrowed-parameters.ts": 3237, + "4562-string-self-concat-move.ts": 2061, + "4563-array-read-projection-receivers.ts": 2512, + "4564-literal-choice-strings.ts": 2795, + "4568-for-of-hole-elements.ts": 2661, + "4569-shorthand-missing-elements.ts": 3064, + "4570-map-lookup-default-record.ts": 2901, + "4591-weak-keys-union-records.ts": 2778, + "4592-cycle-const-from-import/main.ts": 2529, + "4593-weak-keys-empty-objects.ts": 2806, + "4594-union-class-field-mixed-types.ts": 3153, + "4595-union-class-field-optional-receiver.ts": 1997, + "4596-error-subclass-int-fields.ts": 2606, + "4596-tdz-nullable-forward-capture.ts": 3433, + "4597-callback-field-method-name.ts": 2519, + "4598-live-array-ref-element-access.ts": 4363, + "4598-map-set-clear-reuse.ts": 4118, + "4598-os-available-parallelism.ts": 2474, + "4598-publish-constructor-stores.ts": 2635, + "4599-construction-only-field-borrows.ts": 3147, + "4600-construction-only-fields-dynamic-writes.ts": 2319, + "4601-cycle-holders.ts": 2904, + "4602-constructor-escape-order.ts": 2703, + "4610-array-ext-dyn-refresh.ts": 3049, + "4620-optional-chain-borrowed-receivers.ts": 3006, + "4621-edge-preserving-callees/main.ts": 2464, + "4630-contract-int32.ts": 2586, + "4630-reference-write-call-arguments.ts": 2892, + "4631-contract-nothrow.ts": 2842, + "4631-reference-write-aliases.ts": 2922, + "4632-contract-immutable.ts": 2582, + "4632-reference-write-loops-and-walks.ts": 2399, + "4633-contract-program-lifetime.ts": 3449, + "4633-reference-write-callbacks-returns.ts": 2678, + "4634-contract-program-lifetime-publish.ts": 4573, + "4634-optional-element-borrowed-returns.ts": 2111, + "4640-bitwise-identity-ranges.ts": 2671, + "4641-nothrow-try-catch.ts": 2141, + "4642-acyclic-contract.ts": 2859, + "4650-stale-property-narrowing.ts": 2759, + "4651-map-string-get-entry.ts": 3114, + "4652-stale-closure-binding-narrowing.ts": 3092, + "4660-typed-rest-spread-forwarding.ts": 2331, + "4671-scoped-array-read-borrows.ts": 2575, + "4690-cycle-bypass-long-lived.ts": 4228, + "4691-publish-constructor-self-alias.ts": 2964, + "4692-borrowed-result-mutating-callees.ts": 2766, + "4720-cold-throw-paths.ts": 3228, + "4721-integer-induction-numbers.ts": 2974, + "4730-touint32-large-magnitudes.ts": 2198, + "4731-string-mixed-ascii-slices.ts": 3160, + "4732-buffer-write-utf16le-runs.ts": 3120, + "4733-typed-array-read-compares.ts": 2977, + "4750-map-string-absent-filter.ts": 3464, + "4751-string-search-multibyte-needles.ts": 2454, + "4795-published-untyped-member-reads.ts": 3340, + "4806-uint32-loop-accumulators.ts": 2740, + "4810-union-identity-retags.ts": 4045, + "4811-union-retag-checked-cast.ts": 2819, + "4812-int32-wrapping-sums.ts": 3339, + "4813-typed-array-read-equality-bindings.ts": 3997, + "4820-sort-comparator-lent-arguments.ts": 2782, + "4821-callback-lent-arguments.ts": 3485, + "4822-stable-capture-reads.ts": 2483, + "4823-array-store-receivers.ts": 2858, + "4830-typed-teardown-chains.ts": 3292, + "4831-cycle-bypass-probe-windows.ts": 3738, + "4840-array-hole-free-prefix.ts": 3550, + "4860-int32-local-storage.ts": 3699, + "4870-array-pipeline-fusion.ts": 6694, + "4871-array-pipeline-analytics.ts": 4274, + "4872-array-pipeline-temporaries.ts": 7763, + "4875-stream-consumers-array-buffer.ts": 3017, + "4876-array-buffer-inspect.ts": 2569, + "4880-await-call-turn-order.ts": 2784, + "4881-await-call-exceptions.ts": 2757, + "4882-await-call-request-chain.ts": 2151, + "4883-await-values-and-hops.ts": 2520, + "4884-await-call-unhandled-sibling.ts": 2379, + "4885-await-call-checkpoints.ts": 2128, + "4890-regex-literal-sites.ts": 3484, + "4891-regex-plain-text-patterns.ts": 2502, + "4892-regex-exec-read-captures.ts": 3120, + "4900-bigint-division-cross-check.ts": 3532, + "4900-console-instances.ts": 3723, + "4901-bigint-radix-text.ts": 3090, + "4901-console-instance-errors.ts": 3055, + "4902-bigint-compound-assign.ts": 2449, + "4903-bigint-fixed-width.ts": 2818, + "4904-bigint-large-products.ts": 2953, + "4905-bigint-fixed-width-fusion.ts": 3047, + "4906-bigint-small-value-trees.ts": 3132, + "4907-bigint-random-trees.ts": 4068, + "4910-hole-free-prefix-upkeep.ts": 3149, + "4920-string-literal-switch.ts": 4588, + "4930-typed-record-reflection.ts": 4183, + "4931-typed-data-generic-walks.ts": 4062, + "4932-typed-json-unknown.ts": 3239, + "4940-async-return-adoption.ts": 2845, + "4941-async-return-adoption-try.ts": 3156, + "4942-async-return-adoption-values.ts": 3620, + "4943-async-return-adoption-interleaved.ts": 2831, + "4950-regex-compiled-captures.ts": 5723, + "4951-regex-compiled-last-index.ts": 3059, + "4952-regex-compiled-anchors-classes.ts": 2426, + "4953-regex-compiled-backtracking.ts": 3365, + "4954-regex-log-report.ts": 3193, + "4955-regex-compiled-differential.ts": 24862, + "4970-int32-call-abi.ts": 2508, + "4980-generator-early-exit-finally.ts": 2836, + "4981-generator-delegation-iterables.ts": 4874, + "4982-generator-sent-values.ts": 2242, + "4983-generator-reuse-iterables.ts": 3066, + "4984-generator-exceptions.ts": 2959, + "4985-generator-lazy-pipeline.ts": 2708, + "4986-generator-default-channels.ts": 3119, + "4987-generator-closures-methods.ts": 2675, + "4988-generator-async-interplay.ts": 2141, + "4989-generator-step-drives.ts": 4185, + "4990-lone-surrogates.ts": 3319, + "4991-lone-surrogate-halves.ts": 2978, + "4992-lone-surrogate-search.ts": 2759, + "4993-lone-surrogate-json.ts": 2994, + "4994-lone-surrogate-uri.ts": 2786, + "4995-lone-surrogate-regex.ts": 3169, + "4996-lone-surrogate-stdio.ts": 2201, + "4997-lone-surrogate-stdout-patch.js": 2754, + "4998-lone-surrogate-buffers.ts": 3060, + "4999-lone-surrogate-io.ts": 4219, + "500-array-basics.ts": 2646, + "501-array-push-pop.ts": 2128, + "5010-lifetime-region-generations.ts": 2950, + "5011-lifetime-region-outside-references.ts": 2816, + "5012-lifetime-region-shapes.ts": 3847, + "5013-lifetime-region-async.ts": 3198, + "5014-lifetime-region-nesting.ts": 2741, + "5015-lifetime-region-publish.ts": 2749, + "5016-lifetime-region-weak-keys.ts": 2541, + "5017-lifetime-region-cycles.ts": 2989, + "5018-lifetime-region-hierarchies.ts": 3642, + "5019-lifetime-region-values.ts": 2516, + "502-array-for-of.ts": 2614, + "5020-lifetime-region-large.ts": 3840, + "5021-lifetime-region-opaque-holders.ts": 2702, + "5022-lifetime-region-workers.ts": 3127, "5023-lifetime-region-await.ts": 3656, "5024-lifetime-region-await-forms.ts": 3342, - "503-array-functions.ts": 2924, - "504-array-rc-stress.ts": 3242, - "5040-promise-all-race-turns.ts": 4173, - "5041-promise-all-turns.js": 2741, - "5042-async-generator-return-promise.ts": 3826, - "5043-async-generator-return-forms.ts": 2473, - "5045-generator-delegation-typed-next.ts": 4238, - "5046-generator-delegation-return-throw.ts": 3793, - "5047-generator-delegation-iterables-typed.ts": 4942, - "5048-generator-delegation-async.ts": 3582, - "5049-generator-delegation-edges.ts": 2876, - "5050-inherited-in-membership.ts": 3767, - "5051-typed-record-prototypes.ts": 3580, - "5052-class-for-in-unknown.ts": 3587, - "5053-json-replacer-arrays.ts": 2213, - "5054-required-field-delete.ts": 2545, - "5055-object-create-record-literal.ts": 2467, - "5056-generator-in-unknown.ts": 2333, - "5060-child-fork-exit-after-messages/main.ts": 2415, - "5061-child-fork-local-disconnect/main.ts": 3036, - "5062-child-fork-message-before-eof/main.ts": 2882, - "5065-global-increment-initializers.ts": 2801, - "5066-global-compound-updates.ts": 3218, - "5067-global-updates-in-functions.ts": 3110, - "5068-global-var-let-const-updates.ts": 2271, - "5069-global-update-modules/main.ts": 2850, - "5070-optional-read-bindings.ts": 2832, - "5071-optional-chain-scalars.ts": 2863, - "5072-optional-nullish-ternary.ts": 2578, - "5073-optional-results.ts": 3429, - "5074-optional-pop-shift.ts": 2389, - "5075-optional-reads-unchecked/main.ts": 2697, - "5076-optional-escapes.ts": 2437, - "5080-boolean-array-storage.ts": 6485, - "5081-boolean-array-dynamic-views.ts": 2359, - "5085-promise-allsettled-turns.ts": 3904, - "5086-promise-any-turns.ts": 3934, - "5087-promise-allsettled-any-dyn.js": 5476, - "5088-promise-combinator-thenables.js": 3403, - "5089-promise-settled-records.ts": 3102, - "5090-generator-finished-result-value.ts": 3342, - "5091-generator-delegation-arrays-strings.ts": 4412, - "5092-generator-delegation-sets-maps.ts": 3102, - "5095-console-count-group.ts": 3177, - "5096-console-assert-dir.ts": 3849, - "5097-console-table.ts": 3057, - "5098-console-time-warnings.ts": 6642, - "5099-console-methods-dynamic.cjs": 3356, - "510-array-map-filter-foreach.ts": 3363, - "511-array-indexof-includes.ts": 3037, - "5110-var-hoisting-early-reads.ts": 2475, - "5111-var-hoisting-closures-classes.ts": 3177, - "5112-var-hoisting-function-scope.ts": 2961, - "5113-tdz-let-const-class.ts": 3714, - "5114-var-hoisting-js.js": 2962, - "5115-regex-replace-compiled.ts": 3348, - "5116-regex-capture-reads.ts": 3537, - "5117-regex-log-report-spans.ts": 2918, - "5118-regex-replace-char-chains.ts": 2863, - "512-array-join-chains.ts": 2158, - "5120-frame-records.ts": 2742, - "5121-frame-objects.ts": 2716, - "5122-frame-result-slots.ts": 2032, - "5123-frame-reassigned.ts": 2738, - "5124-frame-objects-control.ts": 2735, - "5125-frame-mutating-methods.ts": 2979, - "5126-frame-returned-params.ts": 2879, - "5127-frame-loop-bindings.ts": 3193, - "513-array-methods-rc-stress.ts": 2584, - "5130-event-target-dispatch.js": 3996, - "5131-event-target-listener-errors.js": 2992, - "5132-event-target-typed.ts": 2663, - "5133-abort-signal-event-target.ts": 3726, - "5134-events-error-monitor.ts": 3026, - "5135-event-target-warnings.js": 3015, - "5136-events-error-monitor-string-name.ts": 1974, - "5137-events-error-monitor-computed-name.js": 2881, - "5138-events-error-monitor-shared-listener.ts": 1863, - "5139-event-target-listener-throw.ts": 2263, - "514-array-find-some-every.ts": 3260, - "5140-os-host-facts.ts": 3684, - "5141-os-constants.ts": 3492, - "5142-path-parse-format.ts": 2821, - "5145-path-matches-glob-basics.ts": 2871, - "5146-path-matches-glob-braces.ts": 4793, - "5147-path-matches-glob-extglob.ts": 3097, - "5148-path-matches-glob-classes.ts": 3036, - "5149-path-matches-glob-win32.ts": 3100, - "515-array-flatmap.ts": 3003, - "5150-small-array-inline-slots.ts": 3147, - "5155-cycle-header-types.ts": 3920, - "516-array-reduce.ts": 3545, - "5160-field-callback-receiver.ts": 2905, - "5161-field-callback-receiver-escape.ts": 2883, - "5162-field-method-reference-receiver.ts": 2527, - "5163-field-callback-receiver.cjs": 3464, - "5164-worker-field-callback-receiver.ts": 3434, - "5165-interface-method-dispatch.ts": 3679, - "5166-interface-method-values.ts": 3253, - "5167-interface-method-order.ts": 3399, - "5168-interface-method-hierarchy.ts": 3873, - "5169-interface-method-chains.ts": 4165, - "517-array-hof-index-args.ts": 2228, - "5170-string-scan-eviction.ts": 2996, - "5171-lone-surrogate-replace-seams.ts": 3136, - "5175-forin-typed-as-unknown.ts": 2043, - "5176-object-keys-typed-as-unknown.ts": 3098, - "5177-forin-dynamic-objects.ts": 3236, - "5178-forin-keys-js.js": 3163, - "5179-forin-typed-shapes.ts": 3384, - "518-array-sort.ts": 2963, - "518-promise-void-union-callbacks.ts": 3093, - "5180-interface-arrays.ts": 3147, - "5181-interface-array-methods.ts": 8906, - "5182-interface-array-boundaries.ts": 2573, - "5183-interface-property-reads.ts": 3303, - "5184-interface-property-objects.ts": 2438, - "5185-util-inherits.cjs": 3986, - "5186-util-inherits.ts": 3513, - "5187-util-deprecate.cjs": 3994, - "5188-util-deprecate-flags.cjs": 2993, - "5189-util-deprecate.ts": 3292, - "519-array-from-length.ts": 2634, - "519-promise-union-await-values.ts": 2998, - "5190-util-callbackify.cjs": 2477, - "5191-util-callbackify.ts": 3362, - "5192-util-debuglog.cjs": 3445, - "5193-util-debuglog.ts": 3383, - "5194-process-emit-warning-tick.cjs": 2282, - "5195-object-entries-typed-as-unknown.ts": 3460, - "5196-object-values-typed-as-unknown.ts": 3267, - "5197-object-entries-dynamic-objects.ts": 3904, - "5198-object-entries-values-js.js": 2966, - "5199-object-entries-identity.ts": 3380, - "520-map-basics.ts": 2986, - "5200-array-sort-keyed-numbers.ts": 3421, - "5201-array-sort-keyed-records.ts": 5202, - "5202-array-sort-keyed-lookalikes.ts": 3629, - "5203-typed-array-sort-default.ts": 5027, - "5204-typed-array-sort-comparators.ts": 3154, - "521-map-number-keys.ts": 2975, - "5210-process-memory-usage.ts": 2993, - "5211-process-identity.ts": 2460, - "5212-perf-marks-measures.ts": 3807, - "5213-perf-timing-errors.ts": 2266, - "5214-perf-entry-inspect.ts": 4135, - "5215-perf-timing-validation.js": 3297, - "5216-perf-spread-arguments.js": 2533, - "5217-perf-spread-typed.ts": 2686, - "522-map-foreach.ts": 3042, - "5220-url-parse-warnings.ts": 2728, - "5221-url-parse-shapes.ts": 3405, - "5222-url-parse-hosts.ts": 3159, - "5223-url-parse-query.ts": 3506, - "5224-url-format-objects.ts": 3987, - "5225-url-format-whatwg.ts": 3370, - "5226-url-resolve.ts": 3030, - "5227-url-legacy-dependency/main.ts": 2891, - "5228-url-domain-conversion.ts": 2727, - "5229-url-legacy-errors.cjs": 3507, - "523-map-ref-values.ts": 2648, - "5230-inline-union-fields.ts": 3279, - "5231-inline-union-field-kinds.ts": 2225, - "5232-inline-union-fields-dynamic.ts": 4075, - "5233-inline-union-fields-shapes.ts": 3388, - "5234-inline-union-class-fields.ts": 3532, - "5235-inline-union-fields-publish.ts": 2491, - "5236-inline-union-unchecked-reads.ts": 3193, - "5237-inline-union-frame-objects.ts": 3058, - "524-map-cycles.ts": 2269, - "5240-event-target-subclass.ts": 4204, - "5241-event-subclass.ts": 2870, - "5242-event-target-subclass-hierarchy.ts": 2589, - "5243-event-target-subclass-dynamic.ts": 3729, - "5244-event-target-subclass.js": 3769, - "5245-event-target-subclass-signals.ts": 3471, - "5246-event-target-subclass-listener-throw.ts": 3466, - "5247-event-target-subclass-lifetimes.ts": 4294, - "5248-event-target-subclass-warnings.ts": 3036, - "5249-event-target-subclass-unconstructed.ts": 2612, - "525-map-rc-stress.ts": 2418, + "503-array-functions.ts": 2610, + "504-array-rc-stress.ts": 2247, + "5040-promise-all-race-turns.ts": 3415, + "5041-promise-all-turns.js": 5156, + "5042-async-generator-return-promise.ts": 3112, + "5043-async-generator-return-forms.ts": 3029, + "5045-generator-delegation-typed-next.ts": 3463, + "5046-generator-delegation-return-throw.ts": 2606, + "5047-generator-delegation-iterables-typed.ts": 4378, + "5048-generator-delegation-async.ts": 4885, + "5049-generator-delegation-edges.ts": 2538, + "5050-inherited-in-membership.ts": 3142, + "5051-typed-record-prototypes.ts": 3140, + "5052-class-for-in-unknown.ts": 2653, + "5053-json-replacer-arrays.ts": 4713, + "5054-required-field-delete.ts": 2632, + "5055-object-create-record-literal.ts": 2065, + "5056-generator-in-unknown.ts": 3903, + "5060-child-fork-exit-after-messages/main.ts": 2572, + "5061-child-fork-local-disconnect/main.ts": 3248, + "5062-child-fork-message-before-eof/main.ts": 4732, + "5065-global-increment-initializers.ts": 3985, + "5066-global-compound-updates.ts": 2635, + "5067-global-updates-in-functions.ts": 2589, + "5068-global-var-let-const-updates.ts": 2726, + "5069-global-update-modules/main.ts": 2372, + "5070-optional-read-bindings.ts": 2144, + "5071-optional-chain-scalars.ts": 2192, + "5072-optional-nullish-ternary.ts": 2587, + "5073-optional-results.ts": 2727, + "5074-optional-pop-shift.ts": 2568, + "5075-optional-reads-unchecked/main.ts": 4996, + "5076-optional-escapes.ts": 2735, + "5080-boolean-array-storage.ts": 5236, + "5081-boolean-array-dynamic-views.ts": 2815, + "5085-promise-allsettled-turns.ts": 3332, + "5086-promise-any-turns.ts": 3297, + "5087-promise-allsettled-any-dyn.js": 3767, + "5088-promise-combinator-thenables.js": 4248, + "5089-promise-settled-records.ts": 3528, + "5090-generator-finished-result-value.ts": 2964, + "5091-generator-delegation-arrays-strings.ts": 2768, + "5092-generator-delegation-sets-maps.ts": 3565, + "5095-console-count-group.ts": 2753, + "5096-console-assert-dir.ts": 4648, + "5097-console-table.ts": 2620, + "5098-console-time-warnings.ts": 6302, + "5099-console-methods-dynamic.cjs": 2644, + "510-array-map-filter-foreach.ts": 2991, + "511-array-indexof-includes.ts": 2657, + "5110-var-hoisting-early-reads.ts": 2806, + "5111-var-hoisting-closures-classes.ts": 2117, + "5112-var-hoisting-function-scope.ts": 2614, + "5113-tdz-let-const-class.ts": 3154, + "5114-var-hoisting-js.js": 4536, + "5115-regex-replace-compiled.ts": 2608, + "5116-regex-capture-reads.ts": 3064, + "5117-regex-log-report-spans.ts": 3404, + "5118-regex-replace-char-chains.ts": 2444, + "512-array-join-chains.ts": 2376, + "5120-frame-records.ts": 2615, + "5121-frame-objects.ts": 2616, + "5122-frame-result-slots.ts": 2622, + "5123-frame-reassigned.ts": 2564, + "5124-frame-objects-control.ts": 3061, + "5125-frame-mutating-methods.ts": 2527, + "5126-frame-returned-params.ts": 2697, + "5127-frame-loop-bindings.ts": 2824, + "513-array-methods-rc-stress.ts": 2641, + "5130-event-target-dispatch.js": 3752, + "5131-event-target-listener-errors.js": 3003, + "5132-event-target-typed.ts": 3341, + "5133-abort-signal-event-target.ts": 3302, + "5134-events-error-monitor.ts": 2664, + "5135-event-target-warnings.js": 2890, + "5136-events-error-monitor-string-name.ts": 2380, + "5137-events-error-monitor-computed-name.js": 3077, + "5138-events-error-monitor-shared-listener.ts": 2001, + "5139-event-target-listener-throw.ts": 1965, + "514-array-find-some-every.ts": 2998, + "5140-os-host-facts.ts": 3248, + "5141-os-constants.ts": 2402, + "5142-path-parse-format.ts": 2850, + "5145-path-matches-glob-basics.ts": 2904, + "5146-path-matches-glob-braces.ts": 4866, + "5147-path-matches-glob-extglob.ts": 2653, + "5148-path-matches-glob-classes.ts": 2765, + "5149-path-matches-glob-win32.ts": 2754, + "515-array-flatmap.ts": 3015, + "5150-small-array-inline-slots.ts": 3276, + "5155-cycle-header-types.ts": 3561, + "516-array-reduce.ts": 3293, + "5160-field-callback-receiver.ts": 3482, + "5161-field-callback-receiver-escape.ts": 2665, + "5162-field-method-reference-receiver.ts": 2779, + "5163-field-callback-receiver.cjs": 2875, + "5164-worker-field-callback-receiver.ts": 3147, + "5165-interface-method-dispatch.ts": 2641, + "5166-interface-method-values.ts": 4036, + "5167-interface-method-order.ts": 3679, + "5168-interface-method-hierarchy.ts": 4400, + "5169-interface-method-chains.ts": 2934, + "517-array-hof-index-args.ts": 2918, + "5170-string-scan-eviction.ts": 2885, + "5171-lone-surrogate-replace-seams.ts": 3463, + "5175-forin-typed-as-unknown.ts": 3333, + "5176-object-keys-typed-as-unknown.ts": 3148, + "5177-forin-dynamic-objects.ts": 2926, + "5178-forin-keys-js.js": 2135, + "5179-forin-typed-shapes.ts": 3197, + "518-array-sort.ts": 2699, + "518-promise-void-union-callbacks.ts": 1929, + "5180-interface-arrays.ts": 3267, + "5181-interface-array-methods.ts": 7443, + "5182-interface-array-boundaries.ts": 3225, + "5183-interface-property-reads.ts": 3018, + "5184-interface-property-objects.ts": 3161, + "5185-util-inherits.cjs": 3120, + "5186-util-inherits.ts": 3012, + "5187-util-deprecate.cjs": 3705, + "5188-util-deprecate-flags.cjs": 2866, + "5189-util-deprecate.ts": 2361, + "519-array-from-length.ts": 3817, + "519-promise-union-await-values.ts": 2296, + "5190-util-callbackify.cjs": 3512, + "5191-util-callbackify.ts": 2893, + "5192-util-debuglog.cjs": 3224, + "5193-util-debuglog.ts": 4346, + "5194-process-emit-warning-tick.cjs": 2199, + "5195-object-entries-typed-as-unknown.ts": 2787, + "5196-object-values-typed-as-unknown.ts": 2984, + "5197-object-entries-dynamic-objects.ts": 3371, + "5198-object-entries-values-js.js": 2819, + "5199-object-entries-identity.ts": 3133, + "520-map-basics.ts": 2629, + "5200-array-sort-keyed-numbers.ts": 3636, + "5201-array-sort-keyed-records.ts": 3559, + "5202-array-sort-keyed-lookalikes.ts": 3148, + "5203-typed-array-sort-default.ts": 6169, + "5204-typed-array-sort-comparators.ts": 4152, + "521-map-number-keys.ts": 2529, + "5210-process-memory-usage.ts": 3044, + "5211-process-identity.ts": 2815, + "5212-perf-marks-measures.ts": 2925, + "5213-perf-timing-errors.ts": 3203, + "5214-perf-entry-inspect.ts": 3164, + "5215-perf-timing-validation.js": 4384, + "5216-perf-spread-arguments.js": 3711, + "5217-perf-spread-typed.ts": 3324, + "522-map-foreach.ts": 2813, + "5220-url-parse-warnings.ts": 2906, + "5221-url-parse-shapes.ts": 2400, + "5222-url-parse-hosts.ts": 2972, + "5223-url-parse-query.ts": 2190, + "5224-url-format-objects.ts": 2681, + "5225-url-format-whatwg.ts": 2885, + "5226-url-resolve.ts": 2184, + "5227-url-legacy-dependency/main.ts": 3291, + "5228-url-domain-conversion.ts": 2624, + "5229-url-legacy-errors.cjs": 3698, + "523-map-ref-values.ts": 2904, + "5230-inline-union-fields.ts": 2318, + "5231-inline-union-field-kinds.ts": 3614, + "5232-inline-union-fields-dynamic.ts": 3502, + "5233-inline-union-fields-shapes.ts": 3338, + "5234-inline-union-class-fields.ts": 4285, + "5235-inline-union-fields-publish.ts": 2840, + "5236-inline-union-unchecked-reads.ts": 1998, + "5237-inline-union-frame-objects.ts": 2284, + "524-map-cycles.ts": 3272, + "5240-event-target-subclass.ts": 3668, + "5241-event-subclass.ts": 4201, + "5242-event-target-subclass-hierarchy.ts": 2218, + "5243-event-target-subclass-dynamic.ts": 2613, + "5244-event-target-subclass.js": 3715, + "5245-event-target-subclass-signals.ts": 3077, + "5246-event-target-subclass-listener-throw.ts": 2770, + "5247-event-target-subclass-lifetimes.ts": 3603, + "5248-event-target-subclass-warnings.ts": 2743, + "5249-event-target-subclass-unconstructed.ts": 1632, + "525-map-rc-stress.ts": 3853, "5250-cipher-aes-gcm.ts": 5771, "5251-cipher-aes-cbc.ts": 3823, "5252-cipher-aes-ctr.ts": 2580, @@ -1704,45 +1704,45 @@ "5257-cipher-vectors.ts": 3572, "5258-cipher-handles.js": 2980, "5259-cipher-chunked.ts": 2586, - "526-set-basics.ts": 2254, - "5260-record-unknown-identity.ts": 2475, - "5261-optional-field-identity.ts": 3183, - "5262-record-unknown-many.ts": 2600, - "527-set-foreach.ts": 2444, - "5270-url-parse-no-deprecation.cjs": 3324, - "5271-url-parse-throw-deprecation.cjs": 3222, - "5275-http-end-callback-order.ts": 3388, - "5276-style-text-hex-colors.cjs": 2986, - "5277-fs-read-file-buffer-option.cjs": 2730, - "5278-host-null-bytes.cjs": 2802, - "5279-search-params-null-init.cjs": 2749, - "528-set-seeded.ts": 3056, - "5285-blob-construct.ts": 2884, - "5286-blob-readers.ts": 2550, - "5287-blob-inspect.ts": 3329, - "5288-blob-validation.js": 3838, - "5289-blob-read-order.ts": 3430, - "529-map-seeded.ts": 2821, - "5290-blob-dynamic.js": 3167, - "5295-readline-promises-question.ts": 3310, - "5296-readline-lines.ts": 2423, - "5297-readline-callback-events.cjs": 2594, - "5298-readline-abort.cjs": 3296, - "5299-readline-stdin.ts": 3344, - "530-record-arrays.ts": 2381, - "5300-stream-add-abort-signal.ts": 3578, - "5301-stream-add-abort-signal-errors.cjs": 3164, - "5302-stream-promises-options.ts": 2875, - "5303-stream-finished-callback-opts.cjs": 3111, - "5305-json-stringify-typed-arrays.ts": 3510, - "531-record-array-hofs.ts": 3334, - "5315-map-iterate-after-front-deletes.ts": 2670, - "5316-map-lru-eviction.ts": 3171, - "5317-map-iterate-while-mutating.ts": 3109, - "5318-set-iterate-after-deletes.ts": 3338, - "5319-map-iteration-values.ts": 2901, - "532-record-arrays-rc-stress.ts": 2965, - "5320-map-iterate-across-compaction.ts": 2712, + "526-set-basics.ts": 1919, + "5260-record-unknown-identity.ts": 2937, + "5261-optional-field-identity.ts": 2860, + "5262-record-unknown-many.ts": 2984, + "527-set-foreach.ts": 3210, + "5270-url-parse-no-deprecation.cjs": 3158, + "5271-url-parse-throw-deprecation.cjs": 2975, + "5275-http-end-callback-order.ts": 2389, + "5276-style-text-hex-colors.cjs": 2820, + "5277-fs-read-file-buffer-option.cjs": 2710, + "5278-host-null-bytes.cjs": 2114, + "5279-search-params-null-init.cjs": 1781, + "528-set-seeded.ts": 2610, + "5285-blob-construct.ts": 2681, + "5286-blob-readers.ts": 3079, + "5287-blob-inspect.ts": 3817, + "5288-blob-validation.js": 3803, + "5289-blob-read-order.ts": 2829, + "529-map-seeded.ts": 2574, + "5290-blob-dynamic.js": 2354, + "5295-readline-promises-question.ts": 3709, + "5296-readline-lines.ts": 2760, + "5297-readline-callback-events.cjs": 2472, + "5298-readline-abort.cjs": 2757, + "5299-readline-stdin.ts": 3087, + "530-record-arrays.ts": 2787, + "5300-stream-add-abort-signal.ts": 3027, + "5301-stream-add-abort-signal-errors.cjs": 2717, + "5302-stream-promises-options.ts": 3120, + "5303-stream-finished-callback-opts.cjs": 2705, + "5305-json-stringify-typed-arrays.ts": 3153, + "531-record-array-hofs.ts": 2832, + "5315-map-iterate-after-front-deletes.ts": 3911, + "5316-map-lru-eviction.ts": 2782, + "5317-map-iterate-while-mutating.ts": 2769, + "5318-set-iterate-after-deletes.ts": 2291, + "5319-map-iteration-values.ts": 2689, + "532-record-arrays-rc-stress.ts": 2437, + "5320-map-iterate-across-compaction.ts": 3526, "5321-integer-closed-arithmetic-loops.ts": 3349, "5321-json-parse-cycles.ts": 3308, "5322-integer-variable-step-loops.ts": 2801, @@ -1751,29 +1751,29 @@ "5323-int32-nonnegative-slot-facts.ts": 2381, "5324-int32-initializer-locals.ts": 3123, "5324-structured-clone-documents.ts": 3223, - "5325-record-boundary-returns.ts": 1813, - "5326-record-boundary-params.ts": 2295, - "5327-record-boundary-identity.ts": 3016, - "5328-record-boundary-open.ts": 2956, - "5329-record-boundary-recursion.ts": 3001, - "533-array-element-cycles.ts": 2575, - "5330-record-boundary-fields.ts": 2897, - "5331-record-boundary-methods.ts": 2874, + "5325-record-boundary-returns.ts": 1763, + "5326-record-boundary-params.ts": 2634, + "5327-record-boundary-identity.ts": 2323, + "5328-record-boundary-open.ts": 2561, + "5329-record-boundary-recursion.ts": 2680, + "533-array-element-cycles.ts": 2932, + "5330-record-boundary-fields.ts": 1977, + "5331-record-boundary-methods.ts": 3130, "5332-int32-narrowed-slot-facts.ts": 2932, "5333-integer-guarded-while-counters.ts": 2773, - "5333-record-boundary-nullable-argument.ts": 2389, - "5334-fetch-mentions-without-calls.ts": 2822, + "5333-record-boundary-nullable-argument.ts": 3012, + "5334-fetch-mentions-without-calls.ts": 2532, "5335-stream-operators-values.ts": 3448, - "5335-top-level-await-pending-exit-code.ts": 2359, + "5335-top-level-await-pending-exit-code.ts": 1919, "5336-stream-operators-promise-timing.ts": 3509, - "5336-top-level-await-pending-exit-listener.ts": 2649, - "5337-dc-subscriber-throw-next-tick.cjs": 2705, + "5336-top-level-await-pending-exit-listener.ts": 3734, + "5337-dc-subscriber-throw-next-tick.cjs": 2604, "5337-stream-operators-concurrency.ts": 2478, - "5338-js-tdz-function-element.js": 2787, + "5338-js-tdz-function-element.js": 2562, "5338-stream-operators-checks.cjs": 3991, - "5339-array-buffer-constructor.js": 3134, + "5339-array-buffer-constructor.js": 2502, "5339-stream-for-await-hops.ts": 2919, - "534-record-width-subtyping.ts": 3068, + "534-record-width-subtyping.ts": 2615, "5340-readable-from-options.ts": 1980, "5341-compound-any-operand.ts": 3314, "5341-generator-callback-params.ts": 3955, @@ -1789,28 +1789,28 @@ "5343-stream-compose-edges.ts": 3078, "5344-json-parse-undeclared-keys.ts": 4193, "5344-stream-pipeline-timing.ts": 3177, - "5345-object-values-for-of-unknown.ts": 3435, - "5346-object-values-length-dynamic.ts": 3274, - "5347-object-values-loop-control.ts": 3443, - "5348-object-values-for-of-js.js": 2832, - "5349-object-entries-values-optional.ts": 3325, - "535-object-statics.ts": 3232, - "5350-object-values-wide-record.ts": 2628, - "5351-object-values-methods-index.ts": 4093, + "5345-object-values-for-of-unknown.ts": 3008, + "5346-object-values-length-dynamic.ts": 3055, + "5347-object-values-loop-control.ts": 3030, + "5348-object-values-for-of-js.js": 2732, + "5349-object-entries-values-optional.ts": 2083, + "535-object-statics.ts": 2312, + "5350-object-values-wide-record.ts": 2790, + "5351-object-values-methods-index.ts": 3275, "5352-final-field-loop-reads.ts": 2894, "5353-captured-const-values.ts": 3727, "5354-captured-const-tdz.ts": 2243, "5355-captured-function-declarations.ts": 2917, "5356-captured-tdz-ordering.ts": 2726, "5357-init-only-module-bindings.ts": 1956, - "536-map-seed-array.ts": 1912, - "5360-array-sort-comparator-calls.ts": 3363, - "5361-array-sort-inconsistent-comparators.ts": 3560, - "5362-array-sort-comparator-throws.ts": 3410, - "5363-array-sort-comparator-writes.ts": 7945, - "5364-array-sort-union-and-boolean-elements.ts": 10573, - "5365-array-sort-dynamic-values.js": 2528, - "537-map-iter-drains.ts": 3127, + "536-map-seed-array.ts": 2712, + "5360-array-sort-comparator-calls.ts": 3175, + "5361-array-sort-inconsistent-comparators.ts": 3161, + "5362-array-sort-comparator-throws.ts": 2896, + "5363-array-sort-comparator-writes.ts": 6813, + "5364-array-sort-union-and-boolean-elements.ts": 8514, + "5365-array-sort-dynamic-values.js": 2402, + "537-map-iter-drains.ts": 2867, "5370-zlib-stream-roundtrip.ts": 3486, "5371-zlib-stream-chunking.cjs": 4025, "5372-zlib-stream-errors.cjs": 2794, @@ -1821,29 +1821,29 @@ "5377-zlib-stream-backpressure.cjs": 2917, "5378-zlib-sync-options.cjs": 2777, "5379-zlib-callback-options.ts": 2861, - "538-map-set-for-of.ts": 2968, - "5390-interface-loop-element-lifetimes.ts": 3450, - "5391-interface-dispatch-hierarchies.ts": 2856, - "5392-interface-receiver-bindings.ts": 2639, - "5393-interface-array-holes.ts": 3216, - "5394-interface-implementers.ts": 3420, - "5395-locale-compare-ascii.ts": 2643, - "5396-locale-compare-latin.ts": 3373, - "5397-locale-compare-sorting.ts": 2181, - "540-tuples-basics.ts": 3148, - "5400-json-parse-typed-keys.ts": 3311, - "5405-buffer-arraybuffer-window.ts": 2743, - "5406-util-types-keys.ts": 3041, - "5407-http-header-field-limit.ts": 3155, - "5408-http-unread-request-end.ts": 3012, - "5409-http-held-request-body.ts": 3019, - "541-ref-array-json.ts": 2632, - "5410-inspect-class-values.ts": 3232, - "5411-inspect-class-hierarchies.ts": 3027, - "5412-inspect-dynamic-collections.ts": 2914, - "5413-inspect-class-values.cjs": 3313, + "538-map-set-for-of.ts": 2756, + "5390-interface-loop-element-lifetimes.ts": 2999, + "5391-interface-dispatch-hierarchies.ts": 3168, + "5392-interface-receiver-bindings.ts": 2015, + "5393-interface-array-holes.ts": 2530, + "5394-interface-implementers.ts": 2992, + "5395-locale-compare-ascii.ts": 3026, + "5396-locale-compare-latin.ts": 3119, + "5397-locale-compare-sorting.ts": 3179, + "540-tuples-basics.ts": 2776, + "5400-json-parse-typed-keys.ts": 3131, + "5405-buffer-arraybuffer-window.ts": 2729, + "5406-util-types-keys.ts": 2747, + "5407-http-header-field-limit.ts": 2785, + "5408-http-unread-request-end.ts": 3226, + "5409-http-held-request-body.ts": 3218, + "541-ref-array-json.ts": 3099, + "5410-inspect-class-values.ts": 1875, + "5411-inspect-class-hierarchies.ts": 2712, + "5412-inspect-dynamic-collections.ts": 2792, + "5413-inspect-class-values.cjs": 3020, "5415-zlib-dynamic-inputs.cjs": 3606, - "542-union-element-arrays.ts": 3131, + "542-union-element-arrays.ts": 2846, "5420-readable-from-generators.ts": 3459, "5421-readable-from-generators.cjs": 3156, "5422-stream-async-push-wakeup.ts": 3051, @@ -1854,43 +1854,43 @@ "5427-pipeline-generator-backpressure.ts": 3096, "5428-pipeline-generator-stages.cjs": 2057, "5429-pipeline-generator-buffers.ts": 2918, - "5430-dyn-number-string-boxes.ts": 3282, - "5435-crypto-hash-algorithms.ts": 2301, - "5436-crypto-hash-names.js": 2084, - "5437-crypto-hmac-algorithms.ts": 3303, - "5438-crypto-kdf-digests.ts": 2137, - "5439-crypto-kdf-callbacks.js": 3353, - "5440-crypto-hash-encodings.js": 4466, - "5441-crypto-hash-output-length.ts": 3422, - "5442-crypto-random-values.ts": 3350, - "5443-crypto-random-arguments.js": 3269, - "5444-crypto-timing-safe-equal.js": 2816, - "5445-crypto-secret-key-objects.ts": 3209, - "5445-stream-buffer-chunks.ts": 3329, - "5446-crypto-secret-key-errors.js": 2813, - "5446-stream-buffer-chunks-dynamic.js": 2503, - "5447-fs-readdir-order.ts": 2263, - "5448-fs-glob-patterns.ts": 2912, - "5449-fs-glob-options.ts": 3879, - "5450-fs-glob-validation.js": 4118, - "5451-fs-promises-glob.ts": 3698, - "5452-fs-glob-callback.ts": 2619, - "5455-power-of-two-remainder.ts": 2806, - "5456-remainder-large-integer-dividends.ts": 3156, - "5457-lcg-modulus.ts": 2975, - "5458-fractional-remainder.ts": 2938, - "5460-locale-compare-contractions.ts": 2684, - "5461-locale-compare-equivalents.ts": 3166, - "5462-locale-compare-probe-sweep.ts": 4453, - "5463-locale-compare-combining-letters.ts": 2871, - "5464-locale-compare-fractions.ts": 3156, + "5430-dyn-number-string-boxes.ts": 3059, + "5435-crypto-hash-algorithms.ts": 2030, + "5436-crypto-hash-names.js": 2098, + "5437-crypto-hmac-algorithms.ts": 2699, + "5438-crypto-kdf-digests.ts": 2741, + "5439-crypto-kdf-callbacks.js": 2685, + "5440-crypto-hash-encodings.js": 4004, + "5441-crypto-hash-output-length.ts": 3671, + "5442-crypto-random-values.ts": 3947, + "5443-crypto-random-arguments.js": 3548, + "5444-crypto-timing-safe-equal.js": 3213, + "5445-crypto-secret-key-objects.ts": 3869, + "5445-stream-buffer-chunks.ts": 2881, + "5446-crypto-secret-key-errors.js": 3035, + "5446-stream-buffer-chunks-dynamic.js": 2859, + "5447-fs-readdir-order.ts": 2639, + "5448-fs-glob-patterns.ts": 2837, + "5449-fs-glob-options.ts": 3025, + "5450-fs-glob-validation.js": 3327, + "5451-fs-promises-glob.ts": 3059, + "5452-fs-glob-callback.ts": 2936, + "5455-power-of-two-remainder.ts": 2837, + "5456-remainder-large-integer-dividends.ts": 2786, + "5457-lcg-modulus.ts": 1426, + "5458-fractional-remainder.ts": 1394, + "5460-locale-compare-contractions.ts": 2979, + "5461-locale-compare-equivalents.ts": 2661, + "5462-locale-compare-probe-sweep.ts": 3400, + "5463-locale-compare-combining-letters.ts": 2733, + "5464-locale-compare-fractions.ts": 2833, "5465-dyn-index-read-arrays.ts": 3603, "5466-dyn-index-read-special.ts": 2823, - "5470-strip-vt-osc.cjs": 2872, - "5471-strip-vt-csi.cjs": 2359, - "5472-strip-vt-random.cjs": 3265, - "5473-strip-vt-unterminated.cjs": 3751, - "5474-strip-vt-surrogates.ts": 2805, + "5470-strip-vt-osc.cjs": 2497, + "5471-strip-vt-csi.cjs": 2651, + "5472-strip-vt-random.cjs": 2375, + "5473-strip-vt-unterminated.cjs": 3521, + "5474-strip-vt-surrogates.ts": 2534, "5510-assert-error-properties.js": 2744, "5511-assert-error-class.ts": 3998, "5512-assert-error-options.js": 3572, @@ -1911,20 +1911,20 @@ "5530-buffer-pool.ts": 3788, "5531-buffer-pool-first-slab.ts": 5451, "5532-buffer-pool-first-slab-untyped.mjs": 37592, - "5540-fs-callback-forms.cjs": 3863, - "5541-fs-stats-fields.cjs": 4344, - "5542-fs-promises-parity.cjs": 2640, - "5543-fs-promises-typed.ts": 3538, - "5544-fs-opendir.cjs": 3175, - "5545-fs-options-encoding.cjs": 3831, + "5540-fs-callback-forms.cjs": 3233, + "5541-fs-stats-fields.cjs": 3564, + "5542-fs-promises-parity.cjs": 3940, + "5543-fs-promises-typed.ts": 1655, + "5544-fs-opendir.cjs": 3024, + "5545-fs-options-encoding.cjs": 2994, "5546-fs-read-stream.cjs": 3808, "5547-fs-write-stream.cjs": 5798, - "5548-fs-callback-arguments.cjs": 4728, - "5549-fs-callback-option-checks.cjs": 4270, - "5550-locale-compare-ascii-words.ts": 2457, - "5551-array-search-references.ts": 2240, - "5552-string-appends.ts": 3367, - "5553-string-append-char-code.ts": 2628, + "5548-fs-callback-arguments.cjs": 4041, + "5549-fs-callback-option-checks.cjs": 3738, + "5550-locale-compare-ascii-words.ts": 2509, + "5551-array-search-references.ts": 3475, + "5552-string-appends.ts": 2703, + "5553-string-append-char-code.ts": 2870, "5554-fs-streams-typed.ts": 4016, "5555-fs-callback-turns.cjs": 3136, "5555-http-server-close-keep-alive.ts": 6777, @@ -1937,15 +1937,15 @@ "5562-https-verify-errors.ts": 3646, "5563-http-keep-alive-timeout.ts": 11895, "5564-http-request-signal.ts": 4124, - "5565-fs-dirent-untyped.mjs": 2565, - "5566-fs-dirent-dyn-boundaries/main.mjs": 3508, + "5565-fs-dirent-untyped.mjs": 2600, + "5566-fs-dirent-dyn-boundaries/main.mjs": 2607, "5567-fs-cpsync.ts": 3736, "5568-fs-cp-errors.js": 4246, "5569-fs-cp-symlinks.ts": 2136, "5570-fs-cp-async.ts": 3348, "5571-fs-cp-deep.ts": 4817, - "5585-record-results-inlined.ts": 3419, - "5595-net-ref-unref.ts": 3245, + "5585-record-results-inlined.ts": 2922, + "5595-net-ref-unref.ts": 2593, "5600-dyn-cycle-self.ts": 2318, "5601-dyn-cycle-mutual.ts": 2455, "5602-dyn-cycle-arrays.ts": 3115, @@ -1970,19 +1970,19 @@ "5624-timers-promises-unawaited.ts": 2304, "5625-promisify-exec.ts": 7463, "5626-promisify-forms.ts": 2936, - "5627-exec-callback.ts": 2909, + "5627-exec-callback.ts": 1900, "5628-promisify-timers.ts": 3194, "5629-promisify-stream.ts": 2517, "5630-promisify-zlib.ts": 2503, - "5631-promisify-crypto.ts": 4296, - "5632-promisify-dns.ts": 2784, - "5644-net-socket-addresses.ts": 2435, - "5645-net-socket-callbacks.ts": 2678, - "5646-net-server-connections.ts": 3279, - "5647-net-is-ip.ts": 2496, - "5648-dns-lookup-forms.ts": 2735, - "5649-dns-service-servers.ts": 3175, - "5650-dns-lookup-errors-untyped.cjs": 1968, + "5631-promisify-crypto.ts": 2200, + "5632-promisify-dns.ts": 1700, + "5644-net-socket-addresses.ts": 2220, + "5645-net-socket-callbacks.ts": 2442, + "5646-net-server-connections.ts": 2389, + "5647-net-is-ip.ts": 2776, + "5648-dns-lookup-forms.ts": 2992, + "5649-dns-service-servers.ts": 2712, + "5650-dns-lookup-errors-untyped.cjs": 2822, "5651-tls-socket-protocol.ts": 2771, "5652-http-client-trailer-overflow.ts": 3884, "5653-net-socket-read-ahead.ts": 4524, @@ -1995,7 +1995,7 @@ "5664-tls-client-identity.ts": 3727, "5674-union-instanceof-array-arms.ts": 2159, "5680-array-growth-after-copy.ts": 3791, - "5681-array-pop-and-length.ts": 2915, + "5681-array-pop-and-length.ts": 3754, "5682-publish-wide-objects.ts": 3326, "5700-cycle-release-retained.ts": 2156, "5701-cycle-release-old-edges.ts": 2601, @@ -2060,39 +2060,39 @@ "5795-worker-message-port-batches.ts": 1925, "5796-worker-message-channel.cjs": 2678, "5797-worker-message-port-transfer.ts": 3445, - "5800-broadcast-channel.ts": 3609, - "5801-broadcast-channel.cjs": 3080, - "5802-broadcast-channel-workers.ts": 2610, - "5803-worker-environment-data.ts": 3416, - "5804-worker-environment-data.cjs": 2230, - "5805-worker-receive-message-parent-port.ts": 3538, - "5806-worker-resource-limits.ts": 2813, - "5807-worker-error-values.ts": 4237, - "5808-worker-unhandled-rejections.ts": 4239, - "5809-process-exit-and-rejections.cjs": 3639, - "5810-mock-method-records.ts": 3521, - "5811-mock-tracker-restore.ts": 2838, - "5812-dyn-box-async-fields.ts": 3501, - "5813-mock-timers-module.ts": 3107, - "5814-mock-timers-date.ts": 2412, + "5800-broadcast-channel.ts": 2899, + "5801-broadcast-channel.cjs": 2727, + "5802-broadcast-channel-workers.ts": 2809, + "5803-worker-environment-data.ts": 2748, + "5804-worker-environment-data.cjs": 2469, + "5805-worker-receive-message-parent-port.ts": 2839, + "5806-worker-resource-limits.ts": 3153, + "5807-worker-error-values.ts": 3304, + "5808-worker-unhandled-rejections.ts": 3430, + "5809-process-exit-and-rejections.cjs": 3294, + "5810-mock-method-records.ts": 3976, + "5811-mock-tracker-restore.ts": 3698, + "5812-dyn-box-async-fields.ts": 3522, + "5813-mock-timers-module.ts": 3766, + "5814-mock-timers-date.ts": 3760, "5830-timers-promises-signal.ts": 3875, - "5831-util-types-brands.ts": 4018, - "5832-util-types-brands-dynamic.js": 3859, - "5833-url-search-params-iterators.ts": 2320, - "5834-url-search-params-iterators-dynamic.mjs": 3863, - "5835-util-format-integer-specifiers.ts": 2838, - "5836-url-search-params-tuple-pairs.ts": 3097, - "5837-util-format-json-circular.ts": 2711, - "5838-qs-stringify-bigint.ts": 3073, + "5831-util-types-brands.ts": 3347, + "5832-util-types-brands-dynamic.js": 3250, + "5833-url-search-params-iterators.ts": 2678, + "5834-url-search-params-iterators-dynamic.mjs": 2696, + "5835-util-format-integer-specifiers.ts": 2534, + "5836-url-search-params-tuple-pairs.ts": 2118, + "5837-util-format-json-circular.ts": 3117, + "5838-qs-stringify-bigint.ts": 2207, "5839-timers-promises-scheduler.ts": 3195, "5840-promise-with-resolvers-js.js": 2842, - "5841-json-typed-dyn-members.ts": 3759, - "5842-qs-parse-null-prototype.ts": 3419, - "5843-qs-parse-null-prototype-js.mjs": 2453, - "5844-date-unknown-values.ts": 3400, + "5841-json-typed-dyn-members.ts": 5467, + "5842-qs-parse-null-prototype.ts": 1774, + "5843-qs-parse-null-prototype-js.mjs": 1559, + "5844-date-unknown-values.ts": 3969, "5845-groupby-null-prototype.ts": 2868, - "5846-events-esm-default-max.ts": 2670, - "5847-events-cjs-default-max.cjs": 2274, + "5846-events-esm-default-max.ts": 2633, + "5847-events-cjs-default-max.cjs": 2823, "5849-class-view-observations.ts": 3073, "5850-using-disposable-values.ts": 3391, "5851-using-suppressed-error-values.ts": 2932, @@ -2101,46 +2101,46 @@ "5854-array-from-async.ts": 4140, "5855-array-from-async-js.js": 3324, "5856-error-is-error.ts": 2937, - "5857-regexp-unicode-sets.ts": 2520, - "5858-disposable-stack.ts": 4398, - "5859-disposable-stack-js.js": 3669, + "5857-regexp-unicode-sets.ts": 3350, + "5858-disposable-stack.ts": 3050, + "5859-disposable-stack-js.js": 3100, "5860-url-ipv4-hosts.ts": 3101, - "5870-worker-thread-names.ts": 3899, - "5871-worker-untransferable.cjs": 3409, + "5870-worker-thread-names.ts": 3106, + "5871-worker-untransferable.cjs": 2786, "5872-readline-positional-create-interface.mjs": 3151, "5873-readline-promises-namespace.cjs": 2023, - "5874-worker-stdio-streams.ts": 3395, - "5875-worker-stdout-pipe.cjs": 3257, - "5879-worker-stdin.ts": 3922, + "5874-worker-stdio-streams.ts": 2839, + "5875-worker-stdout-pipe.cjs": 2740, + "5879-worker-stdin.ts": 3158, "5880-emitter-leak-warning-delivery.ts": 3418, - "5881-inspect-weak-collections.ts": 2457, - "5882-string-decoder-runtime-encoding.ts": 2823, - "5883-os-set-priority.ts": 2720, - "5884-inspect-layout-options.ts": 3781, + "5881-inspect-weak-collections.ts": 2615, + "5882-string-decoder-runtime-encoding.ts": 2541, + "5883-os-set-priority.ts": 2380, + "5884-inspect-layout-options.ts": 3108, "5885-events-max-listener-helpers.ts": 2992, - "5886-inspect-dates.ts": 3072, - "5887-inspect-typed-arrays.ts": 2960, - "5888-inspect-sorted.ts": 3397, + "5886-inspect-dates.ts": 2559, + "5887-inspect-typed-arrays.ts": 3448, + "5888-inspect-sorted.ts": 2998, "5889-timers-scheduler-signal.ts": 2284, "5890-while-string-length-counters.ts": 2516, "5892-buffer-write-utf16le-runs.ts": 3107, - "5900-float16-array.ts": 3631, - "5901-float16-array-js.js": 3789, - "5904-async-generator-completion.ts": 5745, - "5905-array-from-async-generator.ts": 3532, - "5906-array-from-async-generator-js.js": 3910, - "5907-regex-groups-match-rows.ts": 4071, - "5910-set-prototype-of-primitive-object-kinds.ts": 3248, - "5911-dyn-class-to-primitive.ts": 6701, - "5912-dyn-class-conversion-methods.ts": 4374, - "5913-prototype-type-error-messages.ts": 3102, - "5914-dyn-in-class-prototype-members.ts": 2530, - "5915-dyn-error-string-conversions.ts": 3023, + "5900-float16-array.ts": 3000, + "5901-float16-array-js.js": 2900, + "5904-async-generator-completion.ts": 2950, + "5905-array-from-async-generator.ts": 2750, + "5906-array-from-async-generator-js.js": 2950, + "5907-regex-groups-match-rows.ts": 3150, + "5910-set-prototype-of-primitive-object-kinds.ts": 2719, + "5911-dyn-class-to-primitive.ts": 2850, + "5912-dyn-class-conversion-methods.ts": 3251, + "5913-prototype-type-error-messages.ts": 2484, + "5914-dyn-in-class-prototype-members.ts": 3169, + "5915-dyn-error-string-conversions.ts": 3200, "5919-record-unions-shared-arms.ts": 3182, "5920-promise-try-args.ts": 3028, "5921-promise-try-args-js.js": 3179, - "5922-matchall-groups-callbacks.ts": 4418, - "5923-matchall-groups-js.js": 3161, + "5922-matchall-groups-callbacks.ts": 3650, + "5923-matchall-groups-js.js": 3970, "5924-js-literal-identity.js": 2577, "5925-class-view-identity-observers.ts": 2297, "5926-class-view-switch-js.js": 2243, @@ -2161,2558 +2161,2567 @@ "5935-js-subclass-fields-and-element-calls.js": 2484, "5936-checked-js-class-types.js": 3412, "5937-override-narrowed-union-returns.ts": 3036, - "5938-object-literal-computed-keys-keep-methods.ts": 3273, - "5939-js-let-object-reassigned-wider.js": 1819, + "5938-object-literal-computed-keys-keep-methods.ts": 3195, + "5939-js-let-object-reassigned-wider.js": 1945, "5940-callback-helper-specialization.ts": 3109, "5941-callback-specialization-recursion.ts": 3112, "5942-callback-specialization-throws.ts": 3221, - "5943-fields-read-before-assignment.ts": 3902, - "5944-js-fields-read-before-assignment.js": 2868, - "5945-local-class-observed-methods.ts": 2284, - "5946-nested-record-field-optional-writes.ts": 2987, - "5950-tuple-predicate-methods.ts": 4611, - "5951-result-never-widening.ts": 2943, - "5952-record-missing-keys.ts": 2332, - "5953-nan-coded-method-returns.ts": 2799, - "5955-any-promise-methods.js": 3148, - "5956-erased-generic-members.ts": 4927, - "5958-asserted-union-receiver.ts": 2198, - "5959-date-to-json.ts": 3051, + "5943-fields-read-before-assignment.ts": 6856, + "5944-js-fields-read-before-assignment.js": 4247, + "5945-local-class-observed-methods.ts": 5063, + "5946-nested-record-field-optional-writes.ts": 6045, + "5950-tuple-predicate-methods.ts": 5990, + "5951-result-never-widening.ts": 4710, + "5952-record-missing-keys.ts": 6090, + "5953-nan-coded-method-returns.ts": 4100, + "5955-any-promise-methods.js": 3940, + "5956-erased-generic-members.ts": 6730, + "5958-asserted-union-receiver.ts": 2430, + "5959-date-to-json.ts": 3330, "5960-frame-records-own-references.ts": 3563, - "5960-generic-mapped-types.ts": 2996, + "5960-generic-mapped-types.ts": 2540, "5961-frame-spread-updates.ts": 3260, "5962-frame-tuples.ts": 3208, - "5970-net-connect-host-name.ts": 1747, - "5971-buffer-chunks-to-string.ts": 3079, - "5972-net-set-encoding-listeners.ts": 3253, + "5970-net-connect-host-name.ts": 2400, + "5971-buffer-chunks-to-string.ts": 2700, + "5972-net-set-encoding-listeners.ts": 2550, "5973-large-closure-environment.ts": 4499, - "5974-typeof-module-exports.cjs": 2558, - "5975-zlib-class-values.ts": 2531, - "5990-worker-uncloneable.mjs": 3772, - "5991-worker-async-dispose.mjs": 4075, - "5992-worker-thread-name-lifetime.mjs": 3241, + "5974-typeof-module-exports.cjs": 2000, + "5975-zlib-class-values.ts": 2800, + "5990-worker-uncloneable.mjs": 3283, + "5991-worker-async-dispose.mjs": 5699, + "5992-worker-thread-name-lifetime.mjs": 2687, "5993-array-length-loop-resizing.ts": 3187, "5994-array-length-sparse-loops.ts": 3292, "5995-array-dense-loop-boundaries.ts": 2596, - "600-closures-basic.ts": 2093, - "601-closures-loops.ts": 2964, - "602-closures-identity-recursion.ts": 2859, - "6020-class-extends-function-constructor.js": 3170, - "6021-asserted-literal-union-arm.ts": 3166, - "603-closures-rc-stress.ts": 2756, - "604-closures-for-of.ts": 2963, + "5996-rejections-between-macrotasks.cjs": 3034, + "600-closures-basic.ts": 2349, + "601-closures-loops.ts": 1788, + "602-closures-identity-recursion.ts": 2372, + "6020-class-extends-function-constructor.js": 4300, + "6021-asserted-literal-union-arm.ts": 3400, + "603-closures-rc-stress.ts": 1832, + "604-closures-for-of.ts": 2639, "6041-error-cause-redeclared.ts": 2988, "6042-regex-match-object-destructuring.ts": 3393, "6043-string-index-narrowed-union.ts": 2983, - "605-closures-forward-capture-tdz.ts": 2902, + "605-closures-forward-capture-tdz.ts": 3277, "6140-cjs-require-tdz-throws/main.js": 2731, "6141-cjs-require-tdz-checked/main.js": 2856, "6142-cjs-require-published-early/main.js": 3400, "6143-cjs-require-json/main.js": 3245, "6144-cjs-require-builtin-nested/main.js": 2181, "6145-cjs-require-cycle/main.js": 3507, - "700-classes-basic.ts": 2476, - "701-classes-composition.ts": 2819, - "702-classes-this-capture.ts": 2834, - "703-classes-rc-stress.ts": 2484, - "710-inheritance-basics.ts": 2629, - "711-inheritance-dispatch.ts": 2199, - "712-inheritance-instanceof.ts": 2914, - "713-inheritance-rc-stress.ts": 2307, - "720-accessors-basics.ts": 2496, - "721-accessors-eval-order.ts": 3007, - "722-accessors-inheritance.ts": 2266, - "723-accessors-rc-stress.ts": 2951, - "750-cycle-closure-box.ts": 2797, - "751-cycle-records-mutual.ts": 2867, - "752-cycle-classes.ts": 2668, - "753-cycle-owned-arrays.ts": 2613, - "754-cycle-external-ref.ts": 2566, - "755-cycle-async-promise.ts": 2707, - "756-cycle-inheritance.ts": 2258, - "757-cycle-cross-generation.ts": 3080, - "762-any-boundary.ts": 3283, - "764-any-async.ts": 2876, - "765-any-optional-chain.ts": 3213, - "766-any-union-boundary.ts": 3515, - "767-string-literal-keys.ts": 2750, - "768-any-uninitialized.ts": 2902, - "800-switch-basics.ts": 2776, - "801-switch-lazy-tests.ts": 2159, - "802-switch-loops.ts": 2543, - "803-switch-rc-stress.ts": 3003, - "804-switch-braced-blocks.ts": 2593, - "810-do-while.ts": 2089, - "820-multi-decl.ts": 2503, - "830-let-uninitialized.ts": 2817, - "900-records-basics.ts": 2340, - "901-records-eval-order.ts": 2257, - "902-records-functions-closures.ts": 2757, - "903-records-rc-stress.ts": 2938, - "904-records-optional-fields.ts": 2935, - "905-records-optional-rc-stress.ts": 2626, - "906-records-utility-types.ts": 2717, - "907-records-utility-generics.ts": 2997, - "908-records-index-signatures.ts": 3162, - "909-records-index-json.ts": 3408, - "910-records-index-rc-stress.ts": 2486, - "911-records-index-dot-access.ts": 3533, - "912-unknown-slots.ts": 2761, - "913-records-index-iteration.ts": 3662, - "914-records-from-entries.ts": 3551, - "915-unknown-tostring-eq.ts": 3814, - "916-unknown-bytes.ts": 2926, - "917-record-array-index-dot.ts": 2493, - "950-modules-basic/main.ts": 2549, - "951-modules-diamond/main.ts": 2015, - "952-modules-cross/main.ts": 2203, - "953-modules-default/main.ts": 2058, - "954-modules-reexport/main.ts": 2223, - "957-builtins-namespace.ts": 2583, - "960-generics-basics.ts": 2371, - "961-generics-recursion.ts": 2698, - "962-generics-closures.ts": 2945, - "963-generics-modules/main.ts": 1815, - "964-generics-rc-stress.ts": 3183, - "965-generics-async.ts": 3138, - "965-unions-retag.ts": 2552, - "966-unions-retag-rc-stress.ts": 2838, - "967-record-field-widening.ts": 3366, - "969-unions-arm-matrix.ts": 2362, - "970-unions-basics.ts": 2298, - "971-unions-switch.ts": 2850, - "972-unions-nested.ts": 2374, - "973-unions-rc-stress.ts": 1915, - "974-unions-modules/main.ts": 2639, - "975-unions-undefined.ts": 2297, - "976-unions-null.ts": 1941, - "977-unions-unit-rc-stress.ts": 2513, - "978-unions-nullish.ts": 3070, - "979-unions-optional-chaining.ts": 3263, - "980-exceptions-basics.ts": 2631, - "981-exceptions-values.ts": 2273, - "982-exceptions-rc-stress.ts": 2398, - "983-exceptions-control-flow.ts": 2350, - "984-exceptions-finally.ts": 2928, - "985-exceptions-call-chains.ts": 2642, - "986-exceptions-uncaught.ts": 2072, - "987-exceptions-result-unions.ts": 2255, - "990-process-basics.ts": 2565, - "991-process-exit.ts": 1649, - "992-fs-roundtrip.ts": 2134, - "993-fs-readdir.ts": 2805, - "994-fs-errors.ts": 1790, - "995-fs-uncaught.ts": 2295, - "996-fs-rc-stress.ts": 3230, - "997-fs-modules/main.ts": 2893, - "998-process-env.ts": 1803, - "abstract-property-dispatch.ts": 3619, - "arguments-arrow-capture.mjs": 2943, - "arguments-reexport/main.ts": 2123, - "array-argument-lifetimes-exits.ts": 3367, - "array-argument-lifetimes-mutation.ts": 2372, - "array-argument-lifetimes-strings.ts": 2429, - "array-argument-lifetimes-values.ts": 3148, - "array-buffer-conversions.js": 2274, - "array-buffer-storage.ts": 2433, - "array-checked-callback-results.mjs": 2526, - "array-checked-constructor.js": 3336, - "array-concat-widening.ts": 1977, + "700-classes-basic.ts": 2530, + "701-classes-composition.ts": 2357, + "702-classes-this-capture.ts": 2140, + "703-classes-rc-stress.ts": 2186, + "710-inheritance-basics.ts": 2728, + "711-inheritance-dispatch.ts": 2360, + "712-inheritance-instanceof.ts": 2715, + "713-inheritance-rc-stress.ts": 2448, + "720-accessors-basics.ts": 2562, + "721-accessors-eval-order.ts": 2406, + "722-accessors-inheritance.ts": 2543, + "723-accessors-rc-stress.ts": 2054, + "750-cycle-closure-box.ts": 2227, + "751-cycle-records-mutual.ts": 2118, + "752-cycle-classes.ts": 2207, + "753-cycle-owned-arrays.ts": 2148, + "754-cycle-external-ref.ts": 2118, + "755-cycle-async-promise.ts": 2303, + "756-cycle-inheritance.ts": 2162, + "757-cycle-cross-generation.ts": 2893, + "762-any-boundary.ts": 2310, + "764-any-async.ts": 2553, + "765-any-optional-chain.ts": 2593, + "766-any-union-boundary.ts": 3292, + "767-string-literal-keys.ts": 2238, + "768-any-uninitialized.ts": 2264, + "800-switch-basics.ts": 2244, + "801-switch-lazy-tests.ts": 2610, + "802-switch-loops.ts": 2329, + "803-switch-rc-stress.ts": 2314, + "804-switch-braced-blocks.ts": 2594, + "810-do-while.ts": 2658, + "820-multi-decl.ts": 2315, + "830-let-uninitialized.ts": 2519, + "900-records-basics.ts": 2736, + "901-records-eval-order.ts": 2544, + "902-records-functions-closures.ts": 2645, + "903-records-rc-stress.ts": 2871, + "904-records-optional-fields.ts": 1801, + "905-records-optional-rc-stress.ts": 2425, + "906-records-utility-types.ts": 2878, + "907-records-utility-generics.ts": 2738, + "908-records-index-signatures.ts": 2545, + "909-records-index-json.ts": 2019, + "910-records-index-rc-stress.ts": 1878, + "911-records-index-dot-access.ts": 3510, + "912-unknown-slots.ts": 2427, + "913-records-index-iteration.ts": 3462, + "914-records-from-entries.ts": 3129, + "915-unknown-tostring-eq.ts": 3072, + "916-unknown-bytes.ts": 2767, + "917-record-array-index-dot.ts": 2445, + "950-modules-basic/main.ts": 2473, + "951-modules-diamond/main.ts": 1969, + "952-modules-cross/main.ts": 2427, + "953-modules-default/main.ts": 2409, + "954-modules-reexport/main.ts": 2586, + "957-builtins-namespace.ts": 2102, + "960-generics-basics.ts": 2487, + "961-generics-recursion.ts": 2589, + "962-generics-closures.ts": 2098, + "963-generics-modules/main.ts": 2726, + "964-generics-rc-stress.ts": 2825, + "965-generics-async.ts": 2802, + "965-unions-retag.ts": 2772, + "966-unions-retag-rc-stress.ts": 2336, + "967-record-field-widening.ts": 2097, + "969-unions-arm-matrix.ts": 2419, + "970-unions-basics.ts": 2692, + "971-unions-switch.ts": 2491, + "972-unions-nested.ts": 3069, + "973-unions-rc-stress.ts": 2478, + "974-unions-modules/main.ts": 2052, + "975-unions-undefined.ts": 2811, + "976-unions-null.ts": 2344, + "977-unions-unit-rc-stress.ts": 2013, + "978-unions-nullish.ts": 2330, + "979-unions-optional-chaining.ts": 2341, + "980-exceptions-basics.ts": 1988, + "981-exceptions-values.ts": 2615, + "982-exceptions-rc-stress.ts": 2259, + "983-exceptions-control-flow.ts": 2004, + "984-exceptions-finally.ts": 2140, + "985-exceptions-call-chains.ts": 2787, + "986-exceptions-uncaught.ts": 2529, + "987-exceptions-result-unions.ts": 2390, + "990-process-basics.ts": 2623, + "991-process-exit.ts": 2155, + "992-fs-roundtrip.ts": 2680, + "993-fs-readdir.ts": 2781, + "994-fs-errors.ts": 2322, + "995-fs-uncaught.ts": 2134, + "996-fs-rc-stress.ts": 2214, + "997-fs-modules/main.ts": 2230, + "998-process-env.ts": 2196, + "abstract-property-dispatch.ts": 2956, + "arguments-arrow-capture.mjs": 2802, + "arguments-reexport/main.ts": 2655, + "array-argument-lifetimes-exits.ts": 2164, + "array-argument-lifetimes-mutation.ts": 2547, + "array-argument-lifetimes-strings.ts": 2738, + "array-argument-lifetimes-values.ts": 3081, + "array-buffer-conversions.js": 1978, + "array-buffer-storage.ts": 3147, + "array-checked-callback-results.mjs": 3053, + "array-checked-constructor.js": 3001, + "array-concat-widening.ts": 2947, "array-deque-unshift.ts": 3233, - "array-element-compound-updates.ts": 3547, - "array-fill-unit-values.ts": 2929, - "array-from-checked.js": 3397, - "array-from-value.mjs": 3059, - "array-isarray-value/main.js": 2918, - "array-numeric-own-keys.ts": 2790, - "array-optional-number-write-index.ts": 2704, - "array-primitive-ordering.ts": 4576, + "array-element-compound-updates.ts": 3325, + "array-fill-unit-values.ts": 2281, + "array-from-checked.js": 3228, + "array-from-value.mjs": 2658, + "array-isarray-value/main.js": 2180, + "array-numeric-own-keys.ts": 2770, + "array-optional-number-write-index.ts": 2584, + "array-primitive-ordering.ts": 3806, "array-queue-head-room.ts": 2847, - "array-read-helper-effects.ts": 3311, - "array-refined-storage.ts": 2961, - "array-sort-dense-effects.ts": 4064, - "array-sort-dense-values.ts": 4011, - "array-sort-holes-published.ts": 7513, - "array-sort-runs.ts": 5700, - "array-sort-runtime-comparator.ts": 4830, - "array-sort-unknown-comparator.ts": 3102, - "array-storage-transitions.ts": 3965, - "array-truncate-reuse.ts": 3475, - "async-backend-factory.mjs": 2766, - "async-local-typed-results.ts": 3471, - "atomics-integer-operations.ts": 3518, - "bigint-checked-casts.ts": 3182, - "bigint-checked-storage.js": 3679, - "bigint-union-conversion.ts": 2403, - "boxed-error-rethrows.mjs": 2704, - "buffer-codec-boundaries.ts": 3023, - "buffer-primitive-predicate.ts": 2153, - "builtin-prototype-method-values.mjs": 2713, - "byte-loop-bounds.ts": 3126, - "byte-number-pipeline.ts": 3555, - "byte-record-windows.ts": 3164, - "call-lifetimes-argument-order.ts": 3386, - "call-lifetimes-control-flow.ts": 2774, - "call-lifetimes-owned-boundaries.ts": 2902, - "call-lifetimes-projections.ts": 2603, - "call-lifetimes-union-values.ts": 3045, - "call-lifetimes-virtual-optionals.ts": 2344, - "callable-module-members.mjs": 2928, - "callable-properties.mjs": 2765, - "callable-property-cycles.js": 1847, - "callable-reexport/main.ts": 2222, - "captured-class-refinement.ts": 3000, - "catch-capture.ts": 3112, - "caught-class-identity.ts": 3640, - "caught-standalone-class.ts": 3171, - "caught-system-error-fields.ts": 3152, - "checked-addition.js": 2684, - "checked-any-addition.ts": 2642, - "checked-array-assignment.ts": 2697, - "checked-array-flat/main.ts": 2840, - "checked-bitwise/main.js": 2581, - "checked-builder-cycles.js": 2948, - "checked-byte-storage/main.ts": 2611, - "checked-callback-options.ts": 1643, - "checked-class-descriptors.mjs": 3640, - "checked-class-factory.mjs": 2778, - "checked-collection-iterators.ts": 3241, - "checked-collection-symbol-methods.ts": 2293, - "checked-dispatch-input-lifetimes.js": 2742, - "checked-increment/main.js": 2072, - "checked-inherited-fields.ts": 3028, - "checked-iterator-consumption.js": 3107, - "checked-numeric-arithmetic.js": 2378, - "checked-object-module-alias.js": 2947, - "checked-optional-calls.mjs": 3142, - "checked-promise-recovery.ts": 2855, - "checked-proxy-callback/main.ts": 1847, - "checked-record-constructor.ts": 2481, - "checked-renderer-defaults.js": 2013, - "checked-rest-function-adapters.js": 3046, - "checked-storage-transitions.js": 2689, - "checked-symbol-array.ts": 2459, - "checked-value-input-lifetimes.ts": 3335, - "class-accessor-returned-function.js": 2629, - "class-array-optional-return.ts": 2795, - "class-bracket-method-calls.js": 3486, - "class-brand-overload.js": 2784, - "class-callback-replacement.js": 2660, - "class-callback-storage.ts": 3042, - "class-checked-composites.ts": 3335, - "class-checked-upcast.ts": 3076, - "class-collection-insertion.ts": 2281, - "class-computed-presence.ts": 3266, - "class-computed-symbols.js": 2803, - "class-covariant-returns.ts": 3398, - "class-curried-factory.mjs": 3626, - "class-data-descriptors.js": 3529, - "class-factory-inherited-statics.mjs": 3667, - "class-factory-parameter-base.mjs": 2767, - "class-factory-record-base.mjs": 3407, - "class-factory-recursive-statics.mjs": 3184, - "class-factory-static-members.mjs": 3515, - "class-function-base/main.js": 3746, - "class-instance-constructor.js": 3651, - "class-interface-protocols.ts": 5020, - "class-interface-refinements.ts": 2194, - "class-json-checked.ts": 1821, - "class-local-function-base.mjs": 3398, - "class-method-spreads.ts": 3880, - "class-narrowed-views.ts": 3116, - "class-property-call-values.mjs": 3490, - "class-prototype-data.js": 3512, - "class-prototype-descriptor-copy.mjs": 4571, - "class-specialized-computed-base.mjs": 3883, - "class-static-data.js": 2886, - "class-subclass-assertions.ts": 3020, - "class-super-surplus-spread.mjs": 2209, - "class-symbol-accessors.ts": 2490, - "class-symbol-cache.mjs": 2911, - "class-value-constructor-exceptions.ts": 2697, + "array-read-helper-effects.ts": 3223, + "array-refined-storage.ts": 3132, + "array-sort-dense-effects.ts": 2813, + "array-sort-dense-values.ts": 3705, + "array-sort-holes-published.ts": 6604, + "array-sort-runs.ts": 5713, + "array-sort-runtime-comparator.ts": 5050, + "array-sort-unknown-comparator.ts": 1888, + "array-storage-transitions.ts": 3122, + "array-truncate-reuse.ts": 2475, + "async-backend-factory.mjs": 2638, + "async-local-typed-results.ts": 2579, + "atomics-integer-operations.ts": 3320, + "bigint-checked-casts.ts": 2572, + "bigint-checked-storage.js": 3519, + "bigint-union-conversion.ts": 2774, + "boxed-error-rethrows.mjs": 2034, + "buffer-codec-boundaries.ts": 3206, + "buffer-primitive-predicate.ts": 2712, + "builtin-prototype-method-values.mjs": 3158, + "byte-loop-bounds.ts": 2922, + "byte-number-pipeline.ts": 2738, + "byte-record-windows.ts": 2668, + "call-lifetimes-argument-order.ts": 1933, + "call-lifetimes-control-flow.ts": 2653, + "call-lifetimes-owned-boundaries.ts": 2979, + "call-lifetimes-projections.ts": 3011, + "call-lifetimes-union-values.ts": 2366, + "call-lifetimes-virtual-optionals.ts": 2747, + "callable-module-members.mjs": 2647, + "callable-properties.mjs": 3266, + "callable-property-cycles.js": 2241, + "callable-reexport/main.ts": 2809, + "captured-class-refinement.ts": 2580, + "catch-capture.ts": 2050, + "caught-class-identity.ts": 3173, + "caught-standalone-class.ts": 2858, + "caught-system-error-fields.ts": 2612, + "checked-addition.js": 2460, + "checked-any-addition.ts": 2551, + "checked-array-assignment.ts": 2273, + "checked-array-flat/main.ts": 2256, + "checked-bitwise/main.js": 2560, + "checked-builder-cycles.js": 3055, + "checked-byte-storage/main.ts": 3171, + "checked-callback-options.ts": 2385, + "checked-class-descriptors.mjs": 3021, + "checked-class-factory.mjs": 2266, + "checked-collection-iterators.ts": 2906, + "checked-collection-symbol-methods.ts": 2575, + "checked-dispatch-input-lifetimes.js": 3038, + "checked-increment/main.js": 2332, + "checked-inherited-fields.ts": 2382, + "checked-iterator-consumption.js": 3603, + "checked-numeric-arithmetic.js": 2783, + "checked-object-module-alias.js": 2898, + "checked-optional-calls.mjs": 2763, + "checked-promise-recovery.ts": 2689, + "checked-proxy-callback/main.ts": 2754, + "checked-record-constructor.ts": 2506, + "checked-renderer-defaults.js": 2308, + "checked-rest-function-adapters.js": 2312, + "checked-storage-transitions.js": 2557, + "checked-symbol-array.ts": 1859, + "checked-value-input-lifetimes.ts": 2728, + "class-accessor-returned-function.js": 2068, + "class-array-optional-return.ts": 2589, + "class-bracket-method-calls.js": 2833, + "class-brand-overload.js": 2700, + "class-callback-replacement.js": 3640, + "class-callback-storage.ts": 3803, + "class-checked-composites.ts": 2846, + "class-checked-upcast.ts": 2625, + "class-collection-insertion.ts": 3901, + "class-computed-presence.ts": 3018, + "class-computed-symbols.js": 3495, + "class-covariant-returns.ts": 3069, + "class-curried-factory.mjs": 3062, + "class-data-descriptors.js": 3732, + "class-factory-inherited-statics.mjs": 2710, + "class-factory-parameter-base.mjs": 2492, + "class-factory-record-base.mjs": 4680, + "class-factory-recursive-statics.mjs": 2820, + "class-factory-static-members.mjs": 2990, + "class-function-base/main.js": 2706, + "class-instance-constructor.js": 2628, + "class-interface-protocols.ts": 3911, + "class-interface-refinements.ts": 2967, + "class-json-checked.ts": 2638, + "class-local-function-base.mjs": 2970, + "class-method-spreads.ts": 3142, + "class-narrowed-views.ts": 2862, + "class-property-call-values.mjs": 3343, + "class-prototype-data.js": 3393, + "class-prototype-descriptor-copy.mjs": 3870, + "class-specialized-computed-base.mjs": 3439, + "class-static-data.js": 2153, + "class-subclass-assertions.ts": 2814, + "class-super-surplus-spread.mjs": 2024, + "class-symbol-accessors.ts": 2458, + "class-symbol-cache.mjs": 2883, + "class-value-constructor-exceptions.ts": 2222, "closed-virtual-dispatch-modules/main.ts": 2682, "closed-virtual-dispatch.ts": 3944, - "closure-nullable-union-return.ts": 3308, - "closure-union-locals.ts": 3570, - "collection-array-cycles.ts": 2714, - "collection-array-maps.ts": 3451, - "collection-array-missing.ts": 3109, - "collection-array-sets.ts": 2862, - "collection-copy-identities.ts": 3119, - "collection-data-unions.ts": 3087, - "collection-ingestion-mappers.ts": 3823, - "collection-ingestion-protocol/main.ts": 2461, - "collection-ingestion-references.ts": 3913, - "collection-ingestion.ts": 3524, - "collection-storage-copies.ts": 3595, - "collection-value-keys.ts": 2425, - "compound-field-receivers.ts": 2962, - "compound-presence-guards.ts": 3337, - "conditional-tuple-destructuring.ts": 2631, - "console-imports.cjs": 2257, - "console-native-value.js": 2531, - "const-enum-module-cycle/main.ts": 2437, - "constant-callback-dispatch.ts": 2800, - "constant-module-globals/main.ts": 3036, - "constant-number-remainders.ts": 2724, - "constructed-class-dispatch.ts": 3005, - "contextual-array-union-write.ts": 6554, - "contextual-return-layouts.ts": 2859, - "counted-loop-numbers.ts": 2703, - "counted-loop-storage.ts": 2473, - "crypto-hash-optional-input.ts": 3036, - "cycle-generations-long-lived.ts": 2902, - "cycle-growth-yield.ts": 3252, - "date-checked-native.js": 2177, - "declared-index-spread.ts": 3543, - "deep-reference-teardown.ts": 2409, - "default-undefined-parameters.ts": 3171, - "deferred-field-updates.ts": 2290, - "deferred-registry-many.ts": 3267, - "derived-numeric-updates.ts": 2762, - "destructure-call-assignment.js": 2259, - "destructure-inferred-row-defaults.js": 2953, - "destructure-union-arrays.ts": 3202, - "dynamic-function-descriptors.js": 2214, - "error-cause-writes.js": 3441, - "error-inherited-message.mjs": 3449, - "error-inherited-name.mjs": 2955, - "error-property-writes.mjs": 2326, - "error-prototype-tostring.js": 2596, - "error-stack-frames.ts": 2880, - "error-stack-limit.ts": 2871, - "error-tostring-overrides.ts": 2481, - "error-values-inspect.ts": 2856, - "exact-index-round-trip.ts": 3660, - "expression-runtime-values.ts": 2159, - "fiber-switch-stress.ts": 2800, - "fiberless-async-ordering.ts": 3075, - "fiberless-async-unhandled.ts": 2437, - "field-assignment-values.ts": 2878, - "file-handle-values.ts": 2035, - "file-read-storage.ts": 2737, - "file-url-percent-decoding.ts": 2029, - "final-field-borrows.ts": 3105, - "for-multiple-bindings.ts": 2994, - "for-multiple-lexical-bindings.ts": 2863, - "for-of-checked-iterator.js": 3515, - "for-of-subclass-elements.ts": 2469, - "forward-generic-signatures.ts": 3287, - "fresh-array-union-layout.js": 2961, - "frozen-checked-dictionaries.mjs": 3021, - "fs-native-realpath.ts": 3263, + "closure-nullable-union-return.ts": 2472, + "closure-union-locals.ts": 2465, + "collection-array-cycles.ts": 2552, + "collection-array-maps.ts": 3481, + "collection-array-missing.ts": 2873, + "collection-array-sets.ts": 3383, + "collection-copy-identities.ts": 2585, + "collection-data-unions.ts": 2565, + "collection-ingestion-mappers.ts": 3262, + "collection-ingestion-protocol/main.ts": 3814, + "collection-ingestion-references.ts": 3375, + "collection-ingestion.ts": 3053, + "collection-storage-copies.ts": 3096, + "collection-value-keys.ts": 3176, + "compound-field-receivers.ts": 2272, + "compound-presence-guards.ts": 3094, + "conditional-tuple-destructuring.ts": 2487, + "console-imports.cjs": 2314, + "console-native-value.js": 2165, + "const-enum-module-cycle/main.ts": 2618, + "constant-callback-dispatch.ts": 2539, + "constant-module-globals/main.ts": 2455, + "constant-number-remainders.ts": 2350, + "constructed-class-dispatch.ts": 3014, + "contextual-array-union-write.ts": 5379, + "contextual-return-layouts.ts": 2919, + "counted-loop-numbers.ts": 2515, + "counted-loop-storage.ts": 2556, + "crypto-hash-optional-input.ts": 2860, + "cycle-generations-long-lived.ts": 2691, + "cycle-growth-yield.ts": 2929, + "date-checked-native.js": 2323, + "declared-index-spread.ts": 2660, + "deep-reference-teardown.ts": 3136, + "default-undefined-parameters.ts": 2589, + "deferred-field-updates.ts": 2347, + "deferred-registry-many.ts": 2661, + "derived-numeric-updates.ts": 1907, + "destructure-call-assignment.js": 2267, + "destructure-inferred-row-defaults.js": 2538, + "destructure-union-arrays.ts": 2379, + "dynamic-function-descriptors.js": 2763, + "error-cause-writes.js": 2954, + "error-inherited-message.mjs": 2631, + "error-inherited-name.mjs": 2285, + "error-property-writes.mjs": 2636, + "error-prototype-tostring.js": 3155, + "error-stack-frames.ts": 2206, + "error-stack-limit.ts": 2510, + "error-tostring-overrides.ts": 2305, + "error-values-inspect.ts": 2398, + "exact-index-round-trip.ts": 2801, + "expression-runtime-values.ts": 2027, + "fiber-switch-stress.ts": 2898, + "fiberless-async-ordering.ts": 2908, + "fiberless-async-unhandled.ts": 2133, + "field-assignment-values.ts": 2107, + "file-handle-values.ts": 2357, + "file-read-storage.ts": 2439, + "file-url-percent-decoding.ts": 2222, + "final-field-borrows.ts": 2890, + "for-multiple-bindings.ts": 2286, + "for-multiple-lexical-bindings.ts": 2283, + "for-of-checked-iterator.js": 3511, + "for-of-subclass-elements.ts": 2219, + "forward-generic-signatures.ts": 2294, + "fresh-array-union-layout.js": 2480, + "frozen-checked-dictionaries.mjs": 2629, + "fs-native-realpath.ts": 2351, "fs-null-byte-paths-js.cjs": 2762, "fs-null-byte-paths.ts": 3411, - "fs-read-encodings.ts": 3220, + "fs-read-encodings.ts": 2505, "fs-read-utf8-edges.ts": 3246, "fs-read-utf8-handle-forms.ts": 3163, - "fs-remove-readonly.ts": 2468, - "fs-write-string-bytes-union.ts": 2571, - "function-apply-value.mjs": 2118, - "function-constructor-global.mjs": 2459, - "function-constructor-kinds/main.js": 2510, - "function-custom-prototype.js": 3445, - "function-custom-to-string.mjs": 3088, - "function-object-assign.js": 2894, - "function-own-prototype/main.js": 2937, - "generator-checked-protocol.ts": 3202, - "generator-checked-return.js": 2917, - "generator-custom-delegation/main.ts": 5180, - "generator-default-return-pattern.ts": 2163, - "generator-delegation-values.ts": 2121, - "generator-inferred-date.js": 1700, - "generator-mixed-checked-channels.ts": 3203, - "generator-untyped-consumer/main.ts": 3571, - "generic-base-specializations.ts": 2610, - "generic-binding-ownership.ts": 3653, - "generic-class-js-functions/main.ts": 2631, - "generic-class-recovery.ts": 3190, - "generic-namespace-factories/main.ts": 2712, - "generic-nullable-collections.ts": 2692, - "generic-pattern-bindings.ts": 2004, - "generic-record-index.ts": 2705, - "generic-visitor-void.ts": 2865, + "fs-remove-readonly.ts": 2354, + "fs-write-string-bytes-union.ts": 2286, + "function-apply-value.mjs": 2558, + "function-constructor-global.mjs": 1848, + "function-constructor-kinds/main.js": 2532, + "function-custom-prototype.js": 2604, + "function-custom-to-string.mjs": 2607, + "function-object-assign.js": 2509, + "function-own-prototype/main.js": 2423, + "generator-checked-protocol.ts": 2631, + "generator-checked-return.js": 2326, + "generator-custom-delegation/main.ts": 3343, + "generator-default-return-pattern.ts": 2653, + "generator-delegation-values.ts": 2368, + "generator-inferred-date.js": 2465, + "generator-mixed-checked-channels.ts": 2662, + "generator-untyped-consumer/main.ts": 2958, + "generic-base-specializations.ts": 2073, + "generic-binding-ownership.ts": 2817, + "generic-class-js-functions/main.ts": 2051, + "generic-class-recovery.ts": 2415, + "generic-namespace-factories/main.ts": 2073, + "generic-nullable-collections.ts": 2677, + "generic-pattern-bindings.ts": 2698, + "generic-record-index.ts": 2753, + "generic-visitor-void.ts": 2405, "global-accumulator-loops.ts": 3053, - "global-error-subclasses.ts": 2690, - "global-runtime-probes.js": 1976, - "global-stored-probes.js": 2924, - "global-string-cache/main.js": 2572, - "global-symbol-cache/main.js": 2380, - "guarded-native-iterables.ts": 2466, - "heap-input-aliases.ts": 2784, - "heap-input-collections.ts": 3100, - "in-array-runtime-index.ts": 3210, - "indexed-assignment-values.js": 3521, - "indexed-assignment-values.ts": 2224, - "indexed-element-field-reads.ts": 2611, - "inferred-array-assignment-values.mjs": 2976, - "inferred-class-default.mjs": 2564, - "inferred-compound-values.mjs": 2110, - "inferred-conditional-class.mjs": 2584, - "inferred-error-fields.js": 2163, - "inferred-map-patterns.mjs": 2233, - "inferred-method-override.js": 2516, - "inferred-partial-destructuring.mjs": 2158, - "inferred-primitive-properties.mjs": 2508, - "inferred-record-return.mjs": 2099, - "inferred-recursive-record.mjs": 2183, - "inferred-undefined-field.mjs": 3012, - "input-lifetime-intervals.ts": 3244, - "input-lifetimes-modules/main.ts": 2793, - "instanceof-class-record-union.ts": 2242, - "integer-flow-arithmetic.ts": 3060, - "integer-loop-forms.ts": 2872, - "integer-view-control.ts": 2400, - "integer-view-numbers.ts": 2753, - "integer-view-storage.ts": 2545, - "intl-grapheme-conformance/main.ts": 4747, - "intl-grapheme.ts": 2345, - "iterator-typed-returns.ts": 3833, - "js-abort-portable.js": 2996, - "js-array-constructor.js": 3177, - "js-array-default-buffer.js": 2796, - "js-array-iterators.js": 3414, - "js-arrow-bind.cjs": 4772, - "js-buffer-callback-brand.cjs": 2001, - "js-callable-proxy.js": 3739, - "js-chained-native-results.mjs": 2683, - "js-checked-array-iterator.js": 2865, - "js-checked-array-reference.js": 3607, - "js-checked-number-negation.mjs": 2731, - "js-checked-sort-result.js": 2328, - "js-child-error-listener.cjs": 2751, - "js-cjs-callable-snapshots/main.cjs": 2946, - "js-class-added-parameters.js": 2228, - "js-class-checked-overrides.js": 2130, - "js-class-computed-fields.js": 2657, - "js-class-enumeration.js": 2642, - "js-class-field-accessor-override.js": 2687, - "js-class-fluent-overrides.js": 2370, - "js-class-late-method-values.js": 3690, - "js-class-member-dispatch.js": 3108, - "js-class-return-shapes.js": 3149, - "js-class-shadowed-methods.js": 3491, - "js-class-stored-method-receiver.js": 2218, - "js-class-subclass-properties.js": 4610, - "js-class-symbol-spread.cjs": 2295, - "js-computed-prototype-additions.js": 3232, - "js-constructor-returned-callable.js": 2404, - "js-constructor-spread.js": 3538, - "js-dataview-dispatch.js": 3187, - "js-declared-fields.cjs": 4825, - "js-default-listener-arguments.cjs": 1767, - "js-default-options/main.ts": 3097, - "js-deferred-field-initializers.js": 1977, - "js-deferred-registry-effects.js": 2772, - "js-derived-constructor-hoisting.js": 2288, - "js-dormant-array-write.js": 2420, - "js-dormant-overrides.js": 2890, - "js-expando-records.js": 2867, - "js-implicit-call-results.js": 2946, - "js-inferred-callback-exports/main.js": 4147, - "js-inferred-class-array-return.js": 3209, - "js-inferred-object-values.js": 2234, - "js-inherited-field-storage.js": 2161, - "js-inherited-parameter-abi.js": 2457, - "js-iterable-spread.js": 3088, - "js-loose-dynamic-primitives.js": 2797, - "js-map-object-seeds.js": 3253, - "js-member-increment.js": 3027, - "js-module-function-values.js": 3358, - "js-mutable-null-members.js": 2588, - "js-nested-native-descriptors.js": 2862, - "js-normalize-dispatch.js": 3006, - "js-nullish-inherited-fields.mjs": 2812, - "js-object-receiver-storage.js": 2500, - "js-object-returning-constructors.mjs": 2542, - "js-object-shared-arrays.js": 2369, - "js-omitted-typed-arguments.js": 2596, - "js-open-binding-writes.js": 2909, - "js-optional-class-fields.js": 3469, - "js-optional-member-call.js": 3126, - "js-primitive-union-addition.js": 2730, - "js-promise-all-values.js": 3561, - "js-promise-catch-handler.js": 2902, - "js-promise-finally-order.js": 2511, - "js-promise-pending-reactions.js": 2712, - "js-prototype-host-boundary.js": 2617, - "js-reflect-receivers.js": 3341, - "js-regex-record-captures.js": 3157, - "js-scalar-iterables.js": 3299, - "js-shared-method-dispatch.js": 3057, - "js-specialized-field-method.js": 2254, - "js-static-accessors.js": 3374, - "js-static-method-values.js": 3629, - "js-static-registries.cjs": 3164, - "js-super-accessor-initialization.js": 2332, - "js-uninitialized-native-fields.js": 2069, - "json-guarded-map-values.ts": 3048, - "json-output-bulk.ts": 1978, - "json-runtime-options.mjs": 3034, - "json-stringify-value.js": 2308, - "json-typed-parse-direct.ts": 2696, + "global-error-subclasses.ts": 1773, + "global-runtime-probes.js": 2288, + "global-stored-probes.js": 2726, + "global-string-cache/main.js": 1889, + "global-symbol-cache/main.js": 3399, + "guarded-native-iterables.ts": 2496, + "heap-input-aliases.ts": 2746, + "heap-input-collections.ts": 2558, + "in-array-runtime-index.ts": 2579, + "indexed-assignment-values.js": 2971, + "indexed-assignment-values.ts": 1852, + "indexed-element-field-reads.ts": 2452, + "inferred-array-assignment-values.mjs": 2352, + "inferred-class-default.mjs": 2460, + "inferred-compound-values.mjs": 2473, + "inferred-conditional-class.mjs": 2635, + "inferred-error-fields.js": 2509, + "inferred-map-patterns.mjs": 2353, + "inferred-method-override.js": 2137, + "inferred-partial-destructuring.mjs": 2205, + "inferred-primitive-properties.mjs": 2135, + "inferred-record-return.mjs": 1793, + "inferred-recursive-record.mjs": 1833, + "inferred-undefined-field.mjs": 1777, + "input-lifetime-intervals.ts": 2714, + "input-lifetimes-modules/main.ts": 3258, + "instanceof-class-record-union.ts": 2400, + "integer-flow-arithmetic.ts": 3652, + "integer-loop-forms.ts": 2368, + "integer-view-control.ts": 1809, + "integer-view-numbers.ts": 2394, + "integer-view-storage.ts": 2439, + "intl-grapheme-conformance/main.ts": 3718, + "intl-grapheme.ts": 2449, + "iterator-typed-returns.ts": 3400, + "js-abort-portable.js": 2829, + "js-array-constructor.js": 3163, + "js-array-default-buffer.js": 2537, + "js-array-iterators.js": 2559, + "js-arrow-bind.cjs": 3343, + "js-buffer-callback-brand.cjs": 2262, + "js-builder-string-method-names/main.ts": 4550, + "js-callable-builder.js": 4500, + "js-callable-proxy.js": 3516, + "js-chained-native-results.mjs": 2641, + "js-checked-array-iterator.js": 2670, + "js-checked-array-reference.js": 2270, + "js-checked-number-negation.mjs": 1915, + "js-checked-sort-result.js": 2373, + "js-child-error-listener.cjs": 2357, + "js-cjs-callable-snapshots/main.cjs": 1981, + "js-class-added-parameters.js": 2472, + "js-class-checked-overrides.js": 2571, + "js-class-computed-fields.js": 1830, + "js-class-constructor-returns/main.ts": 4350, + "js-class-enumeration.js": 3296, + "js-class-field-accessor-override.js": 2567, + "js-class-fluent-overrides.js": 2822, + "js-class-late-method-values.js": 2309, + "js-class-member-dispatch.js": 3016, + "js-class-return-shapes.js": 2231, + "js-class-shadowed-methods.js": 2942, + "js-class-stored-method-receiver.js": 2382, + "js-class-subclass-properties.js": 3695, + "js-class-symbol-spread.cjs": 2704, + "js-computed-prototype-additions.js": 3142, + "js-constructor-returned-callable.js": 2605, + "js-constructor-spread.js": 2289, + "js-dataview-dispatch.js": 2273, + "js-declared-fields.cjs": 3263, + "js-default-listener-arguments.cjs": 2549, + "js-default-options/main.ts": 3044, + "js-deferred-field-initializers.js": 2121, + "js-deferred-registry-effects.js": 2381, + "js-derived-constructor-hoisting.js": 1805, + "js-dormant-array-write.js": 1888, + "js-dormant-overrides.js": 2569, + "js-expando-records.js": 2454, + "js-function-prototype-value.js": 3650, + "js-implicit-call-results.js": 3064, + "js-inferred-callback-exports/main.js": 3830, + "js-inferred-class-array-return.js": 2570, + "js-inferred-object-values.js": 2380, + "js-inherited-field-storage.js": 3121, + "js-inherited-parameter-abi.js": 2210, + "js-iterable-spread.js": 2950, + "js-loose-dynamic-primitives.js": 1960, + "js-map-object-seeds.js": 2610, + "js-member-increment.js": 2926, + "js-module-function-values.js": 2014, + "js-mutable-null-members.js": 2370, + "js-nested-native-descriptors.js": 2412, + "js-normalize-dispatch.js": 2793, + "js-nullish-inherited-fields.mjs": 2710, + "js-number-parse-dynamic.js": 2700, + "js-object-receiver-storage.js": 2613, + "js-object-returning-constructors.mjs": 2186, + "js-object-shared-arrays.js": 2465, + "js-omitted-typed-arguments.js": 2236, + "js-open-binding-writes.js": 1787, + "js-optional-class-fields.js": 2266, + "js-optional-member-call.js": 1883, + "js-primitive-union-addition.js": 2256, + "js-process-destructure.mjs": 4750, + "js-promise-all-values.js": 3079, + "js-promise-catch-handler.js": 1749, + "js-promise-finally-order.js": 1913, + "js-promise-pending-reactions.js": 2644, + "js-prototype-host-boundary.js": 2224, + "js-reflect-receivers.js": 3119, + "js-regex-record-captures.js": 2010, + "js-reshaped-object-literal.js": 5700, + "js-scalar-iterables.js": 2477, + "js-shared-method-dispatch.js": 2033, + "js-specialized-field-method.js": 2335, + "js-static-accessors.js": 2520, + "js-static-method-values.js": 2194, + "js-static-registries.cjs": 2703, + "js-super-accessor-initialization.js": 2100, + "js-uninitialized-native-fields.js": 2180, + "json-guarded-map-values.ts": 2374, + "json-output-bulk.ts": 2827, + "json-runtime-options.mjs": 1997, + "json-stringify-value.js": 2563, + "json-typed-parse-direct.ts": 2355, "json-typed-parse-index-signatures.ts": 3686, "json-typed-parse-optional-members.ts": 3044, "json-typed-parse-union-members.ts": 3090, - "literal-switch-dispatch.ts": 2612, - "live-reference-shared-converters.ts": 3144, - "llvm-read-receiver-lifetime.ts": 1978, - "local-class-call-spreads.js": 1989, - "local-class-declaration.ts": 1927, - "local-class-evaluation.ts": 2816, - "local-class-inheritance.ts": 2647, - "local-class-lifetimes.ts": 3188, - "local-class-namespace/main.js": 3542, - "local-class-prototype-data.js": 2714, - "local-class-specialization.js": 2650, - "local-class-unknown.ts": 2915, - "local-class-values.ts": 2331, - "local-union-storage.ts": 2638, - "locale-compare-root-order.ts": 3001, - "logical-assignment-dynamic.js": 3172, - "logical-assignment-values.ts": 2043, - "logical-runtime-optional-record.ts": 2200, - "loop-reference-lifetimes.ts": 2559, - "map-checked-boundary/main.ts": 2442, - "map-checked-seed.js": 2756, + "literal-switch-dispatch.ts": 2500, + "live-reference-shared-converters.ts": 2552, + "llvm-read-receiver-lifetime.ts": 2343, + "local-class-call-spreads.js": 3208, + "local-class-declaration.ts": 2486, + "local-class-evaluation.ts": 2605, + "local-class-inheritance.ts": 2327, + "local-class-lifetimes.ts": 2376, + "local-class-namespace/main.js": 2940, + "local-class-prototype-data.js": 2781, + "local-class-specialization.js": 2399, + "local-class-unknown.ts": 2443, + "local-class-values.ts": 1784, + "local-union-storage.ts": 2967, + "locale-compare-root-order.ts": 2518, + "logical-assignment-dynamic.js": 2592, + "logical-assignment-values.ts": 2497, + "logical-runtime-optional-record.ts": 2944, + "loop-reference-lifetimes.ts": 2542, + "map-checked-boundary/main.ts": 2629, + "map-checked-seed.js": 3013, "map-get-set-fusion.ts": 3284, - "map-number-keys-dense.ts": 2972, - "map-read-lifetimes-exits.ts": 2860, - "map-read-lifetimes.ts": 2905, - "map-seeds-and-spreads.ts": 2984, - "map-typed-array-values.ts": 2649, - "math-function-values.js": 2638, - "missing-read-lambda-results.ts": 2850, - "missing-read-narrowed-storage.ts": 3077, - "missing-read-number-conversions.ts": 3015, - "module-byte-loops.ts": 2315, - "module-fallback-functions/main.js": 2716, - "narrowed-nullish-values.ts": 2405, - "native-any-timer-callback.ts": 2380, - "native-array-borrowed-find-last.js": 2591, - "native-array-borrowed-slice.js": 2966, - "native-array-copying-methods.js": 2605, - "native-array-fill-copywithin.js": 2662, - "native-array-frozen-noops.js": 2568, - "native-array-index-boundaries.js": 2581, - "native-array-integrity.js": 3066, - "native-array-length.js": 3005, - "native-array-named-properties.js": 2812, - "native-array-prototype/main.js": 3103, - "native-array-read-lifetimes.ts": 2912, - "native-array-reduce-find-last.js": 2732, - "native-array-search-from-index.js": 2720, - "native-array-splice-coercion.js": 1769, - "native-array-splice-flat.js": 2701, - "native-buffer-coercion.js": 2837, - "native-callback-dispatch.ts": 3750, - "native-class-array-boundaries.ts": 3033, - "native-class-cache.js": 3922, - "native-class-properties.cjs": 5335, - "native-class-property-cycles.cjs": 2421, - "native-class-property-order.cjs": 2798, - "native-class-type-predicates.ts": 2523, - "native-factory-records.js": 2515, - "native-method-values.js": 4031, - "native-method-values.ts": 2347, - "native-npm-imports/main.ts": 3454, - "native-object-descriptors.js": 1755, - "native-object-for-in-minimal.js": 2603, - "native-object-property-attributes.js": 3035, - "native-object-prototype.js": 2445, - "native-property-names.ts": 2425, - "native-proxy-env.js": 3704, - "native-worker-arena-reuse.ts": 6858, - "native-worker-bounded-errors.ts": 2058, - "native-worker-buffer-consumers.ts": 3068, - "native-worker-cancel-hot.ts": 2722, - "native-worker-class-fields.ts": 2782, - "native-worker-clone-errors.ts": 2690, - "native-worker-commonjs.cjs": 3412, - "native-worker-delayed-messages.ts": 2375, - "native-worker-discarded-heaps.ts": 5717, - "native-worker-environment.ts": 2804, - "native-worker-error.ts": 2211, - "native-worker-exception-state.ts": 4167, - "native-worker-exit-listeners.ts": 2523, - "native-worker-io.ts": 3345, - "native-worker-loop-cancellation.ts": 2510, - "native-worker-message-graphs.ts": 2419, - "native-worker-messages.ts": 2757, - "native-worker-poll-exceptions.ts": 3061, - "native-worker-port-lifetime.ts": 2699, - "native-worker-process-exit.ts": 2130, - "native-worker-publish-classes.ts": 3636, - "native-worker-publish-refusals.ts": 2020, - "native-worker-published-graphs.ts": 2461, - "native-worker-references.ts": 2598, - "native-worker-roots/main.ts": 3212, - "native-worker-shared-views.ts": 2802, - "native-worker-stack-overflow.ts": 2946, - "native-worker-terminate-exception-state.ts": 3847, - "native-worker-terminate-loop.ts": 2735, - "native-worker-terminate-recursion.ts": 4636, - "native-worker-terminate-suspended.ts": 2692, - "native-worker-terminate-tested-loops.ts": 3271, - "native-worker-terminate-wait.ts": 2775, - "native-worker-typed-arrays.ts": 3254, - "nested-map-cycles.ts": 2753, - "nested-map-values.ts": 4785, - "never-returning-calls.ts": 2228, - "next-tick-commonjs-entry.cjs": 1929, - "node24-buffer-encoding-errors.ts": 2283, - "node24-buffer-encoding.ts": 2691, - "node24-crypto-kdf-errors.ts": 3129, - "node24-crypto-kdf-options.ts": 3852, - "node24-crypto-kdf.ts": 3936, - "node24-crypto-sha2.ts": 1860, - "node24-deep-equality-properties.js": 2441, - "node24-deep-equality.cjs": 2912, - "node24-deep-equality.ts": 3378, - "node24-env-files-errors.ts": 2760, - "node24-env-files.ts": 2643, - "node24-env-imports.cjs": 1749, - "node24-env-parse-errors.ts": 2987, - "node24-env-parse.ts": 1797, - "node24-esm-metadata/main.mjs": 2385, - "node24-file-url-buffer.ts": 2665, - "node24-file-url-errors.js": 3394, - "node24-file-url-options.ts": 3117, - "node24-fs-links-callbacks.cjs": 2182, - "node24-fs-links-errors.cjs": 2221, - "node24-fs-links-options.cjs": 3438, - "node24-fs-links-promise-errors.cjs": 1752, - "node24-fs-links-promises.ts": 2960, - "node24-fs-links.ts": 3132, - "node24-fs-statfs-callbacks.cjs": 2404, - "node24-fs-statfs-errors.cjs": 3053, - "node24-fs-statfs-options.cjs": 3275, - "node24-fs-statfs.ts": 2771, - "node24-fs-timestamps-callbacks.cjs": 3442, - "node24-fs-timestamps-errors.cjs": 2214, - "node24-fs-timestamps-promises.ts": 2905, - "node24-fs-timestamps-symlinks.ts": 2911, - "node24-fs-timestamps.ts": 2652, - "node24-no-error-assertions-coercion.js": 3450, - "node24-no-error-assertions.cjs": 2131, - "node24-no-error-assertions.ts": 3704, - "node24-parseargs.js": 3975, - "node24-string-decoder.ts": 1840, - "node24-style-text-environment.js": 1777, - "node24-style-text-validation.js": 2850, - "node24-style-text.cjs": 2428, - "node24-style-text.ts": 2934, - "node24-system-error-validation.js": 2301, - "node24-system-errors.cjs": 2559, - "node24-system-errors.ts": 2989, - "node24-text-codec-properties.ts": 3210, - "node24-text-encode-into.ts": 2657, - "node24-text-utilities-coercion.js": 2506, - "node24-text-utilities-validation.js": 3129, - "node24-text-utilities.cjs": 2550, - "node24-text-utilities.ts": 2610, - "node24-url-authority-coercion.js": 3075, - "node24-url-authority.ts": 2397, - "node24-url-factories.ts": 3132, - "node24-url-factory-errors.ts": 2346, - "node24-url-mutation-coercion.js": 2926, - "node24-url-mutation.ts": 2845, - "node24-util-types.cjs": 2459, - "node24-util-types.js": 2601, - "node24-util-types.ts": 3126, - "non-null-class-iteration.ts": 1674, - "nonnull-element-arguments.ts": 2593, - "nonnull-forwarded-class-values.ts": 1775, - "nullable-object-extension.mjs": 1502, - "nullish-asserted-class-arms.ts": 2652, - "nullish-assignment-values.ts": 2755, - "nullish-long-chain.ts": 3588, - "number-parse-statics.ts": 2229, - "number-predicates-unknown.ts": 2605, - "numeric-call-specialization.ts": 1690, - "object-enumeration-array-reads.ts": 3043, - "object-from-checked-entries.js": 3900, - "object-inherited-to-string.js": 1733, - "object-key-indexes.js": 3227, - "object-prototype-identity.mjs": 2689, - "object-reexport/main.js": 2801, - "object-spread-computed.ts": 2239, - "opentui-byte-queue.js": 3379, - "optional-callback-arity.ts": 1977, - "optional-class-flows.ts": 2120, - "optional-element-defaults.ts": 2378, - "optional-flag-comparisons.ts": 2194, - "optional-native-callables.js": 2420, - "optional-node-list-iteration.ts": 2425, - "optional-string-index/main.ts": 2629, - "path-to-file-url-options.ts": 1964, - "performance-presence.ts": 2369, - "primitive-and-function-descriptors.js": 2715, - "primitive-union-string.ts": 2231, - "process-builtin-values.js": 3831, - "process-constrained-memory.ts": 2154, - "process-env-computed-keys.js": 2619, - "process-hrtime.js": 2376, - "process-named-signals.cjs": 2024, - "process-uncaught-handler-throws.cjs": 2023, - "process-uncaught-loop.cjs": 1789, - "process-uncaught-module.mjs": 1660, - "process-uncaught-monitor.cjs": 2359, - "process-uncaught-rejection.cjs": 2287, - "process-uncaught-sync.cjs": 2104, - "process-version-pin.ts": 2000, - "process-versions-storage.ts": 2763, - "projected-collection-lifetimes.ts": 2478, - "promise-checked-rejections.ts": 2584, - "promise-resolve-void.ts": 1939, - "prototype-method-overrides.mjs": 5633, - "prototype-named-data-records.ts": 2571, + "map-number-keys-dense.ts": 2562, + "map-read-lifetimes-exits.ts": 2227, + "map-read-lifetimes.ts": 2725, + "map-seeds-and-spreads.ts": 2719, + "map-typed-array-values.ts": 2850, + "math-function-values.js": 2367, + "missing-read-lambda-results.ts": 2379, + "missing-read-narrowed-storage.ts": 2498, + "missing-read-number-conversions.ts": 2181, + "module-byte-loops.ts": 2636, + "module-fallback-functions/main.js": 2148, + "narrowed-nullish-values.ts": 2410, + "native-any-timer-callback.ts": 1834, + "native-array-borrowed-find-last.js": 2515, + "native-array-borrowed-slice.js": 2404, + "native-array-copying-methods.js": 2076, + "native-array-fill-copywithin.js": 2636, + "native-array-frozen-noops.js": 2476, + "native-array-index-boundaries.js": 1913, + "native-array-integrity.js": 2429, + "native-array-length.js": 2568, + "native-array-named-properties.js": 2390, + "native-array-prototype/main.js": 2161, + "native-array-read-lifetimes.ts": 2771, + "native-array-reduce-find-last.js": 2375, + "native-array-search-from-index.js": 1823, + "native-array-splice-coercion.js": 2296, + "native-array-splice-flat.js": 1933, + "native-buffer-coercion.js": 2389, + "native-callback-dispatch.ts": 3007, + "native-class-array-boundaries.ts": 2676, + "native-class-cache.js": 3391, + "native-class-properties.cjs": 3541, + "native-class-property-cycles.cjs": 2291, + "native-class-property-order.cjs": 1867, + "native-class-type-predicates.ts": 2386, + "native-factory-records.js": 2851, + "native-method-values.js": 2903, + "native-method-values.ts": 2495, + "native-npm-imports/main.ts": 2716, + "native-object-descriptors.js": 2717, + "native-object-for-in-minimal.js": 2536, + "native-object-property-attributes.js": 3149, + "native-object-prototype.js": 3180, + "native-property-names.ts": 1827, + "native-proxy-env.js": 3519, + "native-worker-arena-reuse.ts": 4699, + "native-worker-bounded-errors.ts": 2268, + "native-worker-buffer-consumers.ts": 2531, + "native-worker-cancel-hot.ts": 2446, + "native-worker-class-fields.ts": 2650, + "native-worker-clone-errors.ts": 2347, + "native-worker-commonjs.cjs": 2188, + "native-worker-delayed-messages.ts": 3114, + "native-worker-discarded-heaps.ts": 4430, + "native-worker-environment.ts": 3538, + "native-worker-error.ts": 2810, + "native-worker-exception-state.ts": 3938, + "native-worker-exit-listeners.ts": 2965, + "native-worker-io.ts": 3018, + "native-worker-loop-cancellation.ts": 2773, + "native-worker-message-graphs.ts": 2440, + "native-worker-messages.ts": 2911, + "native-worker-poll-exceptions.ts": 2706, + "native-worker-port-lifetime.ts": 3175, + "native-worker-process-exit.ts": 2168, + "native-worker-publish-classes.ts": 2797, + "native-worker-publish-refusals.ts": 2330, + "native-worker-published-graphs.ts": 3411, + "native-worker-references.ts": 2156, + "native-worker-roots/main.ts": 2962, + "native-worker-shared-views.ts": 2377, + "native-worker-stack-overflow.ts": 2443, + "native-worker-terminate-exception-state.ts": 3368, + "native-worker-terminate-loop.ts": 1929, + "native-worker-terminate-recursion.ts": 2935, + "native-worker-terminate-suspended.ts": 2843, + "native-worker-terminate-tested-loops.ts": 3082, + "native-worker-terminate-wait.ts": 2267, + "native-worker-typed-arrays.ts": 2361, + "nested-map-cycles.ts": 2306, + "nested-map-values.ts": 2038, + "never-returning-calls.ts": 2680, + "next-tick-commonjs-entry.cjs": 1924, + "node24-buffer-encoding-errors.ts": 2742, + "node24-buffer-encoding.ts": 2822, + "node24-crypto-kdf-errors.ts": 2607, + "node24-crypto-kdf-options.ts": 1925, + "node24-crypto-kdf.ts": 3401, + "node24-crypto-sha2.ts": 2336, + "node24-deep-equality-properties.js": 2551, + "node24-deep-equality.cjs": 2373, + "node24-deep-equality.ts": 3193, + "node24-env-files-errors.ts": 2555, + "node24-env-files.ts": 2556, + "node24-env-imports.cjs": 2518, + "node24-env-parse-errors.ts": 2083, + "node24-env-parse.ts": 2189, + "node24-esm-metadata/main.mjs": 2257, + "node24-file-url-buffer.ts": 1904, + "node24-file-url-errors.js": 2838, + "node24-file-url-options.ts": 2563, + "node24-fs-links-callbacks.cjs": 2964, + "node24-fs-links-errors.cjs": 2795, + "node24-fs-links-options.cjs": 3096, + "node24-fs-links-promise-errors.cjs": 2481, + "node24-fs-links-promises.ts": 2014, + "node24-fs-links.ts": 3060, + "node24-fs-statfs-callbacks.cjs": 2761, + "node24-fs-statfs-errors.cjs": 3068, + "node24-fs-statfs-options.cjs": 2927, + "node24-fs-statfs.ts": 2192, + "node24-fs-timestamps-callbacks.cjs": 2865, + "node24-fs-timestamps-errors.cjs": 2733, + "node24-fs-timestamps-promises.ts": 2476, + "node24-fs-timestamps-symlinks.ts": 2406, + "node24-fs-timestamps.ts": 2758, + "node24-no-error-assertions-coercion.js": 2950, + "node24-no-error-assertions.cjs": 2361, + "node24-no-error-assertions.ts": 2895, + "node24-parseargs.js": 3512, + "node24-string-decoder.ts": 2569, + "node24-style-text-environment.js": 2370, + "node24-style-text-validation.js": 2999, + "node24-style-text.cjs": 1883, + "node24-style-text.ts": 2102, + "node24-system-error-validation.js": 2003, + "node24-system-errors.cjs": 2247, + "node24-system-errors.ts": 2302, + "node24-text-codec-properties.ts": 2178, + "node24-text-encode-into.ts": 2427, + "node24-text-utilities-coercion.js": 2867, + "node24-text-utilities-validation.js": 1874, + "node24-text-utilities.cjs": 2132, + "node24-text-utilities.ts": 2215, + "node24-url-authority-coercion.js": 2529, + "node24-url-authority.ts": 2720, + "node24-url-factories.ts": 2586, + "node24-url-factory-errors.ts": 1931, + "node24-url-mutation-coercion.js": 2518, + "node24-url-mutation.ts": 2194, + "node24-util-types.cjs": 3057, + "node24-util-types.js": 1900, + "node24-util-types.ts": 2935, + "non-null-class-iteration.ts": 2350, + "nonnull-element-arguments.ts": 2545, + "nonnull-forwarded-class-values.ts": 2532, + "nullable-object-extension.mjs": 1922, + "nullish-asserted-class-arms.ts": 2485, + "nullish-assignment-values.ts": 1745, + "nullish-long-chain.ts": 2326, + "number-parse-statics.ts": 2443, + "number-predicates-unknown.ts": 2375, + "numeric-call-specialization.ts": 2588, + "object-enumeration-array-reads.ts": 1967, + "object-from-checked-entries.js": 2542, + "object-inherited-to-string.js": 2670, + "object-key-indexes.js": 2753, + "object-prototype-identity.mjs": 2064, + "object-reexport/main.js": 2482, + "object-spread-computed.ts": 2578, + "opentui-byte-queue.js": 2802, + "optional-callback-arity.ts": 2348, + "optional-class-flows.ts": 2247, + "optional-element-defaults.ts": 2052, + "optional-flag-comparisons.ts": 2527, + "optional-native-callables.js": 2309, + "optional-node-list-iteration.ts": 2316, + "optional-string-index/main.ts": 2950, + "path-to-file-url-options.ts": 2299, + "performance-presence.ts": 2043, + "primitive-and-function-descriptors.js": 2222, + "primitive-union-string.ts": 2856, + "process-builtin-values.js": 2616, + "process-constrained-memory.ts": 2105, + "process-env-computed-keys.js": 2252, + "process-hrtime.js": 2596, + "process-named-signals.cjs": 2604, + "process-uncaught-handler-throws.cjs": 2306, + "process-uncaught-loop.cjs": 2320, + "process-uncaught-module.mjs": 1832, + "process-uncaught-monitor.cjs": 2077, + "process-uncaught-rejection.cjs": 2431, + "process-uncaught-sync.cjs": 2425, + "process-version-pin.ts": 2418, + "process-versions-storage.ts": 2051, + "projected-collection-lifetimes.ts": 2409, + "promise-checked-rejections.ts": 1985, + "promise-resolve-void.ts": 2341, + "prototype-method-overrides.mjs": 4870, + "prototype-named-data-records.ts": 2513, "rc-last-use-moves.ts": 2854, "rc-private-array-writes.ts": 3076, - "record-field-presence.ts": 3566, - "record-key-order.ts": 2682, - "record-optional-json-presence.ts": 2822, - "record-presence-copies.ts": 3201, - "record-presence-delete-json.ts": 3074, - "record-unchecked-read-presence.ts": 2374, - "record-unknown-values.ts": 3234, - "reflect-own-keys.mjs": 1796, - "reflect-record-union-keys.mjs": 2278, - "reflect-typed-record-keys.ts": 2418, - "regex-callback-replacements.ts": 2839, - "regex-callback-values.js": 2887, - "regex-checked-casts.ts": 1808, - "regex-checked-storage.js": 2999, - "regex-exec-long-subject.ts": 2794, + "record-field-presence.ts": 3025, + "record-key-order.ts": 2807, + "record-optional-json-presence.ts": 2623, + "record-presence-copies.ts": 2693, + "record-presence-delete-json.ts": 2748, + "record-unchecked-read-presence.ts": 2103, + "record-unknown-values.ts": 3450, + "reflect-own-keys.mjs": 2583, + "reflect-record-union-keys.mjs": 2454, + "reflect-typed-record-keys.ts": 1855, + "regex-callback-replacements.ts": 2492, + "regex-callback-values.js": 2733, + "regex-checked-casts.ts": 2350, + "regex-checked-storage.js": 2669, + "regex-exec-long-subject.ts": 4533, "regex-exec-result-arrays.ts": 3204, "regex-fs-text-surfaces.ts": 3720, - "regex-input-lifetimes.ts": 2060, - "regex-native-matcher.ts": 4292, - "regex-optional-captures.ts": 2856, - "regex-optional-templates.ts": 2387, - "regex-split-captures.ts": 2496, - "regex-text-paths.ts": 3201, - "regexp-constructor-repeat.ts": 2842, - "regexp-optional-constructor.ts": 2495, - "regexp-string-coercion.js": 1920, - "renderer-export-dictionaries.js": 2828, - "renderer-null-state.js": 2692, - "renderer-specializations.js": 2881, - "repeat-and-typed-read-errors.ts": 2395, - "rest-optional-array-arguments.ts": 2478, - "rest-optional-elements.ts": 2534, - "return-void-through-finally.ts": 2913, - "runtime-optional-string-flows.ts": 2188, - "scalar-string-slices.ts": 2172, - "set-checked-methods.js": 3226, - "set-checked-storage.ts": 1974, - "set-iterator-seed-references.ts": 2018, - "set-iterator-seeds.ts": 3264, - "set-optional-seeds.ts": 2769, - "small-collection-transitions.ts": 3115, + "regex-input-lifetimes.ts": 2535, + "regex-native-matcher.ts": 3683, + "regex-optional-captures.ts": 2606, + "regex-optional-templates.ts": 2338, + "regex-split-captures.ts": 2583, + "regex-text-paths.ts": 2889, + "regexp-constructor-repeat.ts": 2351, + "regexp-optional-constructor.ts": 2315, + "regexp-string-coercion.js": 1897, + "renderer-export-dictionaries.js": 2582, + "renderer-null-state.js": 2185, + "renderer-specializations.js": 2653, + "repeat-and-typed-read-errors.ts": 2751, + "rest-optional-array-arguments.ts": 2671, + "rest-optional-elements.ts": 2289, + "return-void-through-finally.ts": 2486, + "runtime-optional-string-flows.ts": 2406, + "scalar-string-slices.ts": 2175, + "set-checked-methods.js": 2631, + "set-checked-storage.ts": 2064, + "set-iterator-seed-references.ts": 2863, + "set-iterator-seeds.ts": 2896, + "set-optional-seeds.ts": 2121, + "small-collection-transitions.ts": 2645, "speculative-integer-globals.ts": 2544, "speculative-integer-loops.ts": 2308, "speculative-integer-reads.ts": 3059, - "stack-depth-async-bodies.ts": 2625, - "stack-overflow-async.ts": 1714, - "stack-overflow-caught.ts": 2878, - "stack-overflow-finally.ts": 2668, - "stack-overflow-shapes.ts": 3524, - "stack-overflow-uncaught.ts": 2587, + "stack-depth-async-bodies.ts": 1910, + "stack-overflow-async.ts": 2447, + "stack-overflow-caught.ts": 2424, + "stack-overflow-finally.ts": 2613, + "stack-overflow-shapes.ts": 2534, + "stack-overflow-uncaught.ts": 2317, "stackless-async-concurrency.ts": 3322, "stackless-async-context.ts": 1853, "stackless-async-exceptions.ts": 3251, "stackless-async-ordering.ts": 3551, "stackless-async-unhandled.ts": 1779, - "static-field-updates/main.ts": 2473, - "static-method-receivers.ts": 2567, - "stdio-values.mjs": 2963, - "stdio-write-errors.mjs": 2760, - "stdio-write-overrides.mjs": 2090, - "stored-native-builtins.js": 2900, - "stored-object-helpers.js": 2328, + "static-field-updates/main.ts": 2050, + "static-method-receivers.ts": 2243, + "stdio-values.mjs": 2578, + "stdio-write-errors.mjs": 1977, + "stdio-write-overrides.mjs": 2495, + "stored-native-builtins.js": 2831, + "stored-object-helpers.js": 2747, "stream-dynamic-entry-kinds.cjs": 2778, "stream-dynamic-entry-kinds.ts": 2624, "stream-encoded-from-entries.cjs": 2924, "stream-encoded-from-entries.ts": 3274, - "string-char-code-integer-loops.ts": 1819, - "string-code-points.ts": 1858, - "string-concat-number-parts.ts": 1705, - "string-construction-order.ts": 2928, + "string-char-code-integer-loops.ts": 2495, + "string-code-points.ts": 1970, + "string-concat-number-parts.ts": 2044, + "string-construction-order.ts": 2502, "string-field-append.ts": 2926, - "string-lifetimes-boundaries.ts": 1843, - "string-lifetimes-evaluation.ts": 2718, - "string-lifetimes-iteration.ts": 2668, - "string-lifetimes-operations.ts": 2866, - "string-normalize.ts": 2507, - "string-pattern-replacement.ts": 3053, - "string-scan-fast-paths.ts": 2942, - "string-split-checked-separator.mjs": 2465, - "string-split-traversal.ts": 3686, - "structural-class-properties.ts": 2071, - "structured-text-boundaries.js": 2038, - "structured-text-storage.ts": 2083, - "switch-integer-dispatch.ts": 2561, - "symbol-checked-boundary/main.ts": 3073, - "symbol-class-fields.ts": 1839, - "symbol-class-fields/main.cjs": 2716, - "symbol-class-methods/main.ts": 1920, - "symbol-fields-deferred-factory.ts": 2270, - "symbol-fields-inferred.js": 1610, - "symbol-object-properties/main.js": 2842, - "synchronous-callback-lifetimes.ts": 3460, - "terminal-stream-properties.ts": 2151, - "text-codec-values/main.ts": 2261, - "text-codec-var.ts": 2601, - "text-encode-into-boundaries.ts": 2554, - "timers-clear-many.ts": 2390, - "tuple-and-string-search.ts": 2238, - "tuple-array-union.ts": 2290, - "tuple-callback-visitation.ts": 3777, - "tuple-forof-visitation.ts": 2917, - "typed-array-bulk-conversion.mjs": 4510, - "typed-array-byte-io.js": 2794, - "typed-array-checked-index.js": 1963, - "typed-array-constructor-alias.ts": 2203, - "typed-array-constructor-identity.js": 2030, - "typed-array-constructor-union.ts": 2632, - "typed-array-constructor-values.mjs": 3162, - "typed-array-dynamic-methods.js": 2468, - "typed-array-integer-widths.ts": 2823, - "typed-array-nan-coded-reads.ts": 3658, - "typed-array-numeric-import.ts": 2758, - "typed-array-present-reads.ts": 2812, - "typed-array-reversed-storage.ts": 2702, - "typed-array-unknown.ts": 2767, - "typed-collection-iterator-references.ts": 3694, - "typed-collection-iterators.ts": 3044, - "typed-collection-views/main.ts": 3027, - "typed-index-arguments.ts": 2801, - "typed-prototype-methods.ts": 2702, - "typed-rest-callables.ts": 2066, - "typed-rest-filtered-return.ts": 1741, - "typedarray-native-inputs.js": 3278, - "typeof-checked-comparison.js": 2471, - "uint8array-sort-domains.ts": 2675, - "unicode-case-paths.ts": 2617, - "unicode-process-argv.ts": 2688, - "union-discriminant-width.ts": 3120, - "union-literal-scalar-discriminants.ts": 3160, - "union-literal-slot-conversion.ts": 2002, - "union-nested-layout-discriminant.ts": 2160, - "union-optional-semantic-identity.ts": 3319, - "union-record-clone.ts": 3245, - "union-record-structural-copy.ts": 3278, - "union-reference-comparison.ts": 2689, - "unknown-array-holes.ts": 1863, - "unknown-collections.ts": 2098, - "unknown-object-enumeration.ts": 4264, - "unknown-record-views.ts": 2126, - "url-runtime-base.ts": 2747, - "utf8-span-decoding.ts": 2143, - "util-parseargs-wrapped/main.ts": 3020, - "virtual-runtime-optional-returns.ts": 3408, - "weak-map-array-buffer.ts": 2113, - "weak-map-fresh-array.js": 2822, - "weak-map-native.js": 2623, - "weak-native-class-identity.ts": 1967, - "weak-set-native.js": 2320, - "worker-class-instance-clone.ts": 3408 + "string-lifetimes-boundaries.ts": 2481, + "string-lifetimes-evaluation.ts": 2486, + "string-lifetimes-iteration.ts": 2043, + "string-lifetimes-operations.ts": 2490, + "string-normalize.ts": 2391, + "string-pattern-replacement.ts": 3527, + "string-scan-fast-paths.ts": 2272, + "string-split-checked-separator.mjs": 2144, + "string-split-traversal.ts": 3038, + "structural-class-properties.ts": 2610, + "structured-text-boundaries.js": 2792, + "structured-text-storage.ts": 2942, + "switch-integer-dispatch.ts": 2290, + "symbol-checked-boundary/main.ts": 2273, + "symbol-class-fields.ts": 2065, + "symbol-class-fields/main.cjs": 2595, + "symbol-class-methods/main.ts": 1855, + "symbol-fields-deferred-factory.ts": 2253, + "symbol-fields-inferred.js": 2329, + "symbol-object-properties/main.js": 2835, + "synchronous-callback-lifetimes.ts": 2768, + "terminal-stream-properties.ts": 2586, + "text-codec-values/main.ts": 2158, + "text-codec-var.ts": 2182, + "text-encode-into-boundaries.ts": 1971, + "timers-clear-many.ts": 2704, + "truthy-object-logical.ts": 5950, + "tuple-and-string-search.ts": 2663, + "tuple-array-union.ts": 2706, + "tuple-callback-visitation.ts": 3464, + "tuple-forof-visitation.ts": 2357, + "typed-array-bulk-conversion.mjs": 3837, + "typed-array-byte-io.js": 2552, + "typed-array-checked-index.js": 2420, + "typed-array-constructor-alias.ts": 2507, + "typed-array-constructor-identity.js": 2453, + "typed-array-constructor-union.ts": 2428, + "typed-array-constructor-values.mjs": 2571, + "typed-array-dynamic-methods.js": 2604, + "typed-array-integer-widths.ts": 2747, + "typed-array-nan-coded-reads.ts": 2921, + "typed-array-numeric-import.ts": 2450, + "typed-array-present-reads.ts": 2582, + "typed-array-reversed-storage.ts": 2168, + "typed-array-unknown.ts": 2500, + "typed-collection-iterator-references.ts": 3186, + "typed-collection-iterators.ts": 2946, + "typed-collection-views/main.ts": 2523, + "typed-index-arguments.ts": 2494, + "typed-prototype-methods.ts": 2527, + "typed-rest-callables.ts": 2391, + "typed-rest-filtered-return.ts": 2578, + "typedarray-native-inputs.js": 3104, + "typeof-checked-comparison.js": 2116, + "uint8array-sort-domains.ts": 2494, + "unicode-case-paths.ts": 2356, + "unicode-process-argv.ts": 2569, + "union-discriminant-width.ts": 2670, + "union-literal-scalar-discriminants.ts": 2869, + "union-literal-slot-conversion.ts": 2792, + "union-nested-layout-discriminant.ts": 2120, + "union-optional-semantic-identity.ts": 2455, + "union-record-clone.ts": 2790, + "union-record-structural-copy.ts": 2905, + "union-reference-comparison.ts": 2401, + "unknown-array-holes.ts": 1853, + "unknown-collections.ts": 3166, + "unknown-object-enumeration.ts": 3783, + "unknown-record-views.ts": 3243, + "url-runtime-base.ts": 2584, + "utf8-span-decoding.ts": 2564, + "util-parseargs-wrapped/main.ts": 2257, + "virtual-runtime-optional-returns.ts": 2981, + "weak-map-array-buffer.ts": 2435, + "weak-map-fresh-array.js": 2341, + "weak-map-native.js": 3068, + "weak-native-class-identity.ts": 2403, + "weak-set-native.js": 2924, + "worker-class-instance-clone.ts": 3052 }, "san": { - "001-hello.ts": 48584, - "002-log-args.ts": 53231, - "100-number-format.ts": 36832, - "1000-json-stringify-basics.ts": 52367, - "1001-json-escapes-unicode.ts": 4807, - "1002-json-parse-cast.ts": 5113, - "1003-json-parse-unions.ts": 7293, - "1004-json-parse-errors.ts": 49116, - "1005-json-nested.ts": 41496, - "1006-json-fs-config.ts": 48813, - "1007-json-rc-stress.ts": 4968, - "1008-json-null-arms.ts": 49375, - "1009-json-optional-fields.ts": 52902, - "101-arithmetic.ts": 4596, - "1010-json-stringify-space.ts": 7197, - "1011-json-unknown-typeof.ts": 38530, - "102-comparisons.ts": 45324, - "1020-async-basics.ts": 5928, - "1021-async-ordering.ts": 3518, - "1022-async-exceptions.ts": 4562, - "1023-async-rc-stress.ts": 49059, - "1024-async-pending-exit.ts": 4366, - "1025-async-promise-capture.ts": 4983, - "1026-throw-promise.ts": 47886, - "1027-async-return-promise.ts": 3187, - "1028-async-return-record-literals.ts": 53064, - "1029-async-eager-chains.ts": 5109, - "103-ternary.ts": 4538, - "104-ternary-empty-arrays.ts": 50460, - "1050-comptime-tables.ts": 7149, - "1051-comptime-strings.ts": 4737, - "1052-comptime-records.ts": 37872, - "1053-comptime-json.ts": 4779, - "1054-comptime-modules/main.ts": 7660, - "110-number-radix.ts": 4935, - "111-record-entries.ts": 7207, - "1110-math-members.ts": 4805, - "1111-math-random.ts": 5313, - "1113-string-methods.ts": 39688, - "1114-string-unicode-island.ts": 61280, - "1115-parse-globals.ts": 4273, - "1116-island-static-mix.ts": 58945, - "1117-typeof-static-union.ts": 4726, - "1118-object-spread-conditional.ts": 5790, - "1119-switch-union.ts": 3967, - "112-class-descriptor-key.js": 6359, - "1121-infinity-number-tostring.ts": 6448, - "1122-any-captures.ts": 5744, - "1124-union-narrowed-retag.ts": 48623, - "113-promise-checked-exits.ts": 5906, - "114-live-record-delete.ts": 5041, - "115-array-compound.js": 45694, - "116-text-decoder-runtime.js": 42554, - "117-weak-cache-cycle.js": 4096, - "118-fs-stored-callbacks.cjs": 67405, - "119-native-patterns.js": 6976, - "1200-regex-test-basics.ts": 59964, - "1201-regex-replace.ts": 59629, - "1202-regex-substitutions.ts": 64765, - "1203-regex-split.ts": 40181, - "1204-regex-empty-unicode.ts": 4019, - "1205-regex-rc-stress.ts": 6786, - "1300-errors-basics.ts": 4602, - "1301-errors-subclass.ts": 4547, - "1302-errors-typed-catch.ts": 5456, - "1303-errors-rc-stress.ts": 3915, - "1304-errors-uncaught.ts": 4301, - "1305-errors-async-rejections.ts": 25668, - "1306-errors-runtime-instances.ts": 56774, - "1350-path-normalize-join.ts": 4099, - "1351-path-parts.ts": 3517, - "1352-path-resolve-relative.ts": 4602, - "1353-os-basics.ts": 4075, - "1354-builtin-bare-specifiers.ts": 4565, - "1355-url-parse.ts": 3650, - "1356-url-file-bridge.ts": 5481, - "1357-fsp-roundtrip.ts": 4525, - "1358-crypto-random.ts": 3809, - "1359-json-module/main.ts": 4642, - "1360-spawn-sync.ts": 14534, - "1361-spawn-events.ts": 3384, - "1362-spawn-timers.ts": 9556, - "1363-spawn-unhandled-error.ts": 3577, - "1364-union-truthiness.ts": 4455, - "1365-union-logical.ts": 5263, - "1366-union-equality.ts": 5404, - "1367-destructuring.ts": 6097, - "1368-constructor-functions.ts": 4502, - "1369-promise-union.ts": 5171, - "1370-spread.ts": 5455, - "1371-union-template-tostring.ts": 5704, - "1372-loose-null-tests.ts": 4863, - "1373-union-array-arms.ts": 6061, - "140-bitwise-operators.ts": 5704, - "1400-typedarray-basics.ts": 4417, - "1401-typedarray-slice-set.ts": 6150, - "1402-buffer-encodings.ts": 6652, - "1403-buffer-fs.ts": 4712, - "1404-zlib-crypto-bytes.ts": 8302, - "1405-bytes-unions-arrays.ts": 4908, - "1406-dataview-mp4.ts": 4190, - "1407-dataview-bounds.ts": 5248, - "1408-string-indexing.ts": 6549, - "1409-typedarray-integer-loops.ts": 5748, - "1420-number-statics.ts": 4080, - "1421-number-parse-strings.ts": 3030, - "1422-date-iso.ts": 4656, - "1423-text-codec.ts": 42827, - "1424-fs-options.ts": 4763, - "1425-stdin-tty.ts": 3515, - "1426-stdin-read.ts": 4428, - "1427-fromcharcode-lastindexof.ts": 4393, - "1428-settled-await-order.ts": 3638, - "1429-promise-catch-finally.ts": 6438, - "1430-promise-race.ts": 5872, - "1431-caught-tostring.ts": 4401, - "1432-destructured-params.ts": 3887, - "1433-filter-narrow.ts": 5268, - "1434-async-never.ts": 3971, - "1435-math-spread.ts": 5075, - "1436-default-undef-param.ts": 4896, - "1437-pad-default.ts": 5306, - "1438-promise-all.ts": 8026, - "1440-interval-basics.ts": 3886, - "1441-interval-clear-cross.ts": 8806, - "1442-interval-throw.ts": 3908, - "1443-signal-handlers.ts": 10098, - "1444-exit-listeners.ts": 6271, - "1445-exit-process-exit.ts": 6288, - "1446-exit-uncaught.ts": 4829, - "1447-stdin-closed-events.ts": 5308, - "1448-stream-columns.ts": 3842, - "1450-incdec-expression.ts": 4062, - "1451-instanceof-uint8array-unknown.ts": 4913, - "1452-return-through-finally.ts": 3940, - "1453-pmap-settled.ts": 5769, - "1454-nonnull-narrow-and-fcc-bytes.ts": 5066, - "1455-lambda-union-return-adoption.ts": 4687, - "1460-console-error-warn.ts": 4173, - "1461-process-pid-getuid-kill.ts": 3798, - "1462-exec-sync.ts": 4955, - "1463-timeout-unref.ts": 3605, - "1464-env-writes.ts": 3898, - "1465-env-value.ts": 5166, - "1466-child-containers.ts": 4567, - "1467-string-match.ts": 31065, - "1468-exec-path.ts": 3971, - "1469-remove-listener.ts": 5771, - "1470-child-lifecycle.ts": 4259, - "1471-child-unref.ts": 8596, - "1472-errno-code.ts": 3697, - "1473-promisify-execfile.ts": 5268, - "1474-string-decoder.ts": 4402, - "1475-readline-closed-stdin.ts": 7198, - "1476-assign-expression.ts": 4160, - "1477-in-expressions.ts": 3377, - "1478-promise-reject.ts": 4766, - "1479-destructuring-assign.ts": 3620, - "1480-os-network-interfaces.ts": 5191, - "1481-string-case-static.ts": 47079, - "1482-spawnsync-error.ts": 4222, - "1483-array-slice.ts": 37812, - "1520-fs-wider-surface.ts": 4505, - "1520-string-split-static.ts": 5103, - "1521-fs-lstat-lock.ts": 4862, - "1521-string-trim-pad-static.ts": 4149, - "1522-parseint-static.ts": 3342, - "1522-spawnsync-options.ts": 6589, - "1523-isnan-floor-static.ts": 4386, - "1523-spawn-options.ts": 4864, - "1524-atomics-sleep-static.ts": 5554, - "1524-catch-narrowing.ts": 4776, - "1525-child-exit-signal.ts": 3419, - "1525-unknown-typeof-validation.ts": 4171, - "1526-set-spread.ts": 6387, - "1527-logical-mixed-operands.ts": 56825, - "1528-delete-records-env.ts": 3989, - "1529-class-with-statics.ts": 4851, - "1530-array-push-variadic.ts": 4575, - "1530-spread-override-completion.ts": 4651, - "1531-delete-optional-fields.ts": 5027, - "1531-process-arch-versions.ts": 4345, - "1532-array-splice-shift.ts": 5472, - "1532-union-shared-field-read.ts": 4768, - "1533-bool-equality.ts": 4449, - "1533-path-platform-namespaces.ts": 3877, - "1534-crypto-hash-chain.ts": 4113, - "1534-union-as-arm-cast.ts": 3510, - "1535-spawn-fd-stdio.ts": 3466, - "1535-union-param-defaults.ts": 3648, - "1536-destructuring-defaults.ts": 3985, - "1536-string-array-sweep.ts": 4779, - "1537-chalk-hybrid/main.ts": 4311, - "1537-os-release-spawnsync-stdio.ts": 3803, - "1538-await-promiselike-return.ts": 4183, - "1538-math-static-scalar.ts": 4776, - "1539-readonly-set-map.ts": 4240, - "1539-unknown-truthiness.ts": 3925, - "1540-os-userinfo.ts": 3976, - "1540-void-statement.ts": 3920, - "1541-fs-readdir-dirent.ts": 6148, - "1541-union-keyed-reads.ts": 5049, - "1542-map-promise-values.ts": 4830, - "1542-record-literal-into-union.ts": 4691, - "1543-rest-destructuring.ts": 4682, - "1543-set-server-handles.ts": 11403, - "1544-dyn-json-reads.ts": 5540, - "1544-string-matchall.ts": 4621, - "1545-spread-order-and-optional.ts": 4810, - "1546-union-element-reads.ts": 4735, - "1547-computed-key-fold.ts": 4346, - "1548-boolean-condition-forms.ts": 4311, - "1549-array-isarray-unions.ts": 4783, - "1550-param-defaults-func-set.ts": 4654, - "1551-dyn-receiver-methods.ts": 47581, - "1552-exec-options-record.ts": 4931, - "1553-truthy-hof-predicates.ts": 3759, - "1554-caught-into-unknown.ts": 4792, - "1555-index-spread-into-declared.ts": 5295, - "1556-union-retag-width-arms.ts": 4339, - "1557-url-host.ts": 4062, - "1558-any-joins-and-dyn-validation.ts": 4201, - "1559-conditional-spread-index-merge.ts": 4811, - "1560-forof-homogeneous-tuples.ts": 3801, - "1561-forof-strings.ts": 4569, - "1561-promise-then.ts": 5688, - "1562-optional-chain-tails.ts": 4544, - "1562-spawn-conditional-spread.ts": 5015, - "1563-forof-iterator-projections.ts": 3931, - "1563-string-raw-fold.ts": 2934, - "1564-fs-watch.ts": 4633, - "1564-string-raw.ts": 4462, - "1565-spawn-pipe-streams.ts": 4825, - "1565-union-element-join.ts": 4303, - "1566-child-duck-interface.ts": 3784, - "1567-server-close-override.ts": 8452, - "1568-x509-fingerprint.ts": 4642, - "1569-fsp-mkdir-unlink-chmod.ts": 4604, - "1570-child-unref-kill-reffed.ts": 10519, - "1571-optional-call-tostring-tail.ts": 4149, - "1571-stdin-set-raw-mode-non-tty.ts": 3975, - "1572-promise-reject-all-tuple.ts": 4421, - "1572-x509-validity-date-gettime.ts": 3928, - "1573-promisify-execfile-env-spread.ts": 4371, - "1573-tdz-scalar-forward-capture.ts": 3510, - "1574-dyn-optional-method-number-keys.ts": 5406, - "1574-promise-all-tuple-literal.ts": 4446, - "1575-unknown-assert-into-record.ts": 4160, - "1576-width-coercions.ts": 4905, - "1577-url-hostname.ts": 3830, - "1578-exec-input-optional.ts": 4111, - "1579-matchall-index.ts": 3935, - "1580-exec-env-conditional-spread.ts": 4157, - "1581-declare-const-read.ts": 4532, - "1582-timer-sleep-resolve.ts": 5668, - "1583-loops-and-stream-captures.ts": 4447, - "1584-union-field-unassigned.ts": 4778, - "1585-union-field-conditional-ctor.ts": 4205, - "1586-derived-field-before-super-init.ts": 4167, - "1590-js-unannotated.js": 4511, - "1591-js-closures.js": 4889, - "1592-js-classes.js": 7239, - "1593-js-jsdoc-records.js": 5280, - "1594-js-async.js": 3437, - "1595-js-island-gap/main.js": 3858, - "1596-cjs-modules/main.js": 3826, - "1597-mjs-graph/main.mjs": 4207, - "1598-cjs-builtin-require/main.js": 4782, - "1599-js-uncaught-throw.js": 3029, - "1600-assert-passing.ts": 4584, - "1601-assert-fail-exit.ts": 5710, - "1602-assert-caught-error.ts": 5606, - "1603-assert-scalar-messages.ts": 6055, - "1604-assert-deep-structures.ts": 4164, - "1605-assert-import-forms.ts": 4744, - "1606-assert-strict-module.ts": 3846, - "1607-assert-throws-match.ts": 3634, - "1608-cjs-assert/main.js": 22902, - "1609-assert-async.ts": 5276, - "1610-path-win32-full.ts": 4297, - "1611-url-file-bridge-neutral.ts": 4511, - "1612-cjs-module-globals.cjs": 4120, - "1613-cjs-esm-proxy-named/main.mjs": 4168, - "1614-js-fence-dodges.cjs": 5147, - "1615-cjs-export-shapes/main.cjs": 5790, - "1616-cjs-esm-lexer-invisible/main.mjs": 3074, - "1617-cjs-esm-lexer-visible/main.mjs": 4703, - "1618-cjs-esm-poisoned-tail/main.mjs": 4175, - "1619-cjs-esm-reexport-invisible/main.mjs": 3250, - "1620-cjs-require-effects-order/main.js": 4047, - "1621-cjs-require-cache-hit/main.js": 3190, - "1622-cjs-require-conditional/main.js": 4002, - "1623-cjs-require-diamond/main.js": 3383, - "1624-cjs-require-dir-mid-file/main.js": 4621, - "1625-cjs-require-lazy-fn/main.js": 4138, - "1626-cjs-require-mjs/main.js": 3518, - "1627-mjs-import-cjs-requires/main.mjs": 4705, - "1628-checked-dynamic-builtin-args.cjs": 4815, - "1629-require-main-filename.cjs": 3830, - "1630-inspect-scalars.ts": 3402, - "1630-rmsync-retry-options.cjs": 4168, - "1631-inspect-arrays.ts": 5636, - "1632-inspect-records.ts": 5322, - "1633-inspect-map-set.ts": 4905, - "1634-inspect-classes.ts": 50857, - "1635-inspect-buffer.ts": 3662, - "1636-util-format.ts": 3856, - "1637-inspect-dyn.ts": 4713, - "1638-inspect-cjs.cjs": 4782, - "1639-versions-openssl-probe.ts": 3624, - "1640-fd-read-decode.ts": 4777, - "1641-string-search.ts": 42621, - "1642-object-fromentries-rows.ts": 3842, - "1643-metadata-dyn-return.cjs": 6131, - "1644-ee-basics.ts": 4824, - "1645-ee-extends.ts": 4269, - "1646-ee-once-remove.ts": 5597, - "1647-ee-meta-events.ts": 4609, - "1648-ee-error-event.ts": 3894, - "1649-ee-names-counts.ts": 3445, - "1650-ee-prepend.ts": 5882, - "1651-ee-max-listeners.ts": 3513, - "1652-ee-snapshot.ts": 3828, - "1653-ee-cjs.cjs": 5160, - "1654-ee-namespace.ts": 4086, - "1655-spawnsync-neutral.ts": 5575, - "1656-execsync-neutral.ts": 5201, - "1657-spawn-async-neutral.ts": 4183, - "1660-buffer-read-write-num.ts": 4602, - "1661-buffer-encodings-full.ts": 4532, - "1662-string-decoder-encodings.ts": 4447, - "1663-buffer-compare-search-fill.ts": 6507, - "1664-dyn-fn-boundary.cjs": 3753, - "1665-dyn-fn-mustcall/main.cjs": 3637, - "1666-dyn-fn-identity.ts": 4113, - "1667-dyn-fn-not-callable.cjs": 5226, - "1668-dyn-fn-throws.cjs": 3927, - "1669-symbol-identity.ts": 5374, - "1670-symbol-registry.ts": 5422, - "1671-symbol-typeof.ts": 5011, - "1672-symbol-containers.ts": 6131, - "1673-symbol-cjs.cjs": 3807, - "1674-symbol-inspect.ts": 4101, - "1676-func-array-surface.ts": 3917, - "1677-emitter-listeners.ts": 5384, - "1678-emitter-dyn-listeners.cjs": 6837, - "1679-console-dyn.js": 5132, - "1680-assert-bytes.ts": 5780, - "1681-assert-funcs.ts": 4542, - "1685-stream-readable-basics.ts": 6799, - "1686-stream-readable-paused.ts": 7460, - "1687-stream-readable-flow-control.ts": 6103, - "1688-stream-writable-basics.ts": 8189, - "1689-stream-writable-async-drain.ts": 6061, - "1690-stream-duplex.ts": 8154, - "1691-stream-transform.ts": 8459, - "1692-stream-pipe.ts": 8943, - "1693-stream-pipe-backpressure.ts": 7445, - "1694-stream-destroy.ts": 4337, - "1695-stream-props.ts": 4409, - "1696-stream-read-inside-read.ts": 4780, - "1697-stream-tick-vs-timer.ts": 4369, - "1698-stream-uncaught-error.ts": 9453, - "1699-stream-callback-shapes.ts": 6489, - "1700-mustcall-common/main.cjs": 5513, - "1701-mustcall-exit-report/main.cjs": 5169, - "1702-dyn-proto-dispatch.cjs": 3843, - "1703-arguments-rest-props.cjs": 5139, - "1710-cjs-export-class/main.js": 4603, - "1711-cjs-export-single-values/main.js": 4271, - "1712-field-incdec.ts": 4369, - "1713-js-dyn-fields.js": 3948, - "1720-assert-throws-shape.ts": 4422, - "1721-assert-throws-regex-class.ts": 3508, - "1722-assert-rejects.ts": 4110, - "1723-assert-does-not-reject.ts": 4852, - "1724-assert-iferror.ts": 5098, - "1725-assert-symbols.ts": 4520, - "1726-promise-with-resolvers.ts": 4144, - "1727-assert-throws-shape-exit.ts": 4544, - "1730-countdown-symbol-keys/main.js": 4981, - "1731-symbol-field-shapes.cjs": 4983, - "1732-symbol-field-cross-module/main.js": 6365, - "1740-stream-extends-readable.ts": 4706, - "1741-stream-extends-writable.ts": 8537, - "1742-stream-extends-duplex-transform.ts": 8628, - "1743-stream-extends-vt-dispatch.ts": 7490, - "1744-stream-set-encoding.ts": 3923, - "1745-stream-encoding-js.cjs": 3912, - "1746-stream-for-await.ts": 5266, - "1747-stream-for-await-js.cjs": 9157, - "1750-http-agent-options.ts": 4824, - "1751-options-record-stance.ts": 4860, - "1760-surplus-args-drop.cjs": 3596, - "1761-emitter-special-event-names.cjs": 5408, - "1770-assert-dyn-strict.ts": 4549, - "1771-assert-dyn-deep.ts": 4653, - "1772-assert-dyn-js.cjs": 4842, - "1773-assert-dyn-exit.ts": 3322, - "1780-http-res-surface.ts": 7900, - "1781-http-server-shapes.cjs": 5025, - "1790-computed-key-folds.ts": 4472, - "1791-searchparams-core.ts": 3100, - "1792-searchparams-encoding.ts": 4024, - "1793-searchparams-iteration.ts": 2933, - "1794-searchparams-url-live.ts": 2969, - "1795-dyn-handle-request.cjs": 8538, - "1796-dyn-handle-body.cjs": 8773, - "1797-dyn-handle-socket.cjs": 5230, - "1798-dyn-handle-typed-box.ts": 9154, - "1800-immediate-basics.ts": 3918, - "1801-immediate-handle.ts": 3182, - "1802-immediate-unref-exit.ts": 3903, - "1803-timeout-refresh.ts": 3243, - "1804-timers-module.ts": 3435, - "1805-timer-callback-args.ts": 3958, - "1806-timer-delay-trunc.ts": 4233, - "1810-stream-options-const-record.ts": 3952, - "1811-stream-option-value-callbacks.cjs": 4066, - "1812-stream-super-options-forwarding.cjs": 8532, - "1813-stream-finished.ts": 3971, - "1814-stream-pipeline.cjs": 4413, - "1815-stream-state-reads.cjs": 4085, - "1820-static-block-basics.ts": 3479, - "1821-static-block-order.ts": 4110, - "1822-static-block-js.js": 3095, - "1823-static-instance-method-names.ts": 3531, - "1824-for-of-destructuring-defaults.ts": 3925, - "1825-exhaustive-typeof-switch.ts": 3439, - "1826-settimeout-arguments-callback.js": 3758, - "1830-enum-numeric-basics.ts": 3846, - "1831-enum-string-const-reverse.ts": 3347, - "1832-enum-modules/main.ts": 3603, - "1835-var-basics.ts": 3009, - "1836-var-loop-capture.ts": 4162, - "1837-var-undefined-hoisting.ts": 3457, - "1838-var-modules/main.ts": 4306, - "1839-var-js/main.cjs": 4870, - "1840-jsdoc-import-type-only/main.js": 3497, - "1850-overload-basics.ts": 4398, - "1851-overload-return-narrowing.ts": 3452, - "1852-overload-class-members.ts": 3733, - "1853-overload-modules/main.ts": 3524, - "1854-ambient-declare-fn.ts": 4169, - "1855-ambient-declare-fn-uncaught.ts": 2640, - "1870-unit-type-values.ts": 4848, - "1871-empty-array-never.ts": 3051, - "1872-template-tostring-composite.ts": 3835, - "1880-json-declared-field-order.ts": 5173, - "1881-default-anon/main.ts": 3809, - "1882-default-cjs-interop/main.ts": 3893, - "1883-default-exports/main.ts": 4076, - "1890-ns-imports/main.ts": 3441, - "1891-ns-reexport/main.ts": 3946, - "1940-class-values-basics.ts": 3823, - "1941-class-values-registry.ts": 3834, - "1942-class-expressions.ts": 3250, - "1943-class-statics-expanded.ts": 3491, - "1944-class-values-modules/main.ts": 3807, - "1950-generic-fn-values.ts": 4479, - "1951-generic-classes-basics.ts": 4288, - "1952-generic-class-statics-values.ts": 4461, - "1953-generic-class-hierarchy.ts": 2769, - "1954-generic-modules/main.ts": 4012, - "1960-namespace-basics.ts": 4063, - "1961-namespace-nested.ts": 4436, - "1962-namespace-classes.ts": 3835, - "1963-namespace-aliases.ts": 4480, - "1964-namespace-type-only.ts": 4245, - "1965-namespace-ambient.ts": 3646, - "1966-namespace-modules/main.ts": 3158, - "1967-namespace-alias-typeonly.ts": 2894, - "1968-namespace-import-eq-snapshot.ts": 4133, - "1970-decorators-basics.ts": 5269, - "1971-decorators-rebinding.ts": 4674, - "1972-decorators-throwing.ts": 3103, - "1973-decorators-ambient.ts": 3465, - "1980-primitive-proto-statics.ts": 4370, - "1981-date-utc.ts": 3865, - "1982-freeze-resolve-passthrough.ts": 4409, - "1983-array-tuple-surfaces.ts": 4749, - "1990-labels-basics.ts": 3921, - "1991-for-in-loops.ts": 4875, - "1992-small-syntax.ts": 4940, - "200-strings.ts": 2950, - "2000-generic-methods-basic.ts": 19968, - "2001-generic-methods-generic-class.ts": 3103, - "2002-generic-methods-inheritance.ts": 4643, - "2003-generic-methods-object-literal.ts": 4397, - "2004-generic-methods-statics.ts": 2813, - "201-templates.ts": 3364, - "2010-generators-basics.ts": 4186, - "2011-generators-forof.ts": 4950, - "2012-generators-return-throw.ts": 4210, - "2013-generators-sent-values.ts": 4475, - "2014-generators-values.ts": 4791, - "2015-generators-yieldstar.ts": 3849, - "2016-generators-rc-stress.ts": 4017, - "2017-generators-async.ts": 4735, - "2018-generators-uncaught.ts": 4005, - "2019-generators-loops.ts": 2646, - "2020-generic-value-bindings.ts": 4401, - "2021-generic-value-binding-modules/main.ts": 3358, - "2022-width-index-capture.ts": 3719, - "2023-width-readonly.ts": 3719, - "2024-width-array-elems.ts": 3231, - "2025-width-union-compose.ts": 3698, - "2026-width-spread.ts": 3241, - "2030-width-nested.ts": 4055, - "2031-width-tuples.ts": 3342, - "2032-cjs-export-assigned-class-expression/main.cjs": 3882, - "2033-property-assigned-class-extends.cjs": 3781, - "2035-ternary-array-retag.cjs": 3818, - "2036-evolving-array-decl.cjs": 4090, - "2037-fn-decl-hoisting.cjs": 3678, - "2038-evolving-array-js.cjs": 5045, - "2040-any-bindings.ts": 3791, - "2040-mixin-heritage.ts": 4699, - "2041-any-params-returns.ts": 3681, - "2041-mixin-values.ts": 4051, - "2042-any-flow-loops.ts": 3594, - "2042-mixin-modules/main.ts": 4173, - "2043-any-dom-values.ts": 2471, - "2043-mixin-rc-stress.ts": 4344, - "2044-vtable-sibling-slots.ts": 3559, - "2045-objlit-accessors-basic.ts": 3871, - "2045-parameter-properties.ts": 4491, - "2046-abstract-classes.ts": 5595, - "2046-objlit-accessors-effects.ts": 2807, - "2047-objlit-accessors-shapes.ts": 3455, - "2047-optional-class-fields.ts": 5630, - "2050-dynamic-import-own-module/main.ts": 3193, - "2051-dynamic-import-then/main.ts": 4043, - "2052-dynamic-import-self.ts": 4058, - "2053-typeof-static-fold.ts": 3537, - "2054-destructuring-island-source.ts": 3138, - "2060-empty-tuple.ts": 3805, - "2070-computed-key-folds.ts": 4750, - "2071-integer-key-enumeration-order.ts": 3546, - "2072-expando-function-members.ts": 4747, - "2073-destructuring-assignment.ts": 3553, - "2074-island-destructuring.ts": 4229, - "2075-index-signature-runtime-keys.ts": 5005, - "2080-destructuring-defaults.ts": 4463, - "2081-destructuring-rest.ts": 3264, - "2082-destructuring-assignment.ts": 4012, - "2085-destructuring-heads-rest-params.ts": 3930, - "2087-destructuring-for-heads.ts": 3872, - "2090-index-signature-number-keys.ts": 4103, - "2091-index-signature-string-intersection.ts": 3918, - "2092-package-imports/main.ts": 3799, - "2093-timers-promises.ts": 3870, - "2094-diagnostics-channel.ts": 4547, - "2095-js-catch-unknown.js": 4236, - "2096-os-type.ts": 3673, - "2097-js-evolving-globals.js": 3604, - "210-string-methods.ts": 3491, - "2100-stream-default-hwm.ts": 6786, - "2101-dyn-param-defaults.ts": 2902, - "2102-empty-pattern-decls.ts": 2680, - "2105-computed-key-static-folds.ts": 4156, - "2106-comma-expressions.ts": 4616, - "211-string-unicode.ts": 3897, - "2110-top-object-types.ts": 3870, - "2111-json-stringify-unknown.ts": 4435, - "2112-array-at-findlast.ts": 4707, - "2113-string-index-methods.js": 3454, - "212-string-aliasing-append.ts": 3894, - "2120-package-self-import/main.ts": 2683, - "2121-esm-cycle-inert-backedge/main.ts": 2391, - "2123-ambient-import-crash/main.ts": 3826, - "2124-imports-field-wildcard/main.ts": 4011, - "2140-uri-component-codecs.ts": 4495, - "2160-dc-tracing-channel.cjs": 5323, - "2161-js-object-literal-identity.cjs": 4357, - "2162-js-dyn-destructure.cjs": 3222, - "2163-js-selfref-const.cjs": 3731, - "2164-js-then-dyn-handler.cjs": 3928, - "2165-js-throw-dyn.cjs": 3594, - "2166-cjs-getter-this/main.cjs": 2580, - "2170-island-array-exits.ts": 5872, - "2171-island-json-stringify.ts": 3235, - "2172-island-regexp-boundary.ts": 4811, - "2190-new-object-and-string-wrappers.ts": 3881, - "2191-uri-encoders.ts": 2785, - "2192-object-default-tostring.ts": 3767, - "2193-discarded-stdlib-reads.ts": 2753, - "2194-ambient-undef-chains.ts": 3966, - "2195-require-missing-package/main.mjs": 3949, - "2196-island-computed-key-chain.ts": 3859, - "2210-dyn-promise-crossing.cjs": 5056, - "2211-dc-trace-promise.cjs": 4674, - "2212-unhandled-rejection-listener.cjs": 3832, - "2213-async-local-storage.cjs": 4800, - "2214-dc-bind-store.cjs": 4857, - "2215-process-emit-warning-exit.cjs": 4319, - "2240-width-class-into-record.ts": 4526, - "2241-width-record-into-class.ts": 3828, - "2242-width-statics-into-record.ts": 3590, - "2243-width-assert-satisfies-shapes.ts": 4657, - "2250-tagged-templates.ts": 3291, - "2252-class-iterators.ts": 4007, - "2253-union-coercions.ts": 2990, - "2260-http2-constants.cjs": 3422, - "2280-builtin-namespace-destructure.cjs": 3322, - "2281-domexception-atob-btoa.cjs": 3717, - "2282-queue-microtask.cjs": 4471, - "2283-structured-clone.cjs": 6184, - "2284-regexp-constructor.cjs": 3737, - "2285-iferror-dyn.cjs": 3898, - "2286-dyn-object-walks.cjs": 3663, - "2300-dyn-record-spread-and-keyed-access.cjs": 3720, - "2301-cjs-export-table-dom-attach.cjs": 3384, - "2310-process-next-tick.ts": 5910, - "2311-next-tick-js-callbacks.js": 2877, - "2312-stream-underscore-assign.ts": 8104, - "2313-stream-underscore-assign-js.cjs": 4045, - "2314-process-introspection.ts": 4555, - "2320-await-unit.ts": 3726, - "2321-emitter-static-setmax.cjs": 4139, - "2322-dyn-array-sort.cjs": 3726, - "2323-timer-callback-returns.ts": 3622, - "2330-tls-server-runtime-options.cjs": 27710, - "2331-tls-server-options-typed.ts": 27128, - "2350-nan-global.ts": 4123, - "2351-async-methods.ts": 4008, - "2352-void-coercions.ts": 4044, - "2353-decorators-member-ambient.ts": 3507, - "2354-decorators-expression-ambient.ts": 3756, - "2360-tuple-to-array.ts": 3301, - "2361-assign-index-record.ts": 4658, - "2362-execsync-inherit.ts": 3671, - "2363-nullish-retag.ts": 4322, - "2364-in-runtime-key.ts": 3872, - "2365-dyn-into-island.ts": 4202, - "2366-string-well-formed.ts": 4097, - "2367-regexp-escape.ts": 2500, - "2368-set-methods.ts": 4362, - "2369-promise-try.ts": 4105, - "2370-group-by.ts": 5234, - "2371-iterator-helpers.ts": 3705, - "2380-buffer-module-named-import.ts": 3866, - "2381-builtin-default-imports.js": 3690, - "2382-cycle-two-decl/main.ts": 3053, - "2383-cycle-assertdoc/main.js": 3424, - "2384-cycle-mixed-bindings/main.ts": 3805, - "2385-builtin-reexport-facade/main.ts": 3157, - "2386-string-to-chars.ts": 3939, - "2387-tonumber-argv.ts": 2788, - "2388-tonumber-grammar-zoo.ts": 3308, - "2389-tonumber-unary-plus.ts": 4585, - "2390-dot-requires/main.cjs": 3582, - "2391-default-builtin-imports/main.ts": 3597, - "2392-block-guard-alias-scope.ts": 3540, - "2393-loop-exit-guard-narrow.ts": 4327, - "2394-loop-narrow-containment.ts": 3359, - "2395-while-cond-guard.ts": 3736, - "2396-born-narrowed-decl.ts": 3669, - "2397-branch-kill-merge.ts": 3852, - "2398-switch-arm-kill.ts": 3957, - "2399-reassign-kill-polarity.ts": 3597, - "240-stdout-write.ts": 2582, - "2400-kill-return-edge.ts": 3990, - "2401-kill-break-staging.ts": 3661, - "2402-labeled-break-kill.ts": 3719, - "2403-kill-continue-backedge.ts": 3491, - "2404-kill-throw-catch.ts": 3664, - "2405-sibling-arm-narrow.ts": 3896, - "2406-switch-clause-sibling-narrow.ts": 3538, - "2407-infinite-loop-seal.ts": 3968, - "2408-loop-terminality-reopen.ts": 3262, - "2409-loop-body-return-not-terminal.ts": 3183, - "2410-stacked-cases-terminality.ts": 4213, - "2411-exhaustive-switch-terminality.ts": 4119, - "2412-dowhile-guard-trailing-test.ts": 2693, - "2413-dowhile-kill-renarrow.ts": 3480, - "2414-dowhile-continue-kill.ts": 3748, - "2415-dowhile-break-trailing-test.ts": 3696, - "2416-spread-ternary-positions.ts": 3541, - "2417-ternary-local-inference.ts": 4012, - "2418-wrapped-ternary-arms.ts": 3646, - "2419-selector-ternary-union.ts": 4650, - "2420-nullish-null-identity.ts": 4115, - "2421-float-lane-inference.ts": 3944, - "2422-ieee-div-rem-corners.ts": 4159, - "2423-param-null-reassign.ts": 2605, - "2424-ternary-miss-first-narrowing.ts": 4261, - "2425-elseif-head-exit-narrow.ts": 2714, - "2426-default-snapshot-mutable/main.ts": 3509, - "2427-perf-hooks-now.ts": 3643, - "2428-field-redeclare-inherited.ts": 3729, - "2429-destructure-class-instance.ts": 3764, - "2430-empty-literal-unknown-field.js": 3619, - "2431-primitive-ctor-values.ts": 2975, - "2432-generic-member-fields-async.ts": 3894, - "2433-as-const-command-tables.ts": 4279, - "2434-deferred-init-fields.ts": 3904, - "2435-loose-same-kind-equality.ts": 2449, - "2440-console-inspect-args.ts": 4983, - "2441-console-process-argv.ts": 3366, - "2442-union-literal-arm-widening.ts": 3510, - "2443-union-literal-shadow-narrowing.ts": 4296, - "2444-union-literal-reducer-spread.ts": 4322, - "2445-math-minmax-nary.ts": 4287, - "2446-performance-global.ts": 2765, - "2447-island-boundary-slots/main.ts": 30163, - "2448-entries-null-arms-regex-arrays.ts": 5050, - "2450-private-instance-methods.ts": 3745, - "2451-private-fields.ts": 4055, - "2452-private-statics.ts": 4122, - "2453-private-accessors.ts": 3729, - "2454-private-generator-methods.ts": 4591, - "2455-private-brand-checks.ts": 3790, - "2456-private-async-methods.ts": 4068, - "2457-private-members.js": 3733, - "2460-qs-parse-grammar.ts": 4511, - "2461-qs-parse-options.ts": 5074, - "2462-qs-stringify.ts": 5146, - "2463-qs-escape-unescape.ts": 4740, - "2464-qs-require-forms.cjs": 3706, - "2470-mockable-module-shape.js": 4001, - "2471-record-keyed-write-hasown.js": 4306, - "2472-string-regexp-union.ts": 4333, - "2473-option-table-widths.js": 4080, - "2474-island-literal-forms.ts": 3640, - "2475-variadic-wrapper-island.js": 3607, - "2476-map-regex-values.ts": 3840, - "2480-recursive-record-tree.ts": 3961, - "2481-mutual-recursive-records.ts": 3629, - "2482-recursive-union-tree.ts": 3442, - "2483-recursive-record-cycles.ts": 3728, - "2484-json-stringify-circular.ts": 3926, - "2485-inspect-circular-refs.ts": 4207, - "2486-recursive-record-boundaries.ts": 3631, - "2487-recursive-deep-equal.ts": 4488, - "2488-ast-walker.ts": 3489, - "2490-find-miss-null-compare.ts": 3128, - "2491-strict-unit-compare-no-arm.ts": 3378, - "2492-loose-null-compare-unions.ts": 3406, - "2493-switch-unit-cases.ts": 4046, - "2494-no-arm-compare-effects.ts": 3576, - "2500-net-autosel-timeout.ts": 6361, - "2510-dyn-evolving-array-map.ts": 4082, - "2511-dyn-evolving-array-filter-foreach.ts": 4487, - "2512-dyn-evolving-array-mixed-push.ts": 3602, - "2520-private-statics-class-name-calls.ts": 3443, - "2521-private-statics-class-expression.ts": 4261, - "2522-private-statics-decorated.ts": 3872, - "2523-private-statics-aliased-class.ts": 3793, - "2530-object-destructuring-decl.ts": 3717, - "2531-array-tuple-destructuring-decl.ts": 4697, - "2532-param-destructuring-options.ts": 4524, - "2533-forof-destructuring.ts": 4725, - "2534-object-rest-decl.ts": 4160, - "2535-destructuring-assign-basics.ts": 3008, - "2536-destructuring-assign-nested.ts": 3971, - "2537-destructuring-assign-member-targets.ts": 4117, - "2538-destructuring-assign-class-source.ts": 3926, - "2539-class-instance-rest.ts": 3983, - "2540-accessor-destructuring-defaults.ts": 2587, - "2541-destructuring-eval-order.ts": 4204, - "2550-generics-keyof-pick.ts": 4104, - "2551-generics-value-aliases.ts": 3651, - "2552-generics-iface-methods.ts": 3134, - "2553-generics-signature-bindings.ts": 4036, - "2554-generics-frontier-mix.ts": 4173, - "2555-generics-keyof-writes.ts": 3734, - "2556-crypto-introspection.ts": 3814, - "2556-width-hybrid-shapes.ts": 4554, - "2557-tls-ca-store.ts": 4247, - "2557-width-field-lifts.ts": 3310, - "2558-index-signature-func-values.ts": 3316, - "2558-rejection-events.cjs": 3816, - "2559-index-signature-container-values.ts": 4363, - "2560-arraybuffer-dataview-set.ts": 4259, - "2561-object-is.ts": 3615, - "2562-intl-numberformat-en-us.ts": 4400, - "2563-stream-promises-pipeline.ts": 3735, - "2564-stream-promises-finished.ts": 8470, - "2565-stream-promises-js.cjs": 4670, - "2566-promise-reject-dyn-reason.js": 3862, - "2567-rest-spread-forward.js": 4241, - "2568-rest-spread-forward-dynamic.js": 3805, - "2569-upcast-identity.ts": 2741, - "2570-buffer-arg-validation.cjs": 5723, - "2571-searchparams-arg-validation.cjs": 4325, - "2572-readable-emitted-readable-flag.cjs": 3665, - "2573-fs-url-arg-ladders.cjs": 3433, - "2574-emitter-max-listeners-ladders.cjs": 4082, - "2575-string-destructuring-decl.ts": 4618, - "2576-string-destructuring-assign.ts": 4254, - "2577-builtin-global-destructuring.js": 3582, - "2578-jsval-into-unknown-rows.ts": 4068, - "2579-jsval-object-param-crossing.js": 4185, - "2580-jsval-routed-keyed-ops.js": 4278, - "2581-jsval-routed-calls.js": 4541, - "2582-jsval-object-statics.js": 4272, - "2582-jsval-routed-keyed-ops.js": 3765, - "2583-dyn-nullish-coalesce.js": 3622, - "2583-jsval-routed-calls.js": 4186, - "2584-jsval-object-statics.js": 3517, - "2584-union-dyn-collapse.ts": 5179, - "2585-dyn-nullish-coalesce.js": 4450, - "2585-unknown-array.ts": 4082, - "2586-object-assign-spread.js": 3285, - "2587-array-entries-forof.ts": 4350, - "2588-array-entries-chains.ts": 4523, - "2589-object-create-null.cjs": 4020, - "2590-object-create-dynamic.js": 3068, - "2591-ambient-generic-traps.ts": 4200, - "2592-ambient-trap-uncaught.ts": 3460, - "2593-generic-inert-bindings.ts": 3588, - "2594-nullish-generic-bindings.ts": 3726, - "2595-fs-arg-ladders.cjs": 6740, - "2596-net-arg-ladders.cjs": 6682, - "2597-dgram-send-ladders.cjs": 5257, - "2598-tls-arg-ladders.cjs": 28958, - "2599-stream-arg-ladders.cjs": 4068, - "2600-dyn-keyed-write-harness.js": 4122, - "2601-dyn-keyed-write-ops.js": 3049, - "2602-dyn-array-destructure.js": 3757, - "2603-island-keyed-write-dyn.js": 3437, - "2604-cycle-classes-mutual/main.ts": 3996, - "2605-cycle-three-module/main.ts": 3537, - "2606-dynamic-import-cycle/main.ts": 3810, - "2608-regex-named-groups.ts": 4091, - "2609-regex-named-replace.ts": 2758, - "2610-regex-named-matchall.ts": 4465, - "2611-regex-named-groups-js.cjs": 6008, - "2613-for-init-uninitialized-let.ts": 3817, - "2614-trap-binding-later-writes.ts": 4020, - "2615-nullish-field-record-binding.ts": 3220, - "2616-js-collect-probe-defers.js": 3633, - "2617-enum-static-field-import/main.ts": 3698, - "2618-ee-emit-override.ts": 2900, - "2619-ee-override-chain.ts": 3741, - "2620-ee-override-once-order.ts": 3799, - "2621-ee-override-error-throw.ts": 3035, - "2622-ee-override-filter.ts": 3418, - "2623-ee-job-queue.ts": 3306, - "2624-ee-override-js.cjs": 4196, - "2625-bytes-views.ts": 4141, - "2626-stream-event-names.ts": 5209, - "2627-stream-ticks-are-nextticks.ts": 3902, - "2628-stream-push-encodings.cjs": 3828, - "2629-stream-consumers.ts": 5554, - "2630-stream-consumers-errors.ts": 4330, - "2631-create-require/main.ts": 4336, - "2632-dyn-jsval-iterate.js": 4764, - "2633-island-promise-crossing.js": 5106, - "2634-stream-pipeline-arg-ladders.cjs": 3877, - "2635-trap-binding-unmappable-written.ts": 3449, - "2636-trap-binding-ambient-rooted-rewrite.ts": 4109, - "2637-create-require-bare/main.ts": 3645, - "2638-http-dyn-res-compat.cjs": 7173, - "2639-http-dyn-req-pause.cjs": 7147, - "2640-net-dyn-socket-compat.cjs": 5745, - "2641-http-agent-surface.cjs": 7414, - "2642-http-agent-maxsockets.cjs": 4580, - "2643-or-default-retag.ts": 4099, - "2644-http-client-url-argument.ts": 4758, - "2645-https-client-url-argument.ts": 45938, - "2646-top-level-await.ts": 3701, - "2647-top-level-await-modules/main.ts": 4075, - "2648-top-level-await-rejection.ts": 3331, - "2649-top-level-await-pending.ts": 3587, - "2650-top-level-await-self-import.ts": 3982, - "2651-top-level-await-pending-unhandled.ts": 3896, - "2652-top-level-await-dynamic/main.ts": 3670, - "2653-top-level-await-rejection-stops-loop.ts": 3674, - "2654-top-level-await-unrelated-rejection.ts": 4358, - "2655-top-level-await-cycle/main.ts": 3663, - "2656-top-level-await-cycle-order/main.ts": 3641, - "2657-top-level-await-cycle-dynamic/main.ts": 3605, - "2658-top-level-await-sync-completion/main.ts": 3738, - "2659-top-level-await-dynamic-cycle/main.ts": 3937, - "2660-top-level-await-cycle-rejection/main.ts": 3839, - "2661-top-level-await-dynamic-runtime-root/main.ts": 4277, - "2662-top-level-await-cycle-external-wait/main.ts": 3840, - "2663-top-level-await-dependency-errors/main.ts": 4026, - "2664-top-level-await-same-checkpoint-rejection.ts": 3900, - "2665-top-level-await-unhandled-listener-liveness.ts": 3124, - "2666-array-to-sorted.ts": 7343, - "2668-stored-number-array-iterator.ts": 4155, - "2669-array-copying-methods.ts": 4893, - "2670-uint8array-copy-iterate.ts": 4534, - "2671-array-copying-js.cjs": 4071, - "2672-http-request-response-callback.ts": 25478, - "2673-top-level-await-implicit-module.ts": 3661, - "2674-top-level-for-await-implicit-module.ts": 4714, - "2675-create-require-nested-esm.js": 3731, - "2675-process-self-reexec.ts": 3793, - "2676-indexed-read-strict-equality.ts": 3177, - "2676-record-clone-overrides.ts": 3884, - "2676-top-level-await-ambiguous/main.ts": 3335, - "2677-runtime-optional-closure.ts": 4747, - "2677-top-level-await-module-scope/main.ts": 2879, - "2678-date-instances.ts": 3537, - "2678-large-string-sparse-index.ts": 3659, - "2678-util-parseargs.ts": 8501, - "2679-util-parseargs-cjs.cjs": 5362, - "2680-util-parseargs-default.ts": 3698, - "2681-util-parseargs-dynamic.js": 5047, - "2682-fs-rename.ts": 4318, - "2683-filter-truthy-predicate.ts": 4083, - "2683-fs-rename-js.cjs": 4168, - "2684-filter-no-predicate-dyn.cjs": 3139, - "2684-fs-rename-abort.ts": 3244, - "2685-array-unshift-reverse.ts": 3752, - "2685-fs-write-sync.ts": 3562, - "2686-fs-file-handle.ts": 5916, - "2687-fsp-write-file-options.ts": 4133, - "2687-process-write-args.ts": 3739, - "2688-fs-stats-disk-fields.ts": 4196, - "2689-http-server-timeout-properties.ts": 9510, - "2690-https-server-timeout-option.ts": 26255, - "2691-retained-lowering-record-order.ts": 5714, - "2692-inline-record-assert-index.ts": 4256, - "2692-string-accumulation.ts": 4000, - "2693-math-constants.ts": 3814, - "2700-array-sort-complexity.ts": 4128, - "2700-http-static-trailers.ts": 3673, - "2700-wasi-core.ts": 3941, - "2701-array-sort-snapshot.ts": 5063, - "2701-http-static-trailer-wire.ts": 4002, - "2701-import-meta/main.mjs": 4298, - "2702-http-static-trailer-end.ts": 4488, - "2702-type-import-link-static/main.ts": 3632, - "2702-uint8array-to-sorted.ts": 4201, - "2703-array-sparse-sort.ts": 7778, - "2703-type-import-link-static-reexport/main.ts": 3591, - "2704-array-sparse-to-sorted.ts": 8196, - "2704-type-import-link-static-success/main.ts": 3547, - "2705-array-sparse-sort-append.ts": 6478, - "2705-type-import-link-dynamic/main.ts": 3402, - "2706-array-search-missing-needle.ts": 4264, - "2706-type-import-link-dynamic-success/main.ts": 3801, - "2707-array-search-huge-sparse.ts": 45112, - "2707-type-import-link-static-default-reexport/main.ts": 3162, - "2708-type-import-link-dynamic/main.ts": 2849, - "2720-array-read-parity.ts": 4418, - "2721-array-nested-missing-receiver.ts": 4224, - "2750-array-sparse-foundation.ts": 3486, - "2751-buffer-concat-sparse-list.ts": 3809, - "2752-array-optional-stores.ts": 3893, - "2753-array-optional-method-values.ts": 4447, - "2754-array-property-undefined.ts": 3437, - "2755-array-optional-literal-forwarding.ts": 3309, - "2780-array-parity-composition.ts": 11152, - "2781-array-missing-value-escape.ts": 3766, - "2782-array-sparse-callbacks.ts": 4827, - "2783-array-defaults-rest.ts": 3752, - "2784-array-reduce-missing-result.ts": 3900, - "2785-array-missing-destructuring.ts": 4350, - "2786-array-sparse-serialization.ts": 4399, - "2787-array-missing-string-arithmetic.ts": 3532, - "2788-array-missing-builtin-conversions.ts": 2629, - "2789-array-missing-optional-tostring.ts": 4012, - "2790-dynamic-import-self-name/main.ts": 3567, - "2791-record-optional-keys.ts": 4180, - "2792-record-optional-spread-entries.ts": 3957, - "2793-union-conversion-identity-capture.ts": 4016, - "2794-array-generic-callback-values.ts": 3192, - "2795-array-optional-typedarray-source.ts": 39238, - "2796-array-sparse-class-value-instanceof.ts": 3057, - "2800-array-expression-consumers.ts": 3984, - "2801-array-switch-consumers.ts": 3844, - "2820-array-missing-method-receivers.ts": 4015, - "2821-array-optional-numeric-comparisons.ts": 3715, - "2830-cjs-require-self-name/main.cjs": 3843, - "2840-finally-completions.ts": 3843, - "2841-using-sync.ts": 3805, - "2842-await-using.ts": 3336, - "2843-using-suppressed-error.ts": 3417, - "2844-node-disposable-resources.ts": 4668, - "2845-for-using-of.ts": 3487, - "2846-generator-using.ts": 4293, - "2850-async-generators-protocol.ts": 4610, - "2851-async-generators-values.ts": 4267, - "2852-timers-promises-interval.ts": 3195, - "2854-leading-bom-literals.ts": 3717, - "2855-searchparams-sort-complexity.ts": 3679, - "2856-dynamic-any-local-operators.ts": 3601, - "2857-branded-primitives.ts": 3846, - "2858-import-meta-resolve/main.mjs": 3869, - "2859-import-meta-resolve-dynamic/main.mjs": 3441, - "2860-require-resolve/main.cjs": 3856, - "2861-readable-iterator-close.ts": 8658, - "2862-web-readable-async-iteration.ts": 60491, - "2863-class-async-iterator.ts": 3807, - "2864-array-class-method-receivers.ts": 3808, - "2865-cjs-process-alias.cjs": 3058, - "2866-dyn-switch.ts": 4091, - "2867-array-shift-length.js": 3560, - "2868-empty-record-promise-presence.js": 3622, - "2869-nullish-mixed-lazy.ts": 3214, - "2870-and-dropped-truthy-arm.ts": 3668, - "2871-optional-promise-to-unknown.ts": 3151, - "2872-unobserved-dynamic-event.ts": 3479, - "2873-optional-receiver-loop-lifetime.js": 3838, - "2874-nullable-callback-field-cycle.js": 3416, - "2875-evolving-let-read-before-write.js": 3393, - "2876-class-unknown-roundtrip.ts": 3172, - "2877-child-unknown-roundtrip.ts": 3088, - "2878-class-private-unknown.cjs": 3951, - "2880-cjs-module-graph/main.cjs": 4546, - "2890-crypto-static-utility.ts": 4147, - "2891-json-record-key-escapes.ts": 4489, - "2892-windows-console-unicode.ts": 3631, - "2893-child-stdin-duplex.ts": 4001, - "2894-child-stdin-backpressure.ts": 3911, - "2895-child-stdin-write-after-end.ts": 4040, - "2896-child-stdin-write-after-finish.ts": 4046, - "2897-child-stdin-destroy.ts": 4182, - "2898-child-stdin-spawn-failure.ts": 3819, - "2899-nested-mutual-recursion.ts": 3391, - "2900-float64array-static.ts": 4170, - "2900-void-conditional-arrow.ts": 2973, - "2901-bigint-core.ts": 3785, - "2902-bigint-bytes.ts": 3878, - "2903-bigint-storage.ts": 4174, - "2904-bigint-errors.ts": 3154, - "2905-bigint-edges.ts": 3535, - "2906-bigint-wasi-width.ts": 3636, - "2910-overloaded-callable-alias.ts": 3507, - "2911-execfile-callback.ts": 3775, - "2912-execfile-callback-options.ts": 3546, - "2912-promisify-fs-readfile.ts": 3527, - "2913-builtin-callable-alias.ts": 5224, - "2914-fixed-tuple-call-spread.ts": 4266, - "2915-path-function-values.ts": 4335, - "2916-path-function-values-cjs.ts": 3661, - "2917-builtin-callable-widths.ts": 4692, - "2918-builtin-callable-widths-cjs.ts": 3911, - "2919-fs-function-values.ts": 3993, - "2920-fs-promises-function-values.ts": 3700, - "2921-zlib-callbacks.ts": 4702, - "2922-dyn-bitwise-not.cjs": 3792, - "2923-cjs-factory-export/main.cjs": 3686, - "2930-union-receiver-calls.ts": 4496, - "2931-union-dynamic-field-call.js": 3249, - "2932-create-require-program/main.ts": 4121, - "2933-static-dynamic-import/main.ts": 3790, - "2934-static-import-stored.ts": 2637, - "2935-module-namespace-values/main.ts": 4033, - "2936-static-loose-equality.ts": 4807, - "2937-bitwise-hot-loop.ts": 3730, - "2938-fs-sync-overloads.cjs": 2978, - "2939-child-shell-text.ts": 4396, - "2940-date-parse.ts": 3909, - "2940-fsp-realpath.ts": 3670, - "2941-fsp-lstat-identity.ts": 4973, - "2941-process-exit-code.ts": 2597, - "2942-fsp-readdir-dirent.ts": 3959, - "2942-process-exit-code-override.ts": 3773, - "2943-process-exit-code-invalid.ts": 3459, - "2944-process-exit-code-wrap.ts": 4312, - "2945-url-origin-username.ts": 2754, - "2946-child-fork-ipc/main.ts": 4571, - "2946-url-port-hash.ts": 3017, - "2947-set-readonly-seeds.ts": 3976, - "2948-child-fork-eof-callback/main.ts": 4009, - "2948-stdio-callback-record.ts": 2902, - "2949-child-fork-default/main.mjs": 3935, - "2949-url-password.ts": 3040, - "2950-fs-descriptor-publication.ts": 2555, - "2951-math-static-analytic.ts": 4273, - "2952-math-static-remaining.ts": 3480, - "2953-http-header-validation.ts": 6668, - "2954-http-outgoing-headers.ts": 4292, - "2955-http-static-state.ts": 3942, - "2956-http-static-informational.ts": 8174, - "2957-http-static-response-controls.ts": 4254, - "2961-emitter-computed-names.cjs": 2876, - "2962-emitter-computed-optional.ts": 3963, - "2963-child-fork-dispatch/main.ts": 3170, - "2964-indexed-compound.ts": 4621, - "2966-numeric-array-read-fusion.ts": 3495, - "2967-numeric-array-read-lifetime.ts": 3370, - "2968-numeric-array-borrow.ts": 4623, - "2969-scalar-record-results.ts": 3919, - "2970-constant-numeric-tables.ts": 2953, - "2971-constant-table-modules/main.ts": 2780, - "2972-http-static-distinct-snapshots.ts": 7024, - "2972-math-receiver-borrow.ts": 4560, - "2973-http-static-agent.ts": 8993, - "2973-integer-bitwise-arithmetic.ts": 3843, - "2974-array-search-from-index.ts": 102834, - "2974-http-static-module-values.ts": 6368, - "2974-numeric-remainder.ts": 4108, - "2975-bigint-default-radix.ts": 3498, - "2975-http-static-client-controls.ts": 3623, - "2976-http-static-incoming-state.ts": 2971, - "2976-json-stringify-no-arguments.js": 3696, - "2977-http-static-incoming-timeout.ts": 4074, - "2977-nested-array-binding-defaults.js": 4142, - "2978-http-static-client-timeout.ts": 9714, - "2978-regexp-optional-subject.js": 49628, - "2979-array-search-mixed-needles.js": 4303, - "2979-http-static-server-timeout.ts": 6006, - "2980-http-static-server-timeout-default.ts": 7270, - "2980-string-position-arguments.js": 3086, - "2981-http-static-events.ts": 3123, - "2981-string-optional-positions.ts": 3368, - "2982-http-static-close-all.ts": 3822, - "2982-string-position-coercion-order.js": 3928, - "2983-http-static-close-idle.ts": 3614, - "2984-http-static-close-upgrade.ts": 3907, - "2985-http-static-message-destroy.ts": 3388, - "2986-http-static-client-socket-finish.ts": 3798, - "2987-http-static-timeout-errors.ts": 4096, - "2988-http-static-client-abort.ts": 2850, - "2989-http-static-response-timeout-handled.ts": 3345, - "2990-http-static-request-timeout-handled.ts": 4813, - "2991-array-indexed-equality.ts": 4275, - "2992-stream-rows.ts": 3533, - "2993-fiber-stack-lifetimes.ts": 4327, - "2994-fromcharcode-scalar.ts": 4187, - "2995-math-hyperbolic.ts": 4005, - "2996-math-near-one.ts": 4413, - "2997-math-integer-float.ts": 3945, - "300-if-else.ts": 4350, - "3001-caught-typeof-object.js": 3508, - "3002-promise-then-two.ts": 4636, - "301-while.ts": 3775, - "302-for.ts": 3729, - "3020-string-last-index-position.ts": 2972, - "3021-buffer-union-narrow-callback.ts": 3784, - "3022-string-affix-positions.ts": 3752, - "3023-string-affix-position-coercion.js": 3717, - "3024-string-number-narrow-for-in.ts": 4025, - "3025-string-search-position-coercion.js": 2818, - "3026-array-last-index-of.js": 4346, - "3027-array-last-index-of-records.ts": 2717, - "3028-string-search-dynamic-needle.js": 3694, - "3029-string-search-union-needle.js": 3379, - "303-break-continue.ts": 3648, - "3030-array-search-no-arg.js": 3591, - "3031-array-relative-index-coercion.js": 3587, - "3031-string-last-index-search-value.js": 4017, - "3032-string-search-value.js": 3564, - "3033-string-search-needle-coercion.js": 3378, - "3034-arguments-with-parameters.js": 3967, - "3035-string-positioned-search-value.js": 3417, - "3036-string-object-search-value.js": 3926, - "3037-number-nullish-conversion.js": 4703, - "3038-number-scalar-unions.ts": 3646, - "3039-string-repeat-count.js": 3646, - "304-compound-incdec.ts": 3722, - "3040-string-prototype-call.js": 4670, - "3041-string-prototype-object-call.js": 3431, - "3042-string-padding-coercion.js": 3284, - "3043-string-split-arguments.js": 3505, - "3044-array-slice-splice-positions.js": 3592, - "3045-array-indexed-mutation.js": 3564, - "3046-array-indexed-ref-identity.ts": 4051, - "3047-object-prototype-tag.js": 4202, - "3048-object-own-prototype.ts": 4672, - "3049-array-flat-depth.ts": 3327, - "305-truthiness.ts": 3686, - "3050-array-splice-insert.ts": 4238, - "3051-array-join-default.ts": 3649, - "3052-array-construction.ts": 5275, - "3053-array-construction-js.js": 4051, - "3054-dynamic-abort-record.ts": 31946, - "3055-default-builtin-nodenext/main.ts": 3742, - "3056-default-builtin-bundler/main.ts": 3900, - "3057-default-builtin-nodenext-dynamic/main.ts": 3548, - "3058-optional-array-chain-join.ts": 4351, - "3059-arguments-property-names.ts": 3823, - "3061-concurrent-fiber-stacks.ts": 4696, - "3062-runtime-optional-record-guards.ts": 4448, - "3063-runtime-optional-class-guards.ts": 4574, - "3064-installed-entry-imports/main.ts": 3681, - "3065-installed-entry-js/main.js": 3134, - "3066-source-debugging/main.ts": 3285, - "3067-cjs-function-export-require/main.cjs": 3758, - "3068-debug-variables/main.ts": 3691, - "3068-url-checked-identity.ts": 3668, - "3069-set-checked-seed.js": 3693, - "3069-tuple-spread.ts": 4624, - "3070-checked-object-accessors.js": 4486, - "3070-collection-views.ts": 3364, - "3071-checked-specialization-narrowing.js": 3480, - "3071-map-contextual-record-seeds.ts": 3949, - "3072-optional-union-receivers.ts": 5187, - "3072-weak-process-streams.js": 3596, - "3073-optional-callable-module.js": 2912, - "3073-union-keyed-reads.ts": 4086, - "3074-discriminated-intersections.ts": 3579, - "3075-recursive-contextual-literals.ts": 4053, - "3076-nullish-record-defaults.ts": 4277, - "3077-optional-union-array-reads.ts": 3951, - "3078-forward-mutable-captures.ts": 4480, - "3079-forward-mutable-tdz.ts": 4237, - "3080-exhaustive-never-bindings.ts": 3901, - "3081-recursive-array-destinations.ts": 4116, - "3082-forward-write-unwind.ts": 3019, - "3083-set-string-seed.ts": 4323, - "3084-record-own-membership.ts": 4601, - "3085-conditional-record-construction.ts": 4376, - "3086-error-constructor-options.ts": 4642, - "3087-error-options-lifetime.ts": 3925, - "3088-array-wide-callbacks.ts": 4497, - "3089-array-find-narrowing.ts": 4974, - "3090-json-discriminated-records.ts": 4438, - "3091-json-recursive-discriminants.ts": 5400, - "3092-number-union-predicates.ts": 3730, - "3093-error-option-data.ts": 2865, - "3094-json-replacer-traversal.ts": 4373, - "3095-json-reviver-traversal.ts": 4032, - "3096-json-callback-nonfinite.ts": 3197, - "3097-json-callback-reentrancy.ts": 3379, - "3098-json-callback-space.ts": 3597, - "3099-json-callback-functions.ts": 4206, - "3100-json-callback-holder.js": 4588, - "3101-json-callback-bytes.ts": 4349, - "3102-json-unknown-fields.ts": 3200, - "3103-scalar-record-nested-control-flow.ts": 4214, - "3104-native-analysis-tables-loops.ts": 2623, - "3105-nullable-collections.ts": 4138, - "3106-mixed-insertion-spreads.ts": 3715, - "3107-nullable-collection-lifetimes.ts": 4148, - "3108-for-await-sync-arrays.js": 6166, - "3108-identity-map-keys.ts": 4867, - "3109-destructuring-unknown-defaults.js": 4021, - "3109-identity-union-collections.ts": 5097, - "3110-builtin-error-families.ts": 3559, - "3110-identity-collection-mutation.ts": 3934, - "3111-identity-collection-cycles.ts": 3848, - "3112-union-switch-control-flow.ts": 3478, - "3113-union-array-removal.ts": 4714, - "3114-union-record-field-write.ts": 3240, - "3115-zlib-static-compression-levels.ts": 4206, - "3116-sequence-expression-lifetimes.ts": 4356, - "3117-unknown-switch-control-flow.ts": 3816, - "3118-recursive-union-spread.ts": 4372, - "3119-runtime-optional-spread.ts": 4825, - "3120-dynamic-property-descriptors.js": 3522, - "3120-generator-method-loop-bindings.ts": 4192, - "3120-ir-nonfinite-numbers.ts": 4200, - "3121-compound-assignment-values.js": 3684, - "3121-dynamic-accessor-descriptors.js": 4951, - "3122-dynamic-delete-descriptors.cjs": 4063, - "3122-dynamic-delete-descriptors.js": 3650, - "3122-js-async-class-methods.js": 4320, - "3123-destructured-global-tdz.js": 3748, - "3124-array-prototype-borrow.js": 4580, - "3125-regex-global-match.ts": 2619, - "3126-js-number-radix/main.ts": 4047, - "3127-spawn-runtime-options.ts": 4379, - "3128-regex-last-index.ts": 4682, - "3129-js-token-union/main.ts": 4567, - "3130-child-generic-streams.ts": 4888, - "3131-child-rest-listeners.js": 2682, - "3132-child-generic-stream-completion.ts": 9689, - "3133-text-decoder-streaming.ts": 21112, - "3134-fs-vectors.ts": 3917, - "3135-fs-file-handle-controls.ts": 5050, - "3136-fs-file-handle-options.ts": 5320, - "3137-fs-vector-callbacks.cjs": 5540, - "3138-array-large-storage.ts": 6344, - "3139-regex-native-deep-alternatives.ts": 31598, - "3140-array-dense-access.ts": 6506, - "3141-map-string-key-hash.ts": 4564, - "3150-integer-remainder.ts": 4200, - "3151-array-push-writes.ts": 4614, - "3170-number-conversion-fast-paths.ts": 4996, - "3171-method-census-data-writes.ts": 4891, - "400-fib.ts": 4470, - "401-mutual-recursion.ts": 3443, - "402-string-functions.ts": 3554, - "403-void-and-params.ts": 2749, - "4030-runtime-object-truthiness.ts": 2971, - "4031-event-emitter-long-tuples.ts": 3712, - "4032-inline-rc-fast-paths.ts": 6866, - "404-rc-stress.ts": 3585, - "4040-adapted-function-identity.ts": 3063, - "4041-adapted-function-properties.ts": 4165, - "4042-object-is-union-subclass.ts": 3846, - "4043-nonnull-missing-element.ts": 3736, - "4044-adapted-callback-modules/main.ts": 4121, - "4045-optional-element-projections.ts": 4159, - "4046-captured-parameter-values.ts": 3178, - "4047-captured-parameter-rebinding.ts": 4100, - "405-params-optional.ts": 3985, - "406-params-defaults.ts": 3592, - "4060-cycle-shared-instance/main.ts": 3695, - "4060-stack-union-reads.ts": 5003, - "4061-cycle-evaluation-order/main.ts": 3985, - "4061-nullable-ref-fields.ts": 7201, - "4062-cycle-tdz-read/main.ts": 3866, - "4063-cycle-hoisted-calls/main.ts": 3773, - "4064-cycle-classes-after-init/main.ts": 3673, - "4065-cycle-init-throws/main.ts": 3693, - "4066-cycle-top-level-tdz/main.ts": 3937, - "4067-dynamic-import-cycle-tdz/main.ts": 4237, - "407-params-rest.ts": 4125, - "408-params-ctors-inheritance.ts": 3692, - "4080-optional-read-presence-tests.ts": 3038, - "4080-string-index-bounds.ts": 3844, - "4081-hoisted-function-tdz.ts": 3262, - "4081-string-index-unproven.ts": 4125, - "4082-hoisted-function-tdz-uncaught.ts": 2818, - "4083-dynamic-import-failure/main.ts": 3160, - "4084-record-optional-field-copies.ts": 5146, - "4085-generator-loop-close.ts": 4113, - "4086-optional-capture-defaults.ts": 3684, - "4088-class-static-tdz.ts": 3477, - "4089-class-wrapper-tdz.js": 2771, - "409-params-async-generics.ts": 4030, - "4090-computed-key-tdz.js": 3578, - "4091-class-evaluation-deferred.ts": 4329, - "410-params-rc-stress.ts": 4376, - "4140-array-callback-split-visit.ts": 7471, - "4141-array-callback-ambient-receiver/main.ts": 3909, - "4142-array-callback-factories.ts": 3472, - "4143-union-refinement-intersection-arms.ts": 3347, - "420-dead-strip-modules/main.ts": 3742, - "4290-acyclic-immutable-trees.ts": 4974, - "4291-acyclic-constructor-escapes.ts": 4252, - "4292-acyclic-readonly-bypass.ts": 4530, - "4293-acyclic-dynamic-writes.ts": 4090, - "4294-console-line-sizes.ts": 7343, - "4295-console-template-parts.ts": 3542, - "4296-console-glued-long-parts.ts": 5181, - "4410-inline-object-allocation.ts": 4560, - "4411-nullable-ref-values.ts": 6207, - "4412-nullable-record-values.ts": 5237, - "4413-cycle-old-late-death.ts": 5172, - "4413-nullable-null-and-undefined.ts": 4068, - "4414-cycle-old-weak-keys.ts": 4401, - "4414-nullable-string-values.ts": 7453, - "4415-identity-borrowed-operands.ts": 3629, - "4415-nullable-container-values.ts": 5776, - "4431-exception-pending-contexts.ts": 4992, - "4432-checked-downcast-failures.ts": 4520, - "4451-int32-field-storage.ts": 4554, - "4452-int32-field-dynamic-writes.ts": 4987, - "4453-int32-closed-locals.ts": 4516, + "001-hello.ts": 38244, + "002-log-args.ts": 31270, + "100-number-format.ts": 45195, + "1000-json-stringify-basics.ts": 46332, + "1001-json-escapes-unicode.ts": 4513, + "1002-json-parse-cast.ts": 35521, + "1003-json-parse-unions.ts": 3512, + "1004-json-parse-errors.ts": 3903, + "1005-json-nested.ts": 3425, + "1006-json-fs-config.ts": 3347, + "1007-json-rc-stress.ts": 34305, + "1008-json-null-arms.ts": 3422, + "1009-json-optional-fields.ts": 4004, + "101-arithmetic.ts": 4655, + "1010-json-stringify-space.ts": 45417, + "1011-json-unknown-typeof.ts": 4001, + "102-comparisons.ts": 3774, + "1020-async-basics.ts": 3697, + "1021-async-ordering.ts": 3078, + "1022-async-exceptions.ts": 3780, + "1023-async-rc-stress.ts": 3889, + "1024-async-pending-exit.ts": 3389, + "1025-async-promise-capture.ts": 42296, + "1026-throw-promise.ts": 4482, + "1027-async-return-promise.ts": 3534, + "1028-async-return-record-literals.ts": 3843, + "1029-async-eager-chains.ts": 4890, + "103-ternary.ts": 3470, + "104-ternary-empty-arrays.ts": 7056, + "1050-comptime-tables.ts": 4643, + "1051-comptime-strings.ts": 42895, + "1052-comptime-records.ts": 44375, + "1053-comptime-json.ts": 4497, + "1054-comptime-modules/main.ts": 4326, + "110-number-radix.ts": 3100, + "111-record-entries.ts": 7961, + "1110-math-members.ts": 3457, + "1111-math-random.ts": 4321, + "1113-string-methods.ts": 23286, + "1114-string-unicode-island.ts": 45718, + "1115-parse-globals.ts": 3277, + "1116-island-static-mix.ts": 3738, + "1117-typeof-static-union.ts": 4351, + "1118-object-spread-conditional.ts": 3602, + "1119-switch-union.ts": 4833, + "112-class-descriptor-key.js": 4674, + "1121-infinity-number-tostring.ts": 4470, + "1122-any-captures.ts": 7125, + "1124-union-narrowed-retag.ts": 3484, + "113-promise-checked-exits.ts": 4562, + "114-live-record-delete.ts": 3572, + "115-array-compound.js": 6457, + "116-text-decoder-runtime.js": 33483, + "117-weak-cache-cycle.js": 5789, + "118-fs-stored-callbacks.cjs": 52946, + "119-native-patterns.js": 6101, + "1200-regex-test-basics.ts": 47554, + "1201-regex-replace.ts": 3959, + "1202-regex-substitutions.ts": 3855, + "1203-regex-split.ts": 31517, + "1204-regex-empty-unicode.ts": 4662, + "1205-regex-rc-stress.ts": 36658, + "1300-errors-basics.ts": 4354, + "1301-errors-subclass.ts": 4687, + "1302-errors-typed-catch.ts": 4229, + "1303-errors-rc-stress.ts": 3431, + "1304-errors-uncaught.ts": 3763, + "1305-errors-async-rejections.ts": 4254, + "1306-errors-runtime-instances.ts": 4140, + "1350-path-normalize-join.ts": 4224, + "1351-path-parts.ts": 4167, + "1352-path-resolve-relative.ts": 4382, + "1353-os-basics.ts": 4007, + "1354-builtin-bare-specifiers.ts": 3999, + "1355-url-parse.ts": 3346, + "1356-url-file-bridge.ts": 3553, + "1357-fsp-roundtrip.ts": 4325, + "1358-crypto-random.ts": 3398, + "1359-json-module/main.ts": 4414, + "1360-spawn-sync.ts": 4387, + "1361-spawn-events.ts": 4260, + "1362-spawn-timers.ts": 9971, + "1363-spawn-unhandled-error.ts": 3744, + "1364-union-truthiness.ts": 3907, + "1365-union-logical.ts": 4258, + "1366-union-equality.ts": 3058, + "1367-destructuring.ts": 5461, + "1368-constructor-functions.ts": 3781, + "1369-promise-union.ts": 3864, + "1370-spread.ts": 3429, + "1371-union-template-tostring.ts": 3265, + "1372-loose-null-tests.ts": 3885, + "1373-union-array-arms.ts": 3435, + "140-bitwise-operators.ts": 4527, + "1400-typedarray-basics.ts": 5395, + "1401-typedarray-slice-set.ts": 3626, + "1402-buffer-encodings.ts": 4871, + "1403-buffer-fs.ts": 4268, + "1404-zlib-crypto-bytes.ts": 5331, + "1405-bytes-unions-arrays.ts": 3838, + "1406-dataview-mp4.ts": 3661, + "1407-dataview-bounds.ts": 5553, + "1408-string-indexing.ts": 5392, + "1409-typedarray-integer-loops.ts": 4558, + "1420-number-statics.ts": 3886, + "1421-number-parse-strings.ts": 4644, + "1422-date-iso.ts": 4015, + "1423-text-codec.ts": 38476, + "1424-fs-options.ts": 3473, + "1425-stdin-tty.ts": 4093, + "1426-stdin-read.ts": 3982, + "1427-fromcharcode-lastindexof.ts": 2946, + "1428-settled-await-order.ts": 3794, + "1429-promise-catch-finally.ts": 4465, + "1430-promise-race.ts": 4414, + "1431-caught-tostring.ts": 2971, + "1432-destructured-params.ts": 3941, + "1433-filter-narrow.ts": 3907, + "1434-async-never.ts": 3465, + "1435-math-spread.ts": 3652, + "1436-default-undef-param.ts": 3877, + "1437-pad-default.ts": 3475, + "1438-promise-all.ts": 7297, + "1440-interval-basics.ts": 4144, + "1441-interval-clear-cross.ts": 7176, + "1442-interval-throw.ts": 3609, + "1443-signal-handlers.ts": 7600, + "1444-exit-listeners.ts": 4768, + "1445-exit-process-exit.ts": 5403, + "1446-exit-uncaught.ts": 4319, + "1447-stdin-closed-events.ts": 4894, + "1448-stream-columns.ts": 4014, + "1450-incdec-expression.ts": 3639, + "1451-instanceof-uint8array-unknown.ts": 3654, + "1452-return-through-finally.ts": 4057, + "1453-pmap-settled.ts": 4531, + "1454-nonnull-narrow-and-fcc-bytes.ts": 3459, + "1455-lambda-union-return-adoption.ts": 3583, + "1460-console-error-warn.ts": 3484, + "1461-process-pid-getuid-kill.ts": 3345, + "1462-exec-sync.ts": 5307, + "1463-timeout-unref.ts": 3316, + "1464-env-writes.ts": 3946, + "1465-env-value.ts": 3554, + "1466-child-containers.ts": 4064, + "1467-string-match.ts": 3329, + "1468-exec-path.ts": 3588, + "1469-remove-listener.ts": 5747, + "1470-child-lifecycle.ts": 2972, + "1471-child-unref.ts": 8472, + "1472-errno-code.ts": 3388, + "1473-promisify-execfile.ts": 5200, + "1474-string-decoder.ts": 3868, + "1475-readline-closed-stdin.ts": 3587, + "1476-assign-expression.ts": 4319, + "1477-in-expressions.ts": 3951, + "1478-promise-reject.ts": 4331, + "1479-destructuring-assign.ts": 3821, + "1480-os-network-interfaces.ts": 4186, + "1481-string-case-static.ts": 2782, + "1482-spawnsync-error.ts": 2721, + "1483-array-slice.ts": 52661, + "1520-fs-wider-surface.ts": 3691, + "1520-string-split-static.ts": 3432, + "1521-fs-lstat-lock.ts": 3409, + "1521-string-trim-pad-static.ts": 4078, + "1522-parseint-static.ts": 3461, + "1522-spawnsync-options.ts": 5773, + "1523-isnan-floor-static.ts": 3552, + "1523-spawn-options.ts": 5294, + "1524-atomics-sleep-static.ts": 4028, + "1524-catch-narrowing.ts": 2626, + "1525-child-exit-signal.ts": 3477, + "1525-unknown-typeof-validation.ts": 2889, + "1526-set-spread.ts": 3802, + "1527-logical-mixed-operands.ts": 4773, + "1528-delete-records-env.ts": 3621, + "1529-class-with-statics.ts": 3381, + "1530-array-push-variadic.ts": 2970, + "1530-spread-override-completion.ts": 2499, + "1531-delete-optional-fields.ts": 3623, + "1531-process-arch-versions.ts": 2740, + "1532-array-splice-shift.ts": 4204, + "1532-union-shared-field-read.ts": 2834, + "1533-bool-equality.ts": 4076, + "1533-path-platform-namespaces.ts": 3406, + "1534-crypto-hash-chain.ts": 4097, + "1534-union-as-arm-cast.ts": 45787, + "1535-spawn-fd-stdio.ts": 3840, + "1535-union-param-defaults.ts": 4358, + "1536-destructuring-defaults.ts": 3812, + "1536-string-array-sweep.ts": 3859, + "1537-chalk-hybrid/main.ts": 4683, + "1537-os-release-spawnsync-stdio.ts": 2674, + "1538-await-promiselike-return.ts": 2642, + "1538-math-static-scalar.ts": 3735, + "1539-readonly-set-map.ts": 3299, + "1539-unknown-truthiness.ts": 3045, + "1540-os-userinfo.ts": 4119, + "1540-void-statement.ts": 2941, + "1541-fs-readdir-dirent.ts": 5432, + "1541-union-keyed-reads.ts": 4646, + "1542-map-promise-values.ts": 33000, + "1542-record-literal-into-union.ts": 2885, + "1543-rest-destructuring.ts": 3500, + "1543-set-server-handles.ts": 6770, + "1544-dyn-json-reads.ts": 4863, + "1544-string-matchall.ts": 4770, + "1545-spread-order-and-optional.ts": 4536, + "1546-union-element-reads.ts": 4536, + "1547-computed-key-fold.ts": 3960, + "1548-boolean-condition-forms.ts": 4649, + "1549-array-isarray-unions.ts": 4084, + "1550-param-defaults-func-set.ts": 3020, + "1551-dyn-receiver-methods.ts": 3403, + "1552-exec-options-record.ts": 2877, + "1553-truthy-hof-predicates.ts": 3895, + "1554-caught-into-unknown.ts": 3417, + "1555-index-spread-into-declared.ts": 4534, + "1556-union-retag-width-arms.ts": 3587, + "1557-url-host.ts": 2566, + "1558-any-joins-and-dyn-validation.ts": 33883, + "1559-conditional-spread-index-merge.ts": 3282, + "1560-forof-homogeneous-tuples.ts": 3680, + "1561-forof-strings.ts": 2878, + "1561-promise-then.ts": 3851, + "1562-optional-chain-tails.ts": 4618, + "1562-spawn-conditional-spread.ts": 4043, + "1563-forof-iterator-projections.ts": 3930, + "1563-string-raw-fold.ts": 3100, + "1564-fs-watch.ts": 4051, + "1564-string-raw.ts": 3075, + "1565-spawn-pipe-streams.ts": 3895, + "1565-union-element-join.ts": 4167, + "1566-child-duck-interface.ts": 3875, + "1567-server-close-override.ts": 3304, + "1568-x509-fingerprint.ts": 2839, + "1569-fsp-mkdir-unlink-chmod.ts": 3012, + "1570-child-unref-kill-reffed.ts": 9046, + "1571-optional-call-tostring-tail.ts": 26380, + "1571-stdin-set-raw-mode-non-tty.ts": 4151, + "1572-promise-reject-all-tuple.ts": 4201, + "1572-x509-validity-date-gettime.ts": 3944, + "1573-promisify-execfile-env-spread.ts": 4480, + "1573-tdz-scalar-forward-capture.ts": 2862, + "1574-dyn-optional-method-number-keys.ts": 3192, + "1574-promise-all-tuple-literal.ts": 4410, + "1575-unknown-assert-into-record.ts": 3424, + "1576-width-coercions.ts": 4144, + "1577-url-hostname.ts": 4030, + "1578-exec-input-optional.ts": 4028, + "1579-matchall-index.ts": 4108, + "1580-exec-env-conditional-spread.ts": 3516, + "1581-declare-const-read.ts": 3997, + "1582-timer-sleep-resolve.ts": 4177, + "1583-loops-and-stream-captures.ts": 4450, + "1584-union-field-unassigned.ts": 3964, + "1585-union-field-conditional-ctor.ts": 3070, + "1586-derived-field-before-super-init.ts": 4073, + "1590-js-unannotated.js": 4738, + "1591-js-closures.js": 3535, + "1592-js-classes.js": 7400, + "1593-js-jsdoc-records.js": 4695, + "1594-js-async.js": 3836, + "1595-js-island-gap/main.js": 3139, + "1596-cjs-modules/main.js": 3283, + "1597-mjs-graph/main.mjs": 3605, + "1598-cjs-builtin-require/main.js": 2977, + "1599-js-uncaught-throw.js": 3196, + "1600-assert-passing.ts": 4333, + "1601-assert-fail-exit.ts": 3725, + "1602-assert-caught-error.ts": 3373, + "1603-assert-scalar-messages.ts": 5128, + "1604-assert-deep-structures.ts": 4364, + "1605-assert-import-forms.ts": 4371, + "1606-assert-strict-module.ts": 2984, + "1607-assert-throws-match.ts": 4301, + "1608-cjs-assert/main.js": 3820, + "1609-assert-async.ts": 2695, + "1610-path-win32-full.ts": 2757, + "1611-url-file-bridge-neutral.ts": 4375, + "1612-cjs-module-globals.cjs": 3706, + "1613-cjs-esm-proxy-named/main.mjs": 3290, + "1614-js-fence-dodges.cjs": 2861, + "1615-cjs-export-shapes/main.cjs": 4723, + "1616-cjs-esm-lexer-invisible/main.mjs": 2991, + "1617-cjs-esm-lexer-visible/main.mjs": 3860, + "1618-cjs-esm-poisoned-tail/main.mjs": 3236, + "1619-cjs-esm-reexport-invisible/main.mjs": 3244, + "1620-cjs-require-effects-order/main.js": 2604, + "1621-cjs-require-cache-hit/main.js": 3531, + "1622-cjs-require-conditional/main.js": 3501, + "1623-cjs-require-diamond/main.js": 4051, + "1624-cjs-require-dir-mid-file/main.js": 2658, + "1625-cjs-require-lazy-fn/main.js": 3635, + "1626-cjs-require-mjs/main.js": 2942, + "1627-mjs-import-cjs-requires/main.mjs": 3236, + "1628-checked-dynamic-builtin-args.cjs": 2968, + "1629-require-main-filename.cjs": 2826, + "1630-inspect-scalars.ts": 3908, + "1630-rmsync-retry-options.cjs": 3797, + "1631-inspect-arrays.ts": 4065, + "1632-inspect-records.ts": 4843, + "1633-inspect-map-set.ts": 3133, + "1634-inspect-classes.ts": 3805, + "1635-inspect-buffer.ts": 3530, + "1636-util-format.ts": 2945, + "1637-inspect-dyn.ts": 3297, + "1638-inspect-cjs.cjs": 3549, + "1639-versions-openssl-probe.ts": 3544, + "1640-fd-read-decode.ts": 2932, + "1641-string-search.ts": 3476, + "1642-object-fromentries-rows.ts": 3699, + "1643-metadata-dyn-return.cjs": 4074, + "1644-ee-basics.ts": 4205, + "1645-ee-extends.ts": 3512, + "1646-ee-once-remove.ts": 3828, + "1647-ee-meta-events.ts": 3673, + "1648-ee-error-event.ts": 3271, + "1649-ee-names-counts.ts": 3057, + "1650-ee-prepend.ts": 3927, + "1651-ee-max-listeners.ts": 4648, + "1652-ee-snapshot.ts": 4220, + "1653-ee-cjs.cjs": 3230, + "1654-ee-namespace.ts": 3631, + "1655-spawnsync-neutral.ts": 5393, + "1656-execsync-neutral.ts": 3546, + "1657-spawn-async-neutral.ts": 3320, + "1660-buffer-read-write-num.ts": 4303, + "1661-buffer-encodings-full.ts": 3877, + "1662-string-decoder-encodings.ts": 3423, + "1663-buffer-compare-search-fill.ts": 4770, + "1664-dyn-fn-boundary.cjs": 3405, + "1665-dyn-fn-mustcall/main.cjs": 2819, + "1666-dyn-fn-identity.ts": 2740, + "1667-dyn-fn-not-callable.cjs": 3303, + "1668-dyn-fn-throws.cjs": 3745, + "1669-symbol-identity.ts": 3617, + "1670-symbol-registry.ts": 4207, + "1671-symbol-typeof.ts": 3400, + "1672-symbol-containers.ts": 3581, + "1673-symbol-cjs.cjs": 3624, + "1674-symbol-inspect.ts": 2758, + "1676-func-array-surface.ts": 2900, + "1677-emitter-listeners.ts": 4932, + "1678-emitter-dyn-listeners.cjs": 3287, + "1679-console-dyn.js": 3576, + "1680-assert-bytes.ts": 3903, + "1681-assert-funcs.ts": 3918, + "1685-stream-readable-basics.ts": 6503, + "1686-stream-readable-paused.ts": 6965, + "1687-stream-readable-flow-control.ts": 3669, + "1688-stream-writable-basics.ts": 3711, + "1689-stream-writable-async-drain.ts": 6004, + "1690-stream-duplex.ts": 6220, + "1691-stream-transform.ts": 6193, + "1692-stream-pipe.ts": 6662, + "1693-stream-pipe-backpressure.ts": 3700, + "1694-stream-destroy.ts": 3259, + "1695-stream-props.ts": 4843, + "1696-stream-read-inside-read.ts": 3524, + "1697-stream-tick-vs-timer.ts": 3256, + "1698-stream-uncaught-error.ts": 4826, + "1699-stream-callback-shapes.ts": 3791, + "1700-mustcall-common/main.cjs": 4329, + "1701-mustcall-exit-report/main.cjs": 3995, + "1702-dyn-proto-dispatch.cjs": 4694, + "1703-arguments-rest-props.cjs": 3485, + "1710-cjs-export-class/main.js": 2945, + "1711-cjs-export-single-values/main.js": 3527, + "1712-field-incdec.ts": 3301, + "1713-js-dyn-fields.js": 3702, + "1720-assert-throws-shape.ts": 3665, + "1721-assert-throws-regex-class.ts": 3205, + "1722-assert-rejects.ts": 3941, + "1723-assert-does-not-reject.ts": 3991, + "1724-assert-iferror.ts": 2922, + "1725-assert-symbols.ts": 4117, + "1726-promise-with-resolvers.ts": 3773, + "1727-assert-throws-shape-exit.ts": 4180, + "1730-countdown-symbol-keys/main.js": 3717, + "1731-symbol-field-shapes.cjs": 4041, + "1732-symbol-field-cross-module/main.js": 3671, + "1740-stream-extends-readable.ts": 5413, + "1741-stream-extends-writable.ts": 6469, + "1742-stream-extends-duplex-transform.ts": 6437, + "1743-stream-extends-vt-dispatch.ts": 7212, + "1744-stream-set-encoding.ts": 3635, + "1745-stream-encoding-js.cjs": 2973, + "1746-stream-for-await.ts": 4707, + "1747-stream-for-await-js.cjs": 4902, + "1750-http-agent-options.ts": 7371, + "1751-options-record-stance.ts": 4112, + "1760-surplus-args-drop.cjs": 3672, + "1761-emitter-special-event-names.cjs": 5508, + "1770-assert-dyn-strict.ts": 4072, + "1771-assert-dyn-deep.ts": 3521, + "1772-assert-dyn-js.cjs": 3744, + "1773-assert-dyn-exit.ts": 3156, + "1780-http-res-surface.ts": 7173, + "1781-http-server-shapes.cjs": 3500, + "1790-computed-key-folds.ts": 3641, + "1791-searchparams-core.ts": 3206, + "1792-searchparams-encoding.ts": 3500, + "1793-searchparams-iteration.ts": 3620, + "1794-searchparams-url-live.ts": 3114, + "1795-dyn-handle-request.cjs": 6764, + "1796-dyn-handle-body.cjs": 6226, + "1797-dyn-handle-socket.cjs": 3886, + "1798-dyn-handle-typed-box.ts": 6248, + "1800-immediate-basics.ts": 3211, + "1801-immediate-handle.ts": 3455, + "1802-immediate-unref-exit.ts": 3001, + "1803-timeout-refresh.ts": 3714, + "1804-timers-module.ts": 3580, + "1805-timer-callback-args.ts": 3293, + "1806-timer-delay-trunc.ts": 3354, + "1810-stream-options-const-record.ts": 4095, + "1811-stream-option-value-callbacks.cjs": 3113, + "1812-stream-super-options-forwarding.cjs": 3239, + "1813-stream-finished.ts": 3753, + "1814-stream-pipeline.cjs": 3633, + "1815-stream-state-reads.cjs": 3723, + "1820-static-block-basics.ts": 3496, + "1821-static-block-order.ts": 3121, + "1822-static-block-js.js": 2926, + "1823-static-instance-method-names.ts": 2971, + "1824-for-of-destructuring-defaults.ts": 3389, + "1825-exhaustive-typeof-switch.ts": 2558, + "1826-settimeout-arguments-callback.js": 3292, + "1830-enum-numeric-basics.ts": 3721, + "1831-enum-string-const-reverse.ts": 3386, + "1832-enum-modules/main.ts": 3491, + "1835-var-basics.ts": 3090, + "1836-var-loop-capture.ts": 4227, + "1837-var-undefined-hoisting.ts": 3129, + "1838-var-modules/main.ts": 3442, + "1839-var-js/main.cjs": 2943, + "1840-jsdoc-import-type-only/main.js": 3153, + "1850-overload-basics.ts": 3527, + "1851-overload-return-narrowing.ts": 3485, + "1852-overload-class-members.ts": 3165, + "1853-overload-modules/main.ts": 3369, + "1854-ambient-declare-fn.ts": 3339, + "1855-ambient-declare-fn-uncaught.ts": 2825, + "1870-unit-type-values.ts": 3760, + "1871-empty-array-never.ts": 2995, + "1872-template-tostring-composite.ts": 3281, + "1880-json-declared-field-order.ts": 3669, + "1881-default-anon/main.ts": 3229, + "1882-default-cjs-interop/main.ts": 3282, + "1883-default-exports/main.ts": 3775, + "1890-ns-imports/main.ts": 3324, + "1891-ns-reexport/main.ts": 3059, + "1940-class-values-basics.ts": 3481, + "1941-class-values-registry.ts": 3018, + "1942-class-expressions.ts": 2837, + "1943-class-statics-expanded.ts": 3294, + "1944-class-values-modules/main.ts": 3634, + "1950-generic-fn-values.ts": 3713, + "1951-generic-classes-basics.ts": 3449, + "1952-generic-class-statics-values.ts": 3863, + "1953-generic-class-hierarchy.ts": 3771, + "1954-generic-modules/main.ts": 3506, + "1960-namespace-basics.ts": 3039, + "1961-namespace-nested.ts": 2879, + "1962-namespace-classes.ts": 3820, + "1963-namespace-aliases.ts": 2943, + "1964-namespace-type-only.ts": 3637, + "1965-namespace-ambient.ts": 3549, + "1966-namespace-modules/main.ts": 3116, + "1967-namespace-alias-typeonly.ts": 2879, + "1968-namespace-import-eq-snapshot.ts": 3284, + "1970-decorators-basics.ts": 3029, + "1971-decorators-rebinding.ts": 3079, + "1972-decorators-throwing.ts": 2634, + "1973-decorators-ambient.ts": 3508, + "1980-primitive-proto-statics.ts": 3768, + "1981-date-utc.ts": 3681, + "1982-freeze-resolve-passthrough.ts": 3352, + "1983-array-tuple-surfaces.ts": 3130, + "1990-labels-basics.ts": 3662, + "1991-for-in-loops.ts": 4312, + "1992-small-syntax.ts": 3036, + "200-strings.ts": 3188, + "2000-generic-methods-basic.ts": 3233, + "2001-generic-methods-generic-class.ts": 3654, + "2002-generic-methods-inheritance.ts": 3883, + "2003-generic-methods-object-literal.ts": 4002, + "2004-generic-methods-statics.ts": 2781, + "201-templates.ts": 3259, + "2010-generators-basics.ts": 2930, + "2011-generators-forof.ts": 3439, + "2012-generators-return-throw.ts": 3077, + "2013-generators-sent-values.ts": 3157, + "2014-generators-values.ts": 3230, + "2015-generators-yieldstar.ts": 2691, + "2016-generators-rc-stress.ts": 3408, + "2017-generators-async.ts": 3645, + "2018-generators-uncaught.ts": 3372, + "2019-generators-loops.ts": 3684, + "2020-generic-value-bindings.ts": 4814, + "2021-generic-value-binding-modules/main.ts": 2613, + "2022-width-index-capture.ts": 4066, + "2023-width-readonly.ts": 3988, + "2024-width-array-elems.ts": 3088, + "2025-width-union-compose.ts": 3148, + "2026-width-spread.ts": 3721, + "2030-width-nested.ts": 3956, + "2031-width-tuples.ts": 3454, + "2032-cjs-export-assigned-class-expression/main.cjs": 3771, + "2033-property-assigned-class-extends.cjs": 2857, + "2035-ternary-array-retag.cjs": 3742, + "2036-evolving-array-decl.cjs": 3733, + "2037-fn-decl-hoisting.cjs": 3504, + "2038-evolving-array-js.cjs": 4258, + "2040-any-bindings.ts": 3664, + "2040-mixin-heritage.ts": 3192, + "2041-any-params-returns.ts": 3362, + "2041-mixin-values.ts": 3893, + "2042-any-flow-loops.ts": 3770, + "2042-mixin-modules/main.ts": 3144, + "2043-any-dom-values.ts": 3779, + "2043-mixin-rc-stress.ts": 4190, + "2044-vtable-sibling-slots.ts": 4054, + "2045-objlit-accessors-basic.ts": 3443, + "2045-parameter-properties.ts": 3049, + "2046-abstract-classes.ts": 4183, + "2046-objlit-accessors-effects.ts": 3215, + "2047-objlit-accessors-shapes.ts": 3091, + "2047-optional-class-fields.ts": 4146, + "2050-dynamic-import-own-module/main.ts": 3451, + "2051-dynamic-import-then/main.ts": 3601, + "2052-dynamic-import-self.ts": 3591, + "2053-typeof-static-fold.ts": 3479, + "2054-destructuring-island-source.ts": 3225, + "2060-empty-tuple.ts": 3198, + "2070-computed-key-folds.ts": 3432, + "2071-integer-key-enumeration-order.ts": 3897, + "2072-expando-function-members.ts": 3830, + "2073-destructuring-assignment.ts": 3540, + "2074-island-destructuring.ts": 3784, + "2075-index-signature-runtime-keys.ts": 2791, + "2080-destructuring-defaults.ts": 3781, + "2081-destructuring-rest.ts": 3728, + "2082-destructuring-assignment.ts": 3505, + "2085-destructuring-heads-rest-params.ts": 3490, + "2087-destructuring-for-heads.ts": 3190, + "2090-index-signature-number-keys.ts": 2803, + "2091-index-signature-string-intersection.ts": 2723, + "2092-package-imports/main.ts": 2857, + "2093-timers-promises.ts": 4034, + "2094-diagnostics-channel.ts": 3375, + "2095-js-catch-unknown.js": 3448, + "2096-os-type.ts": 3784, + "2097-js-evolving-globals.js": 3531, + "210-string-methods.ts": 3602, + "2100-stream-default-hwm.ts": 3572, + "2101-dyn-param-defaults.ts": 2799, + "2102-empty-pattern-decls.ts": 3305, + "2105-computed-key-static-folds.ts": 3458, + "2106-comma-expressions.ts": 3662, + "211-string-unicode.ts": 2722, + "2110-top-object-types.ts": 2930, + "2111-json-stringify-unknown.ts": 2894, + "2112-array-at-findlast.ts": 3347, + "2113-string-index-methods.js": 2954, + "212-string-aliasing-append.ts": 2936, + "2120-package-self-import/main.ts": 2637, + "2121-esm-cycle-inert-backedge/main.ts": 2688, + "2123-ambient-import-crash/main.ts": 2830, + "2124-imports-field-wildcard/main.ts": 2779, + "2140-uri-component-codecs.ts": 3028, + "2160-dc-tracing-channel.cjs": 3125, + "2161-js-object-literal-identity.cjs": 3710, + "2162-js-dyn-destructure.cjs": 2745, + "2163-js-selfref-const.cjs": 4243, + "2164-js-then-dyn-handler.cjs": 4454, + "2165-js-throw-dyn.cjs": 3859, + "2166-cjs-getter-this/main.cjs": 3481, + "2170-island-array-exits.ts": 5249, + "2171-island-json-stringify.ts": 3408, + "2172-island-regexp-boundary.ts": 4656, + "2190-new-object-and-string-wrappers.ts": 2892, + "2191-uri-encoders.ts": 2460, + "2192-object-default-tostring.ts": 3152, + "2193-discarded-stdlib-reads.ts": 3436, + "2194-ambient-undef-chains.ts": 3329, + "2195-require-missing-package/main.mjs": 3396, + "2196-island-computed-key-chain.ts": 4364, + "2210-dyn-promise-crossing.cjs": 3412, + "2211-dc-trace-promise.cjs": 4496, + "2212-unhandled-rejection-listener.cjs": 3503, + "2213-async-local-storage.cjs": 3304, + "2214-dc-bind-store.cjs": 4372, + "2215-process-emit-warning-exit.cjs": 4385, + "2240-width-class-into-record.ts": 3816, + "2241-width-record-into-class.ts": 3107, + "2242-width-statics-into-record.ts": 3187, + "2243-width-assert-satisfies-shapes.ts": 3725, + "2250-tagged-templates.ts": 2802, + "2252-class-iterators.ts": 4024, + "2253-union-coercions.ts": 2969, + "2260-http2-constants.cjs": 2611, + "2280-builtin-namespace-destructure.cjs": 2964, + "2281-domexception-atob-btoa.cjs": 3116, + "2282-queue-microtask.cjs": 3672, + "2283-structured-clone.cjs": 3661, + "2284-regexp-constructor.cjs": 2921, + "2285-iferror-dyn.cjs": 2815, + "2286-dyn-object-walks.cjs": 2814, + "2300-dyn-record-spread-and-keyed-access.cjs": 3340, + "2301-cjs-export-table-dom-attach.cjs": 2994, + "2310-process-next-tick.ts": 3462, + "2311-next-tick-js-callbacks.js": 3541, + "2312-stream-underscore-assign.ts": 4210, + "2313-stream-underscore-assign-js.cjs": 3281, + "2314-process-introspection.ts": 4007, + "2320-await-unit.ts": 2773, + "2321-emitter-static-setmax.cjs": 3576, + "2322-dyn-array-sort.cjs": 2683, + "2323-timer-callback-returns.ts": 3611, + "2330-tls-server-runtime-options.cjs": 22007, + "2331-tls-server-options-typed.ts": 22550, + "2350-nan-global.ts": 3586, + "2351-async-methods.ts": 3496, + "2352-void-coercions.ts": 2875, + "2353-decorators-member-ambient.ts": 2855, + "2354-decorators-expression-ambient.ts": 2445, + "2360-tuple-to-array.ts": 3725, + "2361-assign-index-record.ts": 3918, + "2362-execsync-inherit.ts": 3204, + "2363-nullish-retag.ts": 3277, + "2364-in-runtime-key.ts": 3653, + "2365-dyn-into-island.ts": 2967, + "2366-string-well-formed.ts": 3530, + "2367-regexp-escape.ts": 3537, + "2368-set-methods.ts": 3321, + "2369-promise-try.ts": 3477, + "2370-group-by.ts": 3834, + "2371-iterator-helpers.ts": 3503, + "2380-buffer-module-named-import.ts": 3337, + "2381-builtin-default-imports.js": 3386, + "2382-cycle-two-decl/main.ts": 2540, + "2383-cycle-assertdoc/main.js": 3635, + "2384-cycle-mixed-bindings/main.ts": 2680, + "2385-builtin-reexport-facade/main.ts": 2415, + "2386-string-to-chars.ts": 3358, + "2387-tonumber-argv.ts": 3189, + "2388-tonumber-grammar-zoo.ts": 2478, + "2389-tonumber-unary-plus.ts": 3505, + "2390-dot-requires/main.cjs": 3502, + "2391-default-builtin-imports/main.ts": 3560, + "2392-block-guard-alias-scope.ts": 2811, + "2393-loop-exit-guard-narrow.ts": 3396, + "2394-loop-narrow-containment.ts": 3368, + "2395-while-cond-guard.ts": 2736, + "2396-born-narrowed-decl.ts": 3324, + "2397-branch-kill-merge.ts": 2593, + "2398-switch-arm-kill.ts": 3348, + "2399-reassign-kill-polarity.ts": 3637, + "240-stdout-write.ts": 3882, + "2400-kill-return-edge.ts": 3195, + "2401-kill-break-staging.ts": 3449, + "2402-labeled-break-kill.ts": 2813, + "2403-kill-continue-backedge.ts": 3428, + "2404-kill-throw-catch.ts": 2824, + "2405-sibling-arm-narrow.ts": 2442, + "2406-switch-clause-sibling-narrow.ts": 2665, + "2407-infinite-loop-seal.ts": 3312, + "2408-loop-terminality-reopen.ts": 3281, + "2409-loop-body-return-not-terminal.ts": 3145, + "2410-stacked-cases-terminality.ts": 3627, + "2411-exhaustive-switch-terminality.ts": 3158, + "2412-dowhile-guard-trailing-test.ts": 3265, + "2413-dowhile-kill-renarrow.ts": 2701, + "2414-dowhile-continue-kill.ts": 3317, + "2415-dowhile-break-trailing-test.ts": 3362, + "2416-spread-ternary-positions.ts": 3467, + "2417-ternary-local-inference.ts": 3368, + "2418-wrapped-ternary-arms.ts": 3310, + "2419-selector-ternary-union.ts": 3702, + "2420-nullish-null-identity.ts": 2553, + "2421-float-lane-inference.ts": 3344, + "2422-ieee-div-rem-corners.ts": 3186, + "2423-param-null-reassign.ts": 3025, + "2424-ternary-miss-first-narrowing.ts": 3552, + "2425-elseif-head-exit-narrow.ts": 3257, + "2426-default-snapshot-mutable/main.ts": 3423, + "2427-perf-hooks-now.ts": 3049, + "2428-field-redeclare-inherited.ts": 3585, + "2429-destructure-class-instance.ts": 2694, + "2430-empty-literal-unknown-field.js": 3401, + "2431-primitive-ctor-values.ts": 2884, + "2432-generic-member-fields-async.ts": 5845, + "2433-as-const-command-tables.ts": 3180, + "2434-deferred-init-fields.ts": 3249, + "2435-loose-same-kind-equality.ts": 3363, + "2440-console-inspect-args.ts": 5418, + "2441-console-process-argv.ts": 3041, + "2442-union-literal-arm-widening.ts": 2555, + "2443-union-literal-shadow-narrowing.ts": 3302, + "2444-union-literal-reducer-spread.ts": 3618, + "2445-math-minmax-nary.ts": 2645, + "2446-performance-global.ts": 3980, + "2447-island-boundary-slots/main.ts": 6217, + "2448-entries-null-arms-regex-arrays.ts": 3545, + "2450-private-instance-methods.ts": 2931, + "2451-private-fields.ts": 3694, + "2452-private-statics.ts": 2965, + "2453-private-accessors.ts": 3478, + "2454-private-generator-methods.ts": 3697, + "2455-private-brand-checks.ts": 3515, + "2456-private-async-methods.ts": 3535, + "2457-private-members.js": 2780, + "2460-qs-parse-grammar.ts": 4534, + "2461-qs-parse-options.ts": 4115, + "2462-qs-stringify.ts": 3434, + "2463-qs-escape-unescape.ts": 3311, + "2464-qs-require-forms.cjs": 2821, + "2470-mockable-module-shape.js": 2978, + "2471-record-keyed-write-hasown.js": 2970, + "2472-string-regexp-union.ts": 3393, + "2473-option-table-widths.js": 3653, + "2474-island-literal-forms.ts": 3643, + "2475-variadic-wrapper-island.js": 3606, + "2476-map-regex-values.ts": 3711, + "2480-recursive-record-tree.ts": 3376, + "2481-mutual-recursive-records.ts": 3699, + "2482-recursive-union-tree.ts": 3347, + "2483-recursive-record-cycles.ts": 2764, + "2484-json-stringify-circular.ts": 3845, + "2485-inspect-circular-refs.ts": 3694, + "2486-recursive-record-boundaries.ts": 3988, + "2487-recursive-deep-equal.ts": 3416, + "2488-ast-walker.ts": 3100, + "2490-find-miss-null-compare.ts": 3107, + "2491-strict-unit-compare-no-arm.ts": 2820, + "2492-loose-null-compare-unions.ts": 3683, + "2493-switch-unit-cases.ts": 3703, + "2494-no-arm-compare-effects.ts": 3089, + "2500-net-autosel-timeout.ts": 3775, + "2510-dyn-evolving-array-map.ts": 3265, + "2511-dyn-evolving-array-filter-foreach.ts": 2885, + "2512-dyn-evolving-array-mixed-push.ts": 3639, + "2520-private-statics-class-name-calls.ts": 3155, + "2521-private-statics-class-expression.ts": 3520, + "2522-private-statics-decorated.ts": 3673, + "2523-private-statics-aliased-class.ts": 3795, + "2530-object-destructuring-decl.ts": 2869, + "2531-array-tuple-destructuring-decl.ts": 3168, + "2532-param-destructuring-options.ts": 2906, + "2533-forof-destructuring.ts": 2840, + "2534-object-rest-decl.ts": 3199, + "2535-destructuring-assign-basics.ts": 3816, + "2536-destructuring-assign-nested.ts": 3047, + "2537-destructuring-assign-member-targets.ts": 3590, + "2538-destructuring-assign-class-source.ts": 3544, + "2539-class-instance-rest.ts": 3764, + "2540-accessor-destructuring-defaults.ts": 3201, + "2541-destructuring-eval-order.ts": 2670, + "2550-generics-keyof-pick.ts": 3947, + "2551-generics-value-aliases.ts": 3227, + "2552-generics-iface-methods.ts": 3318, + "2553-generics-signature-bindings.ts": 3442, + "2554-generics-frontier-mix.ts": 3344, + "2555-generics-keyof-writes.ts": 3448, + "2556-crypto-introspection.ts": 3351, + "2556-width-hybrid-shapes.ts": 3462, + "2557-tls-ca-store.ts": 4438, + "2557-width-field-lifts.ts": 4453, + "2558-index-signature-func-values.ts": 3590, + "2558-rejection-events.cjs": 3641, + "2559-index-signature-container-values.ts": 4066, + "2560-arraybuffer-dataview-set.ts": 3614, + "2561-object-is.ts": 3391, + "2562-intl-numberformat-en-us.ts": 3241, + "2563-stream-promises-pipeline.ts": 3490, + "2564-stream-promises-finished.ts": 2994, + "2565-stream-promises-js.cjs": 2616, + "2566-promise-reject-dyn-reason.js": 3548, + "2567-rest-spread-forward.js": 3292, + "2568-rest-spread-forward-dynamic.js": 3367, + "2569-upcast-identity.ts": 2553, + "2570-buffer-arg-validation.cjs": 5779, + "2571-searchparams-arg-validation.cjs": 3913, + "2572-readable-emitted-readable-flag.cjs": 3556, + "2573-fs-url-arg-ladders.cjs": 3502, + "2574-emitter-max-listeners-ladders.cjs": 2895, + "2575-string-destructuring-decl.ts": 3433, + "2576-string-destructuring-assign.ts": 2984, + "2577-builtin-global-destructuring.js": 3466, + "2578-jsval-into-unknown-rows.ts": 3398, + "2579-jsval-object-param-crossing.js": 3294, + "2580-jsval-routed-keyed-ops.js": 3298, + "2581-jsval-routed-calls.js": 3542, + "2582-jsval-object-statics.js": 3509, + "2582-jsval-routed-keyed-ops.js": 3136, + "2583-dyn-nullish-coalesce.js": 2976, + "2583-jsval-routed-calls.js": 2950, + "2584-jsval-object-statics.js": 3305, + "2584-union-dyn-collapse.ts": 2970, + "2585-dyn-nullish-coalesce.js": 3632, + "2585-unknown-array.ts": 3809, + "2586-object-assign-spread.js": 4084, + "2587-array-entries-forof.ts": 2633, + "2588-array-entries-chains.ts": 4097, + "2589-object-create-null.cjs": 3112, + "2590-object-create-dynamic.js": 4279, + "2591-ambient-generic-traps.ts": 3216, + "2592-ambient-trap-uncaught.ts": 3198, + "2593-generic-inert-bindings.ts": 3007, + "2594-nullish-generic-bindings.ts": 3321, + "2595-fs-arg-ladders.cjs": 3930, + "2596-net-arg-ladders.cjs": 3528, + "2597-dgram-send-ladders.cjs": 4536, + "2598-tls-arg-ladders.cjs": 4142, + "2599-stream-arg-ladders.cjs": 5465, + "2600-dyn-keyed-write-harness.js": 2800, + "2601-dyn-keyed-write-ops.js": 3269, + "2602-dyn-array-destructure.js": 3207, + "2603-island-keyed-write-dyn.js": 3608, + "2604-cycle-classes-mutual/main.ts": 3410, + "2605-cycle-three-module/main.ts": 2592, + "2606-dynamic-import-cycle/main.ts": 2445, + "2608-regex-named-groups.ts": 3896, + "2609-regex-named-replace.ts": 3215, + "2610-regex-named-matchall.ts": 3887, + "2611-regex-named-groups-js.cjs": 3523, + "2613-for-init-uninitialized-let.ts": 3167, + "2614-trap-binding-later-writes.ts": 3345, + "2615-nullish-field-record-binding.ts": 2720, + "2616-js-collect-probe-defers.js": 3534, + "2617-enum-static-field-import/main.ts": 3068, + "2618-ee-emit-override.ts": 3915, + "2619-ee-override-chain.ts": 2567, + "2620-ee-override-once-order.ts": 3439, + "2621-ee-override-error-throw.ts": 3265, + "2622-ee-override-filter.ts": 3339, + "2623-ee-job-queue.ts": 3586, + "2624-ee-override-js.cjs": 2637, + "2625-bytes-views.ts": 2847, + "2626-stream-event-names.ts": 3436, + "2627-stream-ticks-are-nextticks.ts": 4048, + "2628-stream-push-encodings.cjs": 3219, + "2629-stream-consumers.ts": 4523, + "2630-stream-consumers-errors.ts": 3353, + "2631-create-require/main.ts": 2869, + "2632-dyn-jsval-iterate.js": 3938, + "2633-island-promise-crossing.js": 3898, + "2634-stream-pipeline-arg-ladders.cjs": 2829, + "2635-trap-binding-unmappable-written.ts": 3493, + "2636-trap-binding-ambient-rooted-rewrite.ts": 3155, + "2637-create-require-bare/main.ts": 3093, + "2638-http-dyn-res-compat.cjs": 7897, + "2639-http-dyn-req-pause.cjs": 4028, + "2640-net-dyn-socket-compat.cjs": 3877, + "2641-http-agent-surface.cjs": 6286, + "2642-http-agent-maxsockets.cjs": 4681, + "2643-or-default-retag.ts": 3292, + "2644-http-client-url-argument.ts": 3256, + "2645-https-client-url-argument.ts": 24258, + "2646-top-level-await.ts": 3392, + "2647-top-level-await-modules/main.ts": 3047, + "2648-top-level-await-rejection.ts": 3150, + "2649-top-level-await-pending.ts": 3160, + "2650-top-level-await-self-import.ts": 2440, + "2651-top-level-await-pending-unhandled.ts": 2762, + "2652-top-level-await-dynamic/main.ts": 3760, + "2653-top-level-await-rejection-stops-loop.ts": 2631, + "2654-top-level-await-unrelated-rejection.ts": 2643, + "2655-top-level-await-cycle/main.ts": 3098, + "2656-top-level-await-cycle-order/main.ts": 3167, + "2657-top-level-await-cycle-dynamic/main.ts": 2957, + "2658-top-level-await-sync-completion/main.ts": 3318, + "2659-top-level-await-dynamic-cycle/main.ts": 2585, + "2660-top-level-await-cycle-rejection/main.ts": 3210, + "2661-top-level-await-dynamic-runtime-root/main.ts": 3366, + "2662-top-level-await-cycle-external-wait/main.ts": 3005, + "2663-top-level-await-dependency-errors/main.ts": 2847, + "2664-top-level-await-same-checkpoint-rejection.ts": 3116, + "2665-top-level-await-unhandled-listener-liveness.ts": 2875, + "2666-array-to-sorted.ts": 7633, + "2668-stored-number-array-iterator.ts": 3253, + "2669-array-copying-methods.ts": 3549, + "2670-uint8array-copy-iterate.ts": 3853, + "2671-array-copying-js.cjs": 3682, + "2672-http-request-response-callback.ts": 4143, + "2673-top-level-await-implicit-module.ts": 3247, + "2674-top-level-for-await-implicit-module.ts": 3134, + "2675-create-require-nested-esm.js": 2364, + "2675-process-self-reexec.ts": 2727, + "2676-indexed-read-strict-equality.ts": 2731, + "2676-record-clone-overrides.ts": 2957, + "2676-top-level-await-ambiguous/main.ts": 2732, + "2677-runtime-optional-closure.ts": 4013, + "2677-top-level-await-module-scope/main.ts": 3413, + "2678-date-instances.ts": 2682, + "2678-large-string-sparse-index.ts": 3695, + "2678-util-parseargs.ts": 6509, + "2679-util-parseargs-cjs.cjs": 4674, + "2680-util-parseargs-default.ts": 2968, + "2681-util-parseargs-dynamic.js": 4805, + "2682-fs-rename.ts": 3870, + "2683-filter-truthy-predicate.ts": 3057, + "2683-fs-rename-js.cjs": 3194, + "2684-filter-no-predicate-dyn.cjs": 2886, + "2684-fs-rename-abort.ts": 4187, + "2685-array-unshift-reverse.ts": 3336, + "2685-fs-write-sync.ts": 3018, + "2686-fs-file-handle.ts": 4533, + "2687-fsp-write-file-options.ts": 3468, + "2687-process-write-args.ts": 4056, + "2688-fs-stats-disk-fields.ts": 3885, + "2689-http-server-timeout-properties.ts": 3928, + "2690-https-server-timeout-option.ts": 21635, + "2691-retained-lowering-record-order.ts": 4394, + "2692-inline-record-assert-index.ts": 4260, + "2692-string-accumulation.ts": 2769, + "2693-math-constants.ts": 2825, + "2700-array-sort-complexity.ts": 3067, + "2700-http-static-trailers.ts": 3428, + "2700-wasi-core.ts": 3839, + "2701-array-sort-snapshot.ts": 3995, + "2701-http-static-trailer-wire.ts": 3237, + "2701-import-meta/main.mjs": 2794, + "2702-http-static-trailer-end.ts": 3525, + "2702-type-import-link-static/main.ts": 3217, + "2702-uint8array-to-sorted.ts": 3838, + "2703-array-sparse-sort.ts": 7138, + "2703-type-import-link-static-reexport/main.ts": 2989, + "2704-array-sparse-to-sorted.ts": 7251, + "2704-type-import-link-static-success/main.ts": 3249, + "2705-array-sparse-sort-append.ts": 6240, + "2705-type-import-link-dynamic/main.ts": 2760, + "2706-array-search-missing-needle.ts": 3091, + "2706-type-import-link-dynamic-success/main.ts": 3330, + "2707-array-search-huge-sparse.ts": 45179, + "2707-type-import-link-static-default-reexport/main.ts": 2758, + "2708-type-import-link-dynamic/main.ts": 4132, + "2720-array-read-parity.ts": 3456, + "2721-array-nested-missing-receiver.ts": 3322, + "2750-array-sparse-foundation.ts": 3816, + "2751-buffer-concat-sparse-list.ts": 3043, + "2752-array-optional-stores.ts": 3548, + "2753-array-optional-method-values.ts": 3422, + "2754-array-property-undefined.ts": 3456, + "2755-array-optional-literal-forwarding.ts": 3507, + "2780-array-parity-composition.ts": 9748, + "2781-array-missing-value-escape.ts": 2984, + "2782-array-sparse-callbacks.ts": 3368, + "2783-array-defaults-rest.ts": 3426, + "2784-array-reduce-missing-result.ts": 2920, + "2785-array-missing-destructuring.ts": 4220, + "2786-array-sparse-serialization.ts": 3688, + "2787-array-missing-string-arithmetic.ts": 2565, + "2788-array-missing-builtin-conversions.ts": 2767, + "2789-array-missing-optional-tostring.ts": 3009, + "2790-dynamic-import-self-name/main.ts": 3621, + "2791-record-optional-keys.ts": 3660, + "2792-record-optional-spread-entries.ts": 3741, + "2793-union-conversion-identity-capture.ts": 3519, + "2794-array-generic-callback-values.ts": 2842, + "2795-array-optional-typedarray-source.ts": 29642, + "2796-array-sparse-class-value-instanceof.ts": 4014, + "2800-array-expression-consumers.ts": 2964, + "2801-array-switch-consumers.ts": 3634, + "2820-array-missing-method-receivers.ts": 3219, + "2821-array-optional-numeric-comparisons.ts": 3648, + "2830-cjs-require-self-name/main.cjs": 2817, + "2840-finally-completions.ts": 2484, + "2841-using-sync.ts": 3654, + "2842-await-using.ts": 3139, + "2843-using-suppressed-error.ts": 3369, + "2844-node-disposable-resources.ts": 3909, + "2845-for-using-of.ts": 3562, + "2846-generator-using.ts": 3676, + "2850-async-generators-protocol.ts": 4224, + "2851-async-generators-values.ts": 3418, + "2852-timers-promises-interval.ts": 3999, + "2854-leading-bom-literals.ts": 3644, + "2855-searchparams-sort-complexity.ts": 2896, + "2856-dynamic-any-local-operators.ts": 3122, + "2857-branded-primitives.ts": 2535, + "2858-import-meta-resolve/main.mjs": 2803, + "2859-import-meta-resolve-dynamic/main.mjs": 2791, + "2860-require-resolve/main.cjs": 3416, + "2861-readable-iterator-close.ts": 3965, + "2862-web-readable-async-iteration.ts": 48807, + "2863-class-async-iterator.ts": 3227, + "2864-array-class-method-receivers.ts": 2404, + "2865-cjs-process-alias.cjs": 3403, + "2866-dyn-switch.ts": 2311, + "2867-array-shift-length.js": 3507, + "2868-empty-record-promise-presence.js": 2925, + "2869-nullish-mixed-lazy.ts": 2958, + "2870-and-dropped-truthy-arm.ts": 2834, + "2871-optional-promise-to-unknown.ts": 3267, + "2872-unobserved-dynamic-event.ts": 3355, + "2873-optional-receiver-loop-lifetime.js": 3047, + "2874-nullable-callback-field-cycle.js": 3534, + "2875-evolving-let-read-before-write.js": 2810, + "2876-class-unknown-roundtrip.ts": 3764, + "2877-child-unknown-roundtrip.ts": 2785, + "2878-class-private-unknown.cjs": 3352, + "2880-cjs-module-graph/main.cjs": 3782, + "2890-crypto-static-utility.ts": 2826, + "2891-json-record-key-escapes.ts": 3816, + "2892-windows-console-unicode.ts": 3563, + "2893-child-stdin-duplex.ts": 3578, + "2894-child-stdin-backpressure.ts": 3536, + "2895-child-stdin-write-after-end.ts": 3038, + "2896-child-stdin-write-after-finish.ts": 3391, + "2897-child-stdin-destroy.ts": 3563, + "2898-child-stdin-spawn-failure.ts": 3036, + "2899-nested-mutual-recursion.ts": 3350, + "2900-float64array-static.ts": 3865, + "2900-void-conditional-arrow.ts": 2828, + "2901-bigint-core.ts": 3440, + "2902-bigint-bytes.ts": 2684, + "2903-bigint-storage.ts": 3029, + "2904-bigint-errors.ts": 3660, + "2905-bigint-edges.ts": 3424, + "2906-bigint-wasi-width.ts": 3017, + "2910-overloaded-callable-alias.ts": 3175, + "2911-execfile-callback.ts": 3152, + "2912-execfile-callback-options.ts": 3514, + "2912-promisify-fs-readfile.ts": 3307, + "2913-builtin-callable-alias.ts": 4333, + "2914-fixed-tuple-call-spread.ts": 3657, + "2915-path-function-values.ts": 2684, + "2916-path-function-values-cjs.ts": 3544, + "2917-builtin-callable-widths.ts": 3312, + "2918-builtin-callable-widths-cjs.ts": 4040, + "2919-fs-function-values.ts": 4214, + "2920-fs-promises-function-values.ts": 2447, + "2921-zlib-callbacks.ts": 4192, + "2922-dyn-bitwise-not.cjs": 2704, + "2923-cjs-factory-export/main.cjs": 3106, + "2930-union-receiver-calls.ts": 3700, + "2931-union-dynamic-field-call.js": 3466, + "2932-create-require-program/main.ts": 3686, + "2933-static-dynamic-import/main.ts": 3405, + "2934-static-import-stored.ts": 2381, + "2935-module-namespace-values/main.ts": 3289, + "2936-static-loose-equality.ts": 3642, + "2937-bitwise-hot-loop.ts": 3298, + "2938-fs-sync-overloads.cjs": 2598, + "2939-child-shell-text.ts": 2919, + "2940-date-parse.ts": 3171, + "2940-fsp-realpath.ts": 3497, + "2941-fsp-lstat-identity.ts": 3608, + "2941-process-exit-code.ts": 3007, + "2942-fsp-readdir-dirent.ts": 3744, + "2942-process-exit-code-override.ts": 2479, + "2943-process-exit-code-invalid.ts": 3225, + "2944-process-exit-code-wrap.ts": 3249, + "2945-url-origin-username.ts": 2371, + "2946-child-fork-ipc/main.ts": 4191, + "2946-url-port-hash.ts": 2720, + "2947-set-readonly-seeds.ts": 3363, + "2948-child-fork-eof-callback/main.ts": 3691, + "2948-stdio-callback-record.ts": 3021, + "2949-child-fork-default/main.mjs": 3752, + "2949-url-password.ts": 3268, + "2950-fs-descriptor-publication.ts": 3039, + "2951-math-static-analytic.ts": 2897, + "2952-math-static-remaining.ts": 3708, + "2953-http-header-validation.ts": 2926, + "2954-http-outgoing-headers.ts": 3568, + "2955-http-static-state.ts": 3392, + "2956-http-static-informational.ts": 3156, + "2957-http-static-response-controls.ts": 3011, + "2961-emitter-computed-names.cjs": 3061, + "2962-emitter-computed-optional.ts": 3117, + "2963-child-fork-dispatch/main.ts": 3069, + "2964-indexed-compound.ts": 4283, + "2966-numeric-array-read-fusion.ts": 2881, + "2967-numeric-array-read-lifetime.ts": 3327, + "2968-numeric-array-borrow.ts": 3624, + "2969-scalar-record-results.ts": 3705, + "2970-constant-numeric-tables.ts": 3396, + "2971-constant-table-modules/main.ts": 2786, + "2972-http-static-distinct-snapshots.ts": 3464, + "2972-math-receiver-borrow.ts": 4257, + "2973-http-static-agent.ts": 3844, + "2973-integer-bitwise-arithmetic.ts": 3703, + "2974-array-search-from-index.ts": 120829, + "2974-http-static-module-values.ts": 5733, + "2974-numeric-remainder.ts": 3749, + "2975-bigint-default-radix.ts": 2671, + "2975-http-static-client-controls.ts": 3229, + "2976-http-static-incoming-state.ts": 3560, + "2976-json-stringify-no-arguments.js": 3221, + "2977-http-static-incoming-timeout.ts": 3554, + "2977-nested-array-binding-defaults.js": 3145, + "2978-http-static-client-timeout.ts": 3607, + "2978-regexp-optional-subject.js": 3504, + "2979-array-search-mixed-needles.js": 2692, + "2979-http-static-server-timeout.ts": 3769, + "2980-http-static-server-timeout-default.ts": 3050, + "2980-string-position-arguments.js": 3269, + "2981-http-static-events.ts": 2644, + "2981-string-optional-positions.ts": 2494, + "2982-http-static-close-all.ts": 2737, + "2982-string-position-coercion-order.js": 3410, + "2983-http-static-close-idle.ts": 3031, + "2984-http-static-close-upgrade.ts": 3101, + "2985-http-static-message-destroy.ts": 3632, + "2986-http-static-client-socket-finish.ts": 2911, + "2987-http-static-timeout-errors.ts": 3301, + "2988-http-static-client-abort.ts": 2940, + "2989-http-static-response-timeout-handled.ts": 3640, + "2990-http-static-request-timeout-handled.ts": 3597, + "2991-array-indexed-equality.ts": 3696, + "2992-stream-rows.ts": 3357, + "2993-fiber-stack-lifetimes.ts": 3545, + "2994-fromcharcode-scalar.ts": 3381, + "2995-math-hyperbolic.ts": 3225, + "2996-math-near-one.ts": 2714, + "2997-math-integer-float.ts": 3635, + "300-if-else.ts": 2510, + "3001-caught-typeof-object.js": 3444, + "3002-promise-then-two.ts": 3645, + "301-while.ts": 3200, + "302-for.ts": 2865, + "3020-string-last-index-position.ts": 3627, + "3021-buffer-union-narrow-callback.ts": 3829, + "3022-string-affix-positions.ts": 3463, + "3023-string-affix-position-coercion.js": 3644, + "3024-string-number-narrow-for-in.ts": 3394, + "3025-string-search-position-coercion.js": 3367, + "3026-array-last-index-of.js": 2868, + "3027-array-last-index-of-records.ts": 3472, + "3028-string-search-dynamic-needle.js": 2934, + "3029-string-search-union-needle.js": 3701, + "303-break-continue.ts": 2701, + "3030-array-search-no-arg.js": 3806, + "3031-array-relative-index-coercion.js": 3498, + "3031-string-last-index-search-value.js": 2610, + "3032-string-search-value.js": 3067, + "3033-string-search-needle-coercion.js": 3292, + "3034-arguments-with-parameters.js": 2687, + "3035-string-positioned-search-value.js": 3575, + "3036-string-object-search-value.js": 2688, + "3037-number-nullish-conversion.js": 3018, + "3038-number-scalar-unions.ts": 2381, + "3039-string-repeat-count.js": 2336, + "304-compound-incdec.ts": 3307, + "3040-string-prototype-call.js": 3584, + "3041-string-prototype-object-call.js": 3163, + "3042-string-padding-coercion.js": 3486, + "3043-string-split-arguments.js": 3038, + "3044-array-slice-splice-positions.js": 3582, + "3045-array-indexed-mutation.js": 4003, + "3046-array-indexed-ref-identity.ts": 2594, + "3047-object-prototype-tag.js": 5012, + "3048-object-own-prototype.ts": 4080, + "3049-array-flat-depth.ts": 3414, + "305-truthiness.ts": 2664, + "3050-array-splice-insert.ts": 2966, + "3051-array-join-default.ts": 3468, + "3052-array-construction.ts": 4201, + "3053-array-construction-js.js": 2937, + "3054-dynamic-abort-record.ts": 25141, + "3055-default-builtin-nodenext/main.ts": 2702, + "3056-default-builtin-bundler/main.ts": 3487, + "3057-default-builtin-nodenext-dynamic/main.ts": 2447, + "3058-optional-array-chain-join.ts": 3991, + "3059-arguments-property-names.ts": 2550, + "3061-concurrent-fiber-stacks.ts": 3788, + "3062-runtime-optional-record-guards.ts": 3181, + "3063-runtime-optional-class-guards.ts": 3568, + "3064-installed-entry-imports/main.ts": 2606, + "3065-installed-entry-js/main.js": 3045, + "3066-source-debugging/main.ts": 3383, + "3067-cjs-function-export-require/main.cjs": 2939, + "3068-debug-variables/main.ts": 2618, + "3068-url-checked-identity.ts": 3006, + "3069-set-checked-seed.js": 3140, + "3069-tuple-spread.ts": 3376, + "3070-checked-object-accessors.js": 3573, + "3070-collection-views.ts": 3175, + "3071-checked-specialization-narrowing.js": 3321, + "3071-map-contextual-record-seeds.ts": 4329, + "3072-optional-union-receivers.ts": 3610, + "3072-weak-process-streams.js": 2918, + "3073-optional-callable-module.js": 3300, + "3073-union-keyed-reads.ts": 3869, + "3074-discriminated-intersections.ts": 3384, + "3075-recursive-contextual-literals.ts": 4502, + "3076-nullish-record-defaults.ts": 3009, + "3077-optional-union-array-reads.ts": 3992, + "3078-forward-mutable-captures.ts": 3466, + "3079-forward-mutable-tdz.ts": 3489, + "3080-exhaustive-never-bindings.ts": 3664, + "3081-recursive-array-destinations.ts": 3893, + "3082-forward-write-unwind.ts": 3471, + "3083-set-string-seed.ts": 3139, + "3084-record-own-membership.ts": 2971, + "3085-conditional-record-construction.ts": 3822, + "3086-error-constructor-options.ts": 3660, + "3087-error-options-lifetime.ts": 2905, + "3088-array-wide-callbacks.ts": 3195, + "3089-array-find-narrowing.ts": 4220, + "3090-json-discriminated-records.ts": 3463, + "3091-json-recursive-discriminants.ts": 3555, + "3092-number-union-predicates.ts": 2884, + "3093-error-option-data.ts": 2574, + "3094-json-replacer-traversal.ts": 3823, + "3095-json-reviver-traversal.ts": 3825, + "3096-json-callback-nonfinite.ts": 3620, + "3097-json-callback-reentrancy.ts": 2760, + "3098-json-callback-space.ts": 3696, + "3099-json-callback-functions.ts": 4108, + "3100-json-callback-holder.js": 3675, + "3101-json-callback-bytes.ts": 3250, + "3102-json-unknown-fields.ts": 2925, + "3103-scalar-record-nested-control-flow.ts": 3592, + "3104-native-analysis-tables-loops.ts": 3494, + "3105-nullable-collections.ts": 3244, + "3106-mixed-insertion-spreads.ts": 4146, + "3107-nullable-collection-lifetimes.ts": 3486, + "3108-for-await-sync-arrays.js": 4312, + "3108-identity-map-keys.ts": 3894, + "3109-destructuring-unknown-defaults.js": 3234, + "3109-identity-union-collections.ts": 3977, + "3110-builtin-error-families.ts": 3250, + "3110-identity-collection-mutation.ts": 3825, + "3111-identity-collection-cycles.ts": 3640, + "3112-union-switch-control-flow.ts": 2681, + "3113-union-array-removal.ts": 3778, + "3114-union-record-field-write.ts": 3884, + "3115-zlib-static-compression-levels.ts": 4085, + "3116-sequence-expression-lifetimes.ts": 3245, + "3117-unknown-switch-control-flow.ts": 3706, + "3118-recursive-union-spread.ts": 3476, + "3119-runtime-optional-spread.ts": 4508, + "3120-dynamic-property-descriptors.js": 3228, + "3120-generator-method-loop-bindings.ts": 3222, + "3120-ir-nonfinite-numbers.ts": 3251, + "3121-compound-assignment-values.js": 3525, + "3121-dynamic-accessor-descriptors.js": 4470, + "3122-dynamic-delete-descriptors.cjs": 3353, + "3122-dynamic-delete-descriptors.js": 3300, + "3122-js-async-class-methods.js": 3524, + "3123-destructured-global-tdz.js": 3896, + "3124-array-prototype-borrow.js": 4000, + "3125-regex-global-match.ts": 2889, + "3126-js-number-radix/main.ts": 3491, + "3127-spawn-runtime-options.ts": 3338, + "3128-regex-last-index.ts": 3768, + "3129-js-token-union/main.ts": 3461, + "3130-child-generic-streams.ts": 3435, + "3131-child-rest-listeners.js": 3280, + "3132-child-generic-stream-completion.ts": 6821, + "3133-text-decoder-streaming.ts": 32031, + "3134-fs-vectors.ts": 3621, + "3135-fs-file-handle-controls.ts": 3152, + "3136-fs-file-handle-options.ts": 4992, + "3137-fs-vector-callbacks.cjs": 3636, + "3138-array-large-storage.ts": 5104, + "3139-regex-native-deep-alternatives.ts": 38096, + "3140-array-dense-access.ts": 4712, + "3141-map-string-key-hash.ts": 3358, + "3150-integer-remainder.ts": 3568, + "3151-array-push-writes.ts": 3892, + "3170-number-conversion-fast-paths.ts": 2663, + "3171-method-census-data-writes.ts": 4253, + "400-fib.ts": 3919, + "401-mutual-recursion.ts": 2844, + "402-string-functions.ts": 3081, + "403-void-and-params.ts": 3112, + "4030-runtime-object-truthiness.ts": 3275, + "4031-event-emitter-long-tuples.ts": 3646, + "4032-inline-rc-fast-paths.ts": 4866, + "404-rc-stress.ts": 2781, + "4040-adapted-function-identity.ts": 3610, + "4041-adapted-function-properties.ts": 3413, + "4042-object-is-union-subclass.ts": 2746, + "4043-nonnull-missing-element.ts": 3815, + "4044-adapted-callback-modules/main.ts": 2918, + "4045-optional-element-projections.ts": 4182, + "4046-captured-parameter-values.ts": 4191, + "4047-captured-parameter-rebinding.ts": 2867, + "405-params-optional.ts": 2408, + "406-params-defaults.ts": 2614, + "4060-cycle-shared-instance/main.ts": 2758, + "4060-stack-union-reads.ts": 4386, + "4061-cycle-evaluation-order/main.ts": 3229, + "4061-nullable-ref-fields.ts": 6151, + "4062-cycle-tdz-read/main.ts": 3056, + "4063-cycle-hoisted-calls/main.ts": 3238, + "4064-cycle-classes-after-init/main.ts": 2548, + "4065-cycle-init-throws/main.ts": 2955, + "4066-cycle-top-level-tdz/main.ts": 3040, + "4067-dynamic-import-cycle-tdz/main.ts": 3004, + "407-params-rest.ts": 3335, + "408-params-ctors-inheritance.ts": 3021, + "4080-optional-read-presence-tests.ts": 3095, + "4080-string-index-bounds.ts": 3083, + "4081-hoisted-function-tdz.ts": 3193, + "4081-string-index-unproven.ts": 3273, + "4082-hoisted-function-tdz-uncaught.ts": 2845, + "4083-dynamic-import-failure/main.ts": 3748, + "4084-record-optional-field-copies.ts": 4118, + "4085-generator-loop-close.ts": 3638, + "4086-optional-capture-defaults.ts": 3227, + "4088-class-static-tdz.ts": 3234, + "4089-class-wrapper-tdz.js": 3393, + "409-params-async-generics.ts": 2742, + "4090-computed-key-tdz.js": 2796, + "4091-class-evaluation-deferred.ts": 3464, + "410-params-rc-stress.ts": 3461, + "4140-array-callback-split-visit.ts": 7289, + "4141-array-callback-ambient-receiver/main.ts": 3100, + "4142-array-callback-factories.ts": 4541, + "4143-union-refinement-intersection-arms.ts": 3822, + "420-dead-strip-modules/main.ts": 3118, + "4290-acyclic-immutable-trees.ts": 3580, + "4291-acyclic-constructor-escapes.ts": 3039, + "4292-acyclic-readonly-bypass.ts": 4316, + "4293-acyclic-dynamic-writes.ts": 3268, + "4294-console-line-sizes.ts": 6986, + "4295-console-template-parts.ts": 3358, + "4296-console-glued-long-parts.ts": 3290, + "4410-inline-object-allocation.ts": 3305, + "4411-nullable-ref-values.ts": 5301, + "4412-nullable-record-values.ts": 5088, + "4413-cycle-old-late-death.ts": 4012, + "4413-nullable-null-and-undefined.ts": 4328, + "4414-cycle-old-weak-keys.ts": 4005, + "4414-nullable-string-values.ts": 5044, + "4415-identity-borrowed-operands.ts": 3101, + "4415-nullable-container-values.ts": 4932, + "4431-exception-pending-contexts.ts": 3487, + "4432-checked-downcast-failures.ts": 3971, + "4451-int32-field-storage.ts": 3668, + "4452-int32-field-dynamic-writes.ts": 4531, + "4453-int32-closed-locals.ts": 2786, "4454-int32-field-reflection-reads.ts": 3494, "4455-live-view-reads-without-stores.ts": 4871, - "4471-unassigned-field-reads.ts": 3438, - "4476-string-ascii-header-fact.ts": 4141, - "4477-buffer-write-ascii-runs.ts": 4249, - "4478-string-large-index-reads.ts": 4215, - "4481-array-optional-push.ts": 3757, - "4482-instanceof-static-class-optional.ts": 3228, - "4483-array-splice-statement.ts": 4359, - "4484-array-length-reset.ts": 3824, - "4485-array-splice-optional-item.ts": 4447, - "4486-array-field-element-borrows.ts": 4170, - "4487-array-literal-optional-values.ts": 3597, - "4520-optional-guard-narrowing.ts": 4519, - "4521-array-callback-element-presence.ts": 6504, - "4522-captured-parameter-lifetimes.ts": 3501, - "4523-array-pop-removal.ts": 4310, - "4524-array-callback-supertype-params.ts": 4795, - "4541-nullable-wrap-borrows.ts": 4219, - "4542-preserving-call-borrows.ts": 4390, - "4543-walk-borrowed-locals.ts": 4424, - "4544-checked-cast-aliases.ts": 4017, - "4545-borrowed-returns.ts": 5010, - "4546-rebound-borrowed-params.ts": 4038, - "4560-field-store-borrowed-receivers.ts": 4292, - "4561-virtual-borrowed-parameters.ts": 3188, - "4562-string-self-concat-move.ts": 3258, - "4563-array-read-projection-receivers.ts": 4193, - "4564-literal-choice-strings.ts": 4376, - "4568-for-of-hole-elements.ts": 4040, - "4569-shorthand-missing-elements.ts": 5489, - "4570-map-lookup-default-record.ts": 4379, - "4591-weak-keys-union-records.ts": 3376, - "4592-cycle-const-from-import/main.ts": 3235, - "4593-weak-keys-empty-objects.ts": 4125, - "4594-union-class-field-mixed-types.ts": 6642, - "4595-union-class-field-optional-receiver.ts": 3958, - "4596-error-subclass-int-fields.ts": 3809, - "4596-tdz-nullable-forward-capture.ts": 5432, - "4597-callback-field-method-name.ts": 4265, - "4598-live-array-ref-element-access.ts": 9798, - "4598-map-set-clear-reuse.ts": 5772, - "4598-os-available-parallelism.ts": 3841, - "4598-publish-constructor-stores.ts": 4373, - "4599-construction-only-field-borrows.ts": 4185, - "4600-construction-only-fields-dynamic-writes.ts": 3870, - "4601-cycle-holders.ts": 3436, - "4602-constructor-escape-order.ts": 4107, - "4610-array-ext-dyn-refresh.ts": 4200, - "4620-optional-chain-borrowed-receivers.ts": 3633, - "4621-edge-preserving-callees/main.ts": 4459, - "4630-contract-int32.ts": 3693, - "4630-reference-write-call-arguments.ts": 3005, - "4631-contract-nothrow.ts": 3977, - "4631-reference-write-aliases.ts": 4000, - "4632-contract-immutable.ts": 4206, - "4632-reference-write-loops-and-walks.ts": 3622, - "4633-contract-program-lifetime.ts": 4928, - "4633-reference-write-callbacks-returns.ts": 4472, - "4634-contract-program-lifetime-publish.ts": 58146, - "4634-optional-element-borrowed-returns.ts": 3892, - "4640-bitwise-identity-ranges.ts": 3488, - "4641-nothrow-try-catch.ts": 3941, - "4642-acyclic-contract.ts": 4488, - "4650-stale-property-narrowing.ts": 5393, - "4651-map-string-get-entry.ts": 4850, - "4652-stale-closure-binding-narrowing.ts": 4646, - "4660-typed-rest-spread-forwarding.ts": 3964, - "4671-scoped-array-read-borrows.ts": 4659, - "4690-cycle-bypass-long-lived.ts": 6611, - "4691-publish-constructor-self-alias.ts": 32098, - "4692-borrowed-result-mutating-callees.ts": 4121, - "4720-cold-throw-paths.ts": 3462, - "4721-integer-induction-numbers.ts": 4315, - "4730-touint32-large-magnitudes.ts": 4331, - "4731-string-mixed-ascii-slices.ts": 4955, - "4732-buffer-write-utf16le-runs.ts": 4567, - "4733-typed-array-read-compares.ts": 4680, - "4750-map-string-absent-filter.ts": 3842, - "4751-string-search-multibyte-needles.ts": 4006, - "4795-published-untyped-member-reads.ts": 3280, - "4806-uint32-loop-accumulators.ts": 4561, - "4810-union-identity-retags.ts": 35042, - "4811-union-retag-checked-cast.ts": 4067, - "4812-int32-wrapping-sums.ts": 5061, - "4813-typed-array-read-equality-bindings.ts": 6041, - "4820-sort-comparator-lent-arguments.ts": 5459, - "4821-callback-lent-arguments.ts": 5557, - "4822-stable-capture-reads.ts": 4662, - "4823-array-store-receivers.ts": 3343, - "4830-typed-teardown-chains.ts": 4609, - "4831-cycle-bypass-probe-windows.ts": 6532, - "4840-array-hole-free-prefix.ts": 5275, - "4860-int32-local-storage.ts": 4493, - "4870-array-pipeline-fusion.ts": 9864, - "4871-array-pipeline-analytics.ts": 5983, - "4872-array-pipeline-temporaries.ts": 10585, - "4875-stream-consumers-array-buffer.ts": 5489, - "4876-array-buffer-inspect.ts": 4454, - "4880-await-call-turn-order.ts": 4340, - "4881-await-call-exceptions.ts": 3334, - "4882-await-call-request-chain.ts": 4240, - "4883-await-values-and-hops.ts": 3792, - "4884-await-call-unhandled-sibling.ts": 4171, - "4885-await-call-checkpoints.ts": 4125, - "4890-regex-literal-sites.ts": 3489, - "4891-regex-plain-text-patterns.ts": 3217, - "4892-regex-exec-read-captures.ts": 3864, - "4900-bigint-division-cross-check.ts": 4497, - "4900-console-instances.ts": 4959, - "4901-bigint-radix-text.ts": 4256, - "4901-console-instance-errors.ts": 2879, - "4902-bigint-compound-assign.ts": 3676, - "4903-bigint-fixed-width.ts": 3178, - "4904-bigint-large-products.ts": 3926, - "4905-bigint-fixed-width-fusion.ts": 5267, - "4906-bigint-small-value-trees.ts": 5678, - "4907-bigint-random-trees.ts": 7288, - "4910-hole-free-prefix-upkeep.ts": 4535, - "4920-string-literal-switch.ts": 4267, - "4930-typed-record-reflection.ts": 5782, - "4931-typed-data-generic-walks.ts": 6195, - "4932-typed-json-unknown.ts": 4431, - "4940-async-return-adoption.ts": 4857, - "4941-async-return-adoption-try.ts": 4613, - "4942-async-return-adoption-values.ts": 6005, - "4943-async-return-adoption-interleaved.ts": 3930, - "4950-regex-compiled-captures.ts": 5282, - "4951-regex-compiled-last-index.ts": 4338, - "4952-regex-compiled-anchors-classes.ts": 4435, - "4953-regex-compiled-backtracking.ts": 5380, - "4954-regex-log-report.ts": 5479, - "4955-regex-compiled-differential.ts": 20554, - "4970-int32-call-abi.ts": 4776, - "4980-generator-early-exit-finally.ts": 4365, - "4981-generator-delegation-iterables.ts": 5570, - "4982-generator-sent-values.ts": 4472, - "4983-generator-reuse-iterables.ts": 2952, - "4984-generator-exceptions.ts": 4164, - "4985-generator-lazy-pipeline.ts": 5491, - "4986-generator-default-channels.ts": 3496, - "4987-generator-closures-methods.ts": 4260, - "4988-generator-async-interplay.ts": 4288, - "4989-generator-step-drives.ts": 4530, - "4990-lone-surrogates.ts": 4508, - "4991-lone-surrogate-halves.ts": 4237, - "4992-lone-surrogate-search.ts": 4305, - "4993-lone-surrogate-json.ts": 4527, - "4994-lone-surrogate-uri.ts": 4891, - "4995-lone-surrogate-regex.ts": 4198, - "4996-lone-surrogate-stdio.ts": 3963, - "4997-lone-surrogate-stdout-patch.js": 4611, - "4998-lone-surrogate-buffers.ts": 4299, - "4999-lone-surrogate-io.ts": 4020, - "500-array-basics.ts": 4115, - "501-array-push-pop.ts": 4134, - "5010-lifetime-region-generations.ts": 4583, - "5011-lifetime-region-outside-references.ts": 3728, - "5012-lifetime-region-shapes.ts": 4853, - "5013-lifetime-region-async.ts": 5075, - "5014-lifetime-region-nesting.ts": 4021, - "5015-lifetime-region-publish.ts": 41998, - "5016-lifetime-region-weak-keys.ts": 3440, - "5017-lifetime-region-cycles.ts": 3981, - "5018-lifetime-region-hierarchies.ts": 5065, - "5019-lifetime-region-values.ts": 4354, - "502-array-for-of.ts": 3573, - "5020-lifetime-region-large.ts": 6813, - "5021-lifetime-region-opaque-holders.ts": 3165, - "5022-lifetime-region-workers.ts": 44993, + "4471-unassigned-field-reads.ts": 3896, + "4476-string-ascii-header-fact.ts": 3522, + "4477-buffer-write-ascii-runs.ts": 3321, + "4478-string-large-index-reads.ts": 4146, + "4481-array-optional-push.ts": 3259, + "4482-instanceof-static-class-optional.ts": 3786, + "4483-array-splice-statement.ts": 4036, + "4484-array-length-reset.ts": 2849, + "4485-array-splice-optional-item.ts": 3817, + "4486-array-field-element-borrows.ts": 2903, + "4487-array-literal-optional-values.ts": 3145, + "4520-optional-guard-narrowing.ts": 2774, + "4521-array-callback-element-presence.ts": 5601, + "4522-captured-parameter-lifetimes.ts": 3907, + "4523-array-pop-removal.ts": 3769, + "4524-array-callback-supertype-params.ts": 4594, + "4541-nullable-wrap-borrows.ts": 3939, + "4542-preserving-call-borrows.ts": 3361, + "4543-walk-borrowed-locals.ts": 3633, + "4544-checked-cast-aliases.ts": 3723, + "4545-borrowed-returns.ts": 4116, + "4546-rebound-borrowed-params.ts": 2930, + "4560-field-store-borrowed-receivers.ts": 4438, + "4561-virtual-borrowed-parameters.ts": 3634, + "4562-string-self-concat-move.ts": 2703, + "4563-array-read-projection-receivers.ts": 3601, + "4564-literal-choice-strings.ts": 3137, + "4568-for-of-hole-elements.ts": 3387, + "4569-shorthand-missing-elements.ts": 3958, + "4570-map-lookup-default-record.ts": 3112, + "4591-weak-keys-union-records.ts": 3556, + "4592-cycle-const-from-import/main.ts": 3467, + "4593-weak-keys-empty-objects.ts": 2938, + "4594-union-class-field-mixed-types.ts": 4040, + "4595-union-class-field-optional-receiver.ts": 3379, + "4596-error-subclass-int-fields.ts": 3559, + "4596-tdz-nullable-forward-capture.ts": 4676, + "4597-callback-field-method-name.ts": 4014, + "4598-live-array-ref-element-access.ts": 8384, + "4598-map-set-clear-reuse.ts": 4224, + "4598-os-available-parallelism.ts": 3815, + "4598-publish-constructor-stores.ts": 3618, + "4599-construction-only-field-borrows.ts": 3619, + "4600-construction-only-fields-dynamic-writes.ts": 3184, + "4601-cycle-holders.ts": 3348, + "4602-constructor-escape-order.ts": 3674, + "4610-array-ext-dyn-refresh.ts": 4598, + "4620-optional-chain-borrowed-receivers.ts": 3411, + "4621-edge-preserving-callees/main.ts": 3288, + "4630-contract-int32.ts": 2810, + "4630-reference-write-call-arguments.ts": 3333, + "4631-contract-nothrow.ts": 3196, + "4631-reference-write-aliases.ts": 4264, + "4632-contract-immutable.ts": 3449, + "4632-reference-write-loops-and-walks.ts": 3791, + "4633-contract-program-lifetime.ts": 4644, + "4633-reference-write-callbacks-returns.ts": 4024, + "4634-contract-program-lifetime-publish.ts": 42618, + "4634-optional-element-borrowed-returns.ts": 3411, + "4640-bitwise-identity-ranges.ts": 3713, + "4641-nothrow-try-catch.ts": 3056, + "4642-acyclic-contract.ts": 4040, + "4650-stale-property-narrowing.ts": 3665, + "4651-map-string-get-entry.ts": 3369, + "4652-stale-closure-binding-narrowing.ts": 3504, + "4660-typed-rest-spread-forwarding.ts": 3148, + "4671-scoped-array-read-borrows.ts": 3020, + "4690-cycle-bypass-long-lived.ts": 5374, + "4691-publish-constructor-self-alias.ts": 38620, + "4692-borrowed-result-mutating-callees.ts": 3592, + "4720-cold-throw-paths.ts": 4339, + "4721-integer-induction-numbers.ts": 3854, + "4730-touint32-large-magnitudes.ts": 3431, + "4731-string-mixed-ascii-slices.ts": 4436, + "4732-buffer-write-utf16le-runs.ts": 4084, + "4733-typed-array-read-compares.ts": 3240, + "4750-map-string-absent-filter.ts": 3584, + "4751-string-search-multibyte-needles.ts": 3227, + "4795-published-untyped-member-reads.ts": 3450, + "4806-uint32-loop-accumulators.ts": 3543, + "4810-union-identity-retags.ts": 34911, + "4811-union-retag-checked-cast.ts": 3044, + "4812-int32-wrapping-sums.ts": 3457, + "4813-typed-array-read-equality-bindings.ts": 4853, + "4820-sort-comparator-lent-arguments.ts": 3579, + "4821-callback-lent-arguments.ts": 4210, + "4822-stable-capture-reads.ts": 3094, + "4823-array-store-receivers.ts": 3774, + "4830-typed-teardown-chains.ts": 3908, + "4831-cycle-bypass-probe-windows.ts": 6157, + "4840-array-hole-free-prefix.ts": 3932, + "4860-int32-local-storage.ts": 5136, + "4870-array-pipeline-fusion.ts": 6645, + "4871-array-pipeline-analytics.ts": 4575, + "4872-array-pipeline-temporaries.ts": 10635, + "4875-stream-consumers-array-buffer.ts": 4120, + "4876-array-buffer-inspect.ts": 2819, + "4880-await-call-turn-order.ts": 3872, + "4881-await-call-exceptions.ts": 3027, + "4882-await-call-request-chain.ts": 2730, + "4883-await-values-and-hops.ts": 3412, + "4884-await-call-unhandled-sibling.ts": 3410, + "4885-await-call-checkpoints.ts": 2703, + "4890-regex-literal-sites.ts": 3712, + "4891-regex-plain-text-patterns.ts": 3018, + "4892-regex-exec-read-captures.ts": 4130, + "4900-bigint-division-cross-check.ts": 3763, + "4900-console-instances.ts": 4286, + "4901-bigint-radix-text.ts": 3099, + "4901-console-instance-errors.ts": 3171, + "4902-bigint-compound-assign.ts": 3431, + "4903-bigint-fixed-width.ts": 3707, + "4904-bigint-large-products.ts": 3972, + "4905-bigint-fixed-width-fusion.ts": 3443, + "4906-bigint-small-value-trees.ts": 4875, + "4907-bigint-random-trees.ts": 5277, + "4910-hole-free-prefix-upkeep.ts": 4073, + "4920-string-literal-switch.ts": 3607, + "4930-typed-record-reflection.ts": 4869, + "4931-typed-data-generic-walks.ts": 5228, + "4932-typed-json-unknown.ts": 3250, + "4940-async-return-adoption.ts": 4405, + "4941-async-return-adoption-try.ts": 3533, + "4942-async-return-adoption-values.ts": 4824, + "4943-async-return-adoption-interleaved.ts": 3851, + "4950-regex-compiled-captures.ts": 5146, + "4951-regex-compiled-last-index.ts": 4316, + "4952-regex-compiled-anchors-classes.ts": 3149, + "4953-regex-compiled-backtracking.ts": 3822, + "4954-regex-log-report.ts": 4449, + "4955-regex-compiled-differential.ts": 20102, + "4970-int32-call-abi.ts": 3029, + "4980-generator-early-exit-finally.ts": 3262, + "4981-generator-delegation-iterables.ts": 5306, + "4982-generator-sent-values.ts": 3649, + "4983-generator-reuse-iterables.ts": 4023, + "4984-generator-exceptions.ts": 4220, + "4985-generator-lazy-pipeline.ts": 3164, + "4986-generator-default-channels.ts": 3434, + "4987-generator-closures-methods.ts": 3505, + "4988-generator-async-interplay.ts": 2790, + "4989-generator-step-drives.ts": 3509, + "4990-lone-surrogates.ts": 3213, + "4991-lone-surrogate-halves.ts": 4020, + "4992-lone-surrogate-search.ts": 3375, + "4993-lone-surrogate-json.ts": 3473, + "4994-lone-surrogate-uri.ts": 3848, + "4995-lone-surrogate-regex.ts": 4302, + "4996-lone-surrogate-stdio.ts": 2592, + "4997-lone-surrogate-stdout-patch.js": 3072, + "4998-lone-surrogate-buffers.ts": 3134, + "4999-lone-surrogate-io.ts": 3225, + "500-array-basics.ts": 2886, + "501-array-push-pop.ts": 2682, + "5010-lifetime-region-generations.ts": 4147, + "5011-lifetime-region-outside-references.ts": 3407, + "5012-lifetime-region-shapes.ts": 4861, + "5013-lifetime-region-async.ts": 3124, + "5014-lifetime-region-nesting.ts": 3259, + "5015-lifetime-region-publish.ts": 27669, + "5016-lifetime-region-weak-keys.ts": 2554, + "5017-lifetime-region-cycles.ts": 3105, + "5018-lifetime-region-hierarchies.ts": 4007, + "5019-lifetime-region-values.ts": 2888, + "502-array-for-of.ts": 3621, + "5020-lifetime-region-large.ts": 4812, + "5021-lifetime-region-opaque-holders.ts": 3957, + "5022-lifetime-region-workers.ts": 38841, "5023-lifetime-region-await.ts": 5986, "5024-lifetime-region-await-forms.ts": 5123, - "503-array-functions.ts": 4084, - "504-array-rc-stress.ts": 3791, - "5040-promise-all-race-turns.ts": 5348, - "5041-promise-all-turns.js": 4084, - "5042-async-generator-return-promise.ts": 4929, - "5043-async-generator-return-forms.ts": 3900, - "5045-generator-delegation-typed-next.ts": 4863, - "5046-generator-delegation-return-throw.ts": 4938, - "5047-generator-delegation-iterables-typed.ts": 4203, - "5048-generator-delegation-async.ts": 4733, - "5049-generator-delegation-edges.ts": 5078, - "5050-inherited-in-membership.ts": 4630, - "5051-typed-record-prototypes.ts": 4286, - "5052-class-for-in-unknown.ts": 4449, - "5053-json-replacer-arrays.ts": 4672, - "5054-required-field-delete.ts": 3969, - "5055-object-create-record-literal.ts": 3612, - "5056-generator-in-unknown.ts": 3544, - "5060-child-fork-exit-after-messages/main.ts": 3945, - "5061-child-fork-local-disconnect/main.ts": 3909, - "5062-child-fork-message-before-eof/main.ts": 4129, - "5065-global-increment-initializers.ts": 3769, - "5066-global-compound-updates.ts": 4136, - "5067-global-updates-in-functions.ts": 3795, - "5068-global-var-let-const-updates.ts": 3571, - "5069-global-update-modules/main.ts": 3587, - "5070-optional-read-bindings.ts": 3671, - "5071-optional-chain-scalars.ts": 4013, - "5072-optional-nullish-ternary.ts": 4374, - "5073-optional-results.ts": 4392, - "5074-optional-pop-shift.ts": 3500, - "5075-optional-reads-unchecked/main.ts": 3399, - "5076-optional-escapes.ts": 4284, - "5080-boolean-array-storage.ts": 10145, - "5081-boolean-array-dynamic-views.ts": 5152, - "5085-promise-allsettled-turns.ts": 5572, - "5086-promise-any-turns.ts": 4418, - "5087-promise-allsettled-any-dyn.js": 6479, - "5088-promise-combinator-thenables.js": 3786, - "5089-promise-settled-records.ts": 4701, - "5090-generator-finished-result-value.ts": 4294, - "5091-generator-delegation-arrays-strings.ts": 4885, - "5092-generator-delegation-sets-maps.ts": 3752, - "5095-console-count-group.ts": 4618, - "5096-console-assert-dir.ts": 5191, - "5097-console-table.ts": 3751, - "5098-console-time-warnings.ts": 9353, - "5099-console-methods-dynamic.cjs": 4255, - "510-array-map-filter-foreach.ts": 4191, - "511-array-indexof-includes.ts": 3499, - "5110-var-hoisting-early-reads.ts": 3823, - "5111-var-hoisting-closures-classes.ts": 4157, - "5112-var-hoisting-function-scope.ts": 3874, - "5113-tdz-let-const-class.ts": 3814, - "5114-var-hoisting-js.js": 3818, - "5115-regex-replace-compiled.ts": 3620, - "5116-regex-capture-reads.ts": 2873, - "5117-regex-log-report-spans.ts": 4784, - "5118-regex-replace-char-chains.ts": 3663, - "512-array-join-chains.ts": 2771, - "5120-frame-records.ts": 3939, - "5121-frame-objects.ts": 2783, - "5122-frame-result-slots.ts": 3197, - "5123-frame-reassigned.ts": 3173, - "5124-frame-objects-control.ts": 3904, - "5125-frame-mutating-methods.ts": 3799, - "5126-frame-returned-params.ts": 3813, - "5127-frame-loop-bindings.ts": 4488, - "513-array-methods-rc-stress.ts": 3775, - "5130-event-target-dispatch.js": 6111, - "5131-event-target-listener-errors.js": 4456, - "5132-event-target-typed.ts": 7166, - "5133-abort-signal-event-target.ts": 23098, - "5134-events-error-monitor.ts": 4010, - "5135-event-target-warnings.js": 31124, - "5136-events-error-monitor-string-name.ts": 4008, - "5137-events-error-monitor-computed-name.js": 4468, - "5138-events-error-monitor-shared-listener.ts": 3052, - "5139-event-target-listener-throw.ts": 4657, - "514-array-find-some-every.ts": 3980, - "5140-os-host-facts.ts": 3296, - "5141-os-constants.ts": 4894, - "5142-path-parse-format.ts": 4155, - "5145-path-matches-glob-basics.ts": 3777, - "5146-path-matches-glob-braces.ts": 5827, - "5147-path-matches-glob-extglob.ts": 4341, - "5148-path-matches-glob-classes.ts": 2888, - "5149-path-matches-glob-win32.ts": 4096, - "515-array-flatmap.ts": 4332, - "5150-small-array-inline-slots.ts": 3637, - "5155-cycle-header-types.ts": 43009, - "516-array-reduce.ts": 4514, - "5160-field-callback-receiver.ts": 4758, - "5161-field-callback-receiver-escape.ts": 3837, - "5162-field-method-reference-receiver.ts": 4262, - "5163-field-callback-receiver.cjs": 5679, - "5164-worker-field-callback-receiver.ts": 38682, - "5165-interface-method-dispatch.ts": 4568, - "5166-interface-method-values.ts": 5588, - "5167-interface-method-order.ts": 5287, - "5168-interface-method-hierarchy.ts": 6196, - "5169-interface-method-chains.ts": 4139, - "517-array-hof-index-args.ts": 4188, - "5170-string-scan-eviction.ts": 3592, - "5171-lone-surrogate-replace-seams.ts": 3960, - "5175-forin-typed-as-unknown.ts": 4247, - "5176-object-keys-typed-as-unknown.ts": 3688, - "5177-forin-dynamic-objects.ts": 4079, - "5178-forin-keys-js.js": 3608, - "5179-forin-typed-shapes.ts": 4197, - "518-array-sort.ts": 4624, - "518-promise-void-union-callbacks.ts": 4051, - "5180-interface-arrays.ts": 3814, - "5181-interface-array-methods.ts": 11031, - "5182-interface-array-boundaries.ts": 3743, - "5183-interface-property-reads.ts": 4427, - "5184-interface-property-objects.ts": 3309, - "5185-util-inherits.cjs": 5164, - "5186-util-inherits.ts": 4876, - "5187-util-deprecate.cjs": 4074, - "5188-util-deprecate-flags.cjs": 4955, - "5189-util-deprecate.ts": 5071, - "519-array-from-length.ts": 4423, - "519-promise-union-await-values.ts": 3904, - "5190-util-callbackify.cjs": 7841, - "5191-util-callbackify.ts": 6629, - "5192-util-debuglog.cjs": 6718, - "5193-util-debuglog.ts": 4689, - "5194-process-emit-warning-tick.cjs": 3727, - "5195-object-entries-typed-as-unknown.ts": 5084, - "5196-object-values-typed-as-unknown.ts": 3864, - "5197-object-entries-dynamic-objects.ts": 4955, - "5198-object-entries-values-js.js": 4220, - "5199-object-entries-identity.ts": 3999, - "520-map-basics.ts": 3545, - "5200-array-sort-keyed-numbers.ts": 5325, - "5201-array-sort-keyed-records.ts": 7394, - "5202-array-sort-keyed-lookalikes.ts": 5009, - "5203-typed-array-sort-default.ts": 8431, - "5204-typed-array-sort-comparators.ts": 5119, - "521-map-number-keys.ts": 3823, - "5210-process-memory-usage.ts": 4235, - "5211-process-identity.ts": 3797, - "5212-perf-marks-measures.ts": 5056, - "5213-perf-timing-errors.ts": 4031, - "5214-perf-entry-inspect.ts": 4809, - "5215-perf-timing-validation.js": 6147, - "5216-perf-spread-arguments.js": 4892, - "5217-perf-spread-typed.ts": 4228, - "522-map-foreach.ts": 4028, - "5220-url-parse-warnings.ts": 3469, - "5221-url-parse-shapes.ts": 6083, - "5222-url-parse-hosts.ts": 5268, - "5223-url-parse-query.ts": 5608, - "5224-url-format-objects.ts": 5477, - "5225-url-format-whatwg.ts": 3013, - "5226-url-resolve.ts": 6250, - "5227-url-legacy-dependency/main.ts": 6988, - "5228-url-domain-conversion.ts": 4749, - "5229-url-legacy-errors.cjs": 6936, - "523-map-ref-values.ts": 4339, - "5230-inline-union-fields.ts": 4733, - "5231-inline-union-field-kinds.ts": 5128, - "5232-inline-union-fields-dynamic.ts": 4858, - "5233-inline-union-fields-shapes.ts": 3241, - "5234-inline-union-class-fields.ts": 3221, - "5235-inline-union-fields-publish.ts": 3389, - "5236-inline-union-unchecked-reads.ts": 4250, - "5237-inline-union-frame-objects.ts": 4148, - "524-map-cycles.ts": 2484, - "5240-event-target-subclass.ts": 7308, - "5241-event-subclass.ts": 5029, - "5242-event-target-subclass-hierarchy.ts": 4680, - "5243-event-target-subclass-dynamic.ts": 6118, - "5244-event-target-subclass.js": 4898, - "5245-event-target-subclass-signals.ts": 8806, - "5246-event-target-subclass-listener-throw.ts": 3474, - "5247-event-target-subclass-lifetimes.ts": 5918, - "5248-event-target-subclass-warnings.ts": 4004, - "5249-event-target-subclass-unconstructed.ts": 3498, - "525-map-rc-stress.ts": 3774, + "503-array-functions.ts": 2982, + "504-array-rc-stress.ts": 3289, + "5040-promise-all-race-turns.ts": 4439, + "5041-promise-all-turns.js": 3708, + "5042-async-generator-return-promise.ts": 3292, + "5043-async-generator-return-forms.ts": 3922, + "5045-generator-delegation-typed-next.ts": 4740, + "5046-generator-delegation-return-throw.ts": 3192, + "5047-generator-delegation-iterables-typed.ts": 4558, + "5048-generator-delegation-async.ts": 3457, + "5049-generator-delegation-edges.ts": 3057, + "5050-inherited-in-membership.ts": 4297, + "5051-typed-record-prototypes.ts": 3534, + "5052-class-for-in-unknown.ts": 3663, + "5053-json-replacer-arrays.ts": 4093, + "5054-required-field-delete.ts": 3619, + "5055-object-create-record-literal.ts": 3237, + "5056-generator-in-unknown.ts": 3060, + "5060-child-fork-exit-after-messages/main.ts": 3584, + "5061-child-fork-local-disconnect/main.ts": 4277, + "5062-child-fork-message-before-eof/main.ts": 3570, + "5065-global-increment-initializers.ts": 2946, + "5066-global-compound-updates.ts": 3425, + "5067-global-updates-in-functions.ts": 3465, + "5068-global-var-let-const-updates.ts": 3395, + "5069-global-update-modules/main.ts": 3167, + "5070-optional-read-bindings.ts": 3316, + "5071-optional-chain-scalars.ts": 3214, + "5072-optional-nullish-ternary.ts": 2900, + "5073-optional-results.ts": 3751, + "5074-optional-pop-shift.ts": 3099, + "5075-optional-reads-unchecked/main.ts": 3754, + "5076-optional-escapes.ts": 3593, + "5080-boolean-array-storage.ts": 7564, + "5081-boolean-array-dynamic-views.ts": 3915, + "5085-promise-allsettled-turns.ts": 4557, + "5086-promise-any-turns.ts": 3994, + "5087-promise-allsettled-any-dyn.js": 5205, + "5088-promise-combinator-thenables.js": 5007, + "5089-promise-settled-records.ts": 4859, + "5090-generator-finished-result-value.ts": 3648, + "5091-generator-delegation-arrays-strings.ts": 3362, + "5092-generator-delegation-sets-maps.ts": 4496, + "5095-console-count-group.ts": 3356, + "5096-console-assert-dir.ts": 3645, + "5097-console-table.ts": 3255, + "5098-console-time-warnings.ts": 7324, + "5099-console-methods-dynamic.cjs": 3314, + "510-array-map-filter-foreach.ts": 3232, + "511-array-indexof-includes.ts": 3286, + "5110-var-hoisting-early-reads.ts": 4048, + "5111-var-hoisting-closures-classes.ts": 2474, + "5112-var-hoisting-function-scope.ts": 3383, + "5113-tdz-let-const-class.ts": 3628, + "5114-var-hoisting-js.js": 3550, + "5115-regex-replace-compiled.ts": 3344, + "5116-regex-capture-reads.ts": 3874, + "5117-regex-log-report-spans.ts": 3719, + "5118-regex-replace-char-chains.ts": 3632, + "512-array-join-chains.ts": 3268, + "5120-frame-records.ts": 3221, + "5121-frame-objects.ts": 3861, + "5122-frame-result-slots.ts": 3008, + "5123-frame-reassigned.ts": 3589, + "5124-frame-objects-control.ts": 3184, + "5125-frame-mutating-methods.ts": 3607, + "5126-frame-returned-params.ts": 3362, + "5127-frame-loop-bindings.ts": 4392, + "513-array-methods-rc-stress.ts": 3208, + "5130-event-target-dispatch.js": 4958, + "5131-event-target-listener-errors.js": 4558, + "5132-event-target-typed.ts": 5171, + "5133-abort-signal-event-target.ts": 22917, + "5134-events-error-monitor.ts": 3499, + "5135-event-target-warnings.js": 9058, + "5136-events-error-monitor-string-name.ts": 3057, + "5137-events-error-monitor-computed-name.js": 4052, + "5138-events-error-monitor-shared-listener.ts": 2466, + "5139-event-target-listener-throw.ts": 2925, + "514-array-find-some-every.ts": 3925, + "5140-os-host-facts.ts": 3438, + "5141-os-constants.ts": 2815, + "5142-path-parse-format.ts": 3808, + "5145-path-matches-glob-basics.ts": 3287, + "5146-path-matches-glob-braces.ts": 4987, + "5147-path-matches-glob-extglob.ts": 3938, + "5148-path-matches-glob-classes.ts": 3973, + "5149-path-matches-glob-win32.ts": 3835, + "515-array-flatmap.ts": 3688, + "5150-small-array-inline-slots.ts": 4419, + "5155-cycle-header-types.ts": 38708, + "516-array-reduce.ts": 4017, + "5160-field-callback-receiver.ts": 3678, + "5161-field-callback-receiver-escape.ts": 2857, + "5162-field-method-reference-receiver.ts": 2944, + "5163-field-callback-receiver.cjs": 3655, + "5164-worker-field-callback-receiver.ts": 30046, + "5165-interface-method-dispatch.ts": 2969, + "5166-interface-method-values.ts": 4129, + "5167-interface-method-order.ts": 3988, + "5168-interface-method-hierarchy.ts": 4483, + "5169-interface-method-chains.ts": 3336, + "517-array-hof-index-args.ts": 3024, + "5170-string-scan-eviction.ts": 3285, + "5171-lone-surrogate-replace-seams.ts": 3558, + "5175-forin-typed-as-unknown.ts": 4230, + "5176-object-keys-typed-as-unknown.ts": 3721, + "5177-forin-dynamic-objects.ts": 2893, + "5178-forin-keys-js.js": 2555, + "5179-forin-typed-shapes.ts": 4446, + "518-array-sort.ts": 3134, + "518-promise-void-union-callbacks.ts": 2401, + "5180-interface-arrays.ts": 3230, + "5181-interface-array-methods.ts": 11973, + "5182-interface-array-boundaries.ts": 3847, + "5183-interface-property-reads.ts": 3799, + "5184-interface-property-objects.ts": 3828, + "5185-util-inherits.cjs": 5041, + "5186-util-inherits.ts": 4542, + "5187-util-deprecate.cjs": 5818, + "5188-util-deprecate-flags.cjs": 4078, + "5189-util-deprecate.ts": 3798, + "519-array-from-length.ts": 2988, + "519-promise-union-await-values.ts": 3664, + "5190-util-callbackify.cjs": 5115, + "5191-util-callbackify.ts": 4367, + "5192-util-debuglog.cjs": 5096, + "5193-util-debuglog.ts": 4056, + "5194-process-emit-warning-tick.cjs": 2761, + "5195-object-entries-typed-as-unknown.ts": 3177, + "5196-object-values-typed-as-unknown.ts": 4077, + "5197-object-entries-dynamic-objects.ts": 4742, + "5198-object-entries-values-js.js": 3089, + "5199-object-entries-identity.ts": 3679, + "520-map-basics.ts": 3767, + "5200-array-sort-keyed-numbers.ts": 4618, + "5201-array-sort-keyed-records.ts": 5422, + "5202-array-sort-keyed-lookalikes.ts": 4034, + "5203-typed-array-sort-default.ts": 7941, + "5204-typed-array-sort-comparators.ts": 4085, + "521-map-number-keys.ts": 3317, + "5210-process-memory-usage.ts": 3262, + "5211-process-identity.ts": 3448, + "5212-perf-marks-measures.ts": 4026, + "5213-perf-timing-errors.ts": 4151, + "5214-perf-entry-inspect.ts": 4315, + "5215-perf-timing-validation.js": 2982, + "5216-perf-spread-arguments.js": 3745, + "5217-perf-spread-typed.ts": 4057, + "522-map-foreach.ts": 2964, + "5220-url-parse-warnings.ts": 4859, + "5221-url-parse-shapes.ts": 3814, + "5222-url-parse-hosts.ts": 3398, + "5223-url-parse-query.ts": 2653, + "5224-url-format-objects.ts": 5550, + "5225-url-format-whatwg.ts": 5213, + "5226-url-resolve.ts": 2600, + "5227-url-legacy-dependency/main.ts": 5803, + "5228-url-domain-conversion.ts": 4876, + "5229-url-legacy-errors.cjs": 5195, + "523-map-ref-values.ts": 4321, + "5230-inline-union-fields.ts": 3644, + "5231-inline-union-field-kinds.ts": 4871, + "5232-inline-union-fields-dynamic.ts": 3887, + "5233-inline-union-fields-shapes.ts": 4145, + "5234-inline-union-class-fields.ts": 3244, + "5235-inline-union-fields-publish.ts": 3360, + "5236-inline-union-unchecked-reads.ts": 3108, + "5237-inline-union-frame-objects.ts": 2533, + "524-map-cycles.ts": 3943, + "5240-event-target-subclass.ts": 5571, + "5241-event-subclass.ts": 4311, + "5242-event-target-subclass-hierarchy.ts": 4079, + "5243-event-target-subclass-dynamic.ts": 3528, + "5244-event-target-subclass.js": 4645, + "5245-event-target-subclass-signals.ts": 9410, + "5246-event-target-subclass-listener-throw.ts": 3995, + "5247-event-target-subclass-lifetimes.ts": 5991, + "5248-event-target-subclass-warnings.ts": 4513, + "5249-event-target-subclass-unconstructed.ts": 2679, + "525-map-rc-stress.ts": 2764, "5250-cipher-aes-gcm.ts": 8740, "5251-cipher-aes-cbc.ts": 42449, "5252-cipher-aes-ctr.ts": 26060, @@ -4723,45 +4732,45 @@ "5257-cipher-vectors.ts": 7138, "5258-cipher-handles.js": 24870, "5259-cipher-chunked.ts": 7052, - "526-set-basics.ts": 3756, - "5260-record-unknown-identity.ts": 4341, - "5261-optional-field-identity.ts": 3817, - "5262-record-unknown-many.ts": 3331, - "527-set-foreach.ts": 4129, - "5270-url-parse-no-deprecation.cjs": 5103, - "5271-url-parse-throw-deprecation.cjs": 6761, - "5275-http-end-callback-order.ts": 4622, - "5276-style-text-hex-colors.cjs": 4317, - "5277-fs-read-file-buffer-option.cjs": 3338, - "5278-host-null-bytes.cjs": 64320, - "5279-search-params-null-init.cjs": 2979, - "528-set-seeded.ts": 2529, - "5285-blob-construct.ts": 4818, - "5286-blob-readers.ts": 3080, - "5287-blob-inspect.ts": 3383, - "5288-blob-validation.js": 4818, - "5289-blob-read-order.ts": 4674, - "529-map-seeded.ts": 3233, - "5290-blob-dynamic.js": 4041, - "5295-readline-promises-question.ts": 3501, - "5296-readline-lines.ts": 5784, - "5297-readline-callback-events.cjs": 3985, - "5298-readline-abort.cjs": 10936, - "5299-readline-stdin.ts": 5881, - "530-record-arrays.ts": 4186, - "5300-stream-add-abort-signal.ts": 25846, - "5301-stream-add-abort-signal-errors.cjs": 8721, - "5302-stream-promises-options.ts": 13350, - "5303-stream-finished-callback-opts.cjs": 5087, - "5305-json-stringify-typed-arrays.ts": 6867, - "531-record-array-hofs.ts": 4059, - "5315-map-iterate-after-front-deletes.ts": 3530, - "5316-map-lru-eviction.ts": 3884, - "5317-map-iterate-while-mutating.ts": 4053, - "5318-set-iterate-after-deletes.ts": 4066, - "5319-map-iteration-values.ts": 4477, - "532-record-arrays-rc-stress.ts": 3905, - "5320-map-iterate-across-compaction.ts": 4243, + "526-set-basics.ts": 2480, + "5260-record-unknown-identity.ts": 3505, + "5261-optional-field-identity.ts": 3914, + "5262-record-unknown-many.ts": 3839, + "527-set-foreach.ts": 3683, + "5270-url-parse-no-deprecation.cjs": 4076, + "5271-url-parse-throw-deprecation.cjs": 3487, + "5275-http-end-callback-order.ts": 3028, + "5276-style-text-hex-colors.cjs": 4502, + "5277-fs-read-file-buffer-option.cjs": 2635, + "5278-host-null-bytes.cjs": 16385, + "5279-search-params-null-init.cjs": 2915, + "528-set-seeded.ts": 3643, + "5285-blob-construct.ts": 3124, + "5286-blob-readers.ts": 3309, + "5287-blob-inspect.ts": 2504, + "5288-blob-validation.js": 3775, + "5289-blob-read-order.ts": 3614, + "529-map-seeded.ts": 3331, + "5290-blob-dynamic.js": 2674, + "5295-readline-promises-question.ts": 2401, + "5296-readline-lines.ts": 3088, + "5297-readline-callback-events.cjs": 2975, + "5298-readline-abort.cjs": 6980, + "5299-readline-stdin.ts": 3836, + "530-record-arrays.ts": 3125, + "5300-stream-add-abort-signal.ts": 7154, + "5301-stream-add-abort-signal-errors.cjs": 7763, + "5302-stream-promises-options.ts": 8927, + "5303-stream-finished-callback-opts.cjs": 7119, + "5305-json-stringify-typed-arrays.ts": 4254, + "531-record-array-hofs.ts": 3609, + "5315-map-iterate-after-front-deletes.ts": 2759, + "5316-map-lru-eviction.ts": 3688, + "5317-map-iterate-while-mutating.ts": 3035, + "5318-set-iterate-after-deletes.ts": 2543, + "5319-map-iteration-values.ts": 4062, + "532-record-arrays-rc-stress.ts": 2708, + "5320-map-iterate-across-compaction.ts": 2736, "5321-integer-closed-arithmetic-loops.ts": 3710, "5321-json-parse-cycles.ts": 3383, "5322-integer-variable-step-loops.ts": 3384, @@ -4770,29 +4779,29 @@ "5323-int32-nonnegative-slot-facts.ts": 3774, "5324-int32-initializer-locals.ts": 2663, "5324-structured-clone-documents.ts": 4264, - "5325-record-boundary-returns.ts": 4089, - "5326-record-boundary-params.ts": 3793, - "5327-record-boundary-identity.ts": 3464, - "5328-record-boundary-open.ts": 4146, - "5329-record-boundary-recursion.ts": 3748, - "533-array-element-cycles.ts": 3379, - "5330-record-boundary-fields.ts": 2753, - "5331-record-boundary-methods.ts": 3914, + "5325-record-boundary-returns.ts": 3046, + "5326-record-boundary-params.ts": 2989, + "5327-record-boundary-identity.ts": 3529, + "5328-record-boundary-open.ts": 3718, + "5329-record-boundary-recursion.ts": 3361, + "533-array-element-cycles.ts": 3118, + "5330-record-boundary-fields.ts": 3048, + "5331-record-boundary-methods.ts": 2560, "5332-int32-narrowed-slot-facts.ts": 3588, "5333-integer-guarded-while-counters.ts": 3896, - "5333-record-boundary-nullable-argument.ts": 3869, - "5334-fetch-mentions-without-calls.ts": 3676, + "5333-record-boundary-nullable-argument.ts": 3100, + "5334-fetch-mentions-without-calls.ts": 4032, "5335-stream-operators-values.ts": 6378, - "5335-top-level-await-pending-exit-code.ts": 3377, + "5335-top-level-await-pending-exit-code.ts": 2383, "5336-stream-operators-promise-timing.ts": 4282, - "5336-top-level-await-pending-exit-listener.ts": 3680, - "5337-dc-subscriber-throw-next-tick.cjs": 3947, + "5336-top-level-await-pending-exit-listener.ts": 2814, + "5337-dc-subscriber-throw-next-tick.cjs": 3273, "5337-stream-operators-concurrency.ts": 8858, - "5338-js-tdz-function-element.js": 3181, + "5338-js-tdz-function-element.js": 3733, "5338-stream-operators-checks.cjs": 5284, - "5339-array-buffer-constructor.js": 4102, + "5339-array-buffer-constructor.js": 2884, "5339-stream-for-await-hops.ts": 5704, - "534-record-width-subtyping.ts": 3856, + "534-record-width-subtyping.ts": 3530, "5340-readable-from-options.ts": 4031, "5341-compound-any-operand.ts": 3905, "5341-generator-callback-params.ts": 4564, @@ -4808,28 +4817,28 @@ "5343-stream-compose-edges.ts": 10326, "5344-json-parse-undeclared-keys.ts": 5823, "5344-stream-pipeline-timing.ts": 4092, - "5345-object-values-for-of-unknown.ts": 4269, - "5346-object-values-length-dynamic.ts": 3585, - "5347-object-values-loop-control.ts": 4004, - "5348-object-values-for-of-js.js": 4048, - "5349-object-entries-values-optional.ts": 3374, - "535-object-statics.ts": 4653, - "5350-object-values-wide-record.ts": 3999, - "5351-object-values-methods-index.ts": 3750, + "5345-object-values-for-of-unknown.ts": 4013, + "5346-object-values-length-dynamic.ts": 3930, + "5347-object-values-loop-control.ts": 3598, + "5348-object-values-for-of-js.js": 2760, + "5349-object-entries-values-optional.ts": 3370, + "535-object-statics.ts": 2862, + "5350-object-values-wide-record.ts": 3272, + "5351-object-values-methods-index.ts": 3637, "5352-final-field-loop-reads.ts": 4118, "5353-captured-const-values.ts": 3887, "5354-captured-const-tdz.ts": 3465, "5355-captured-function-declarations.ts": 4030, "5356-captured-tdz-ordering.ts": 4031, "5357-init-only-module-bindings.ts": 3717, - "536-map-seed-array.ts": 3444, - "5360-array-sort-comparator-calls.ts": 3618, - "5361-array-sort-inconsistent-comparators.ts": 4844, - "5362-array-sort-comparator-throws.ts": 4204, - "5363-array-sort-comparator-writes.ts": 13543, - "5364-array-sort-union-and-boolean-elements.ts": 21219, - "5365-array-sort-dynamic-values.js": 3456, - "537-map-iter-drains.ts": 3991, + "536-map-seed-array.ts": 3237, + "5360-array-sort-comparator-calls.ts": 4265, + "5361-array-sort-inconsistent-comparators.ts": 4181, + "5362-array-sort-comparator-throws.ts": 2826, + "5363-array-sort-comparator-writes.ts": 10362, + "5364-array-sort-union-and-boolean-elements.ts": 14300, + "5365-array-sort-dynamic-values.js": 2919, + "537-map-iter-drains.ts": 3050, "5370-zlib-stream-roundtrip.ts": 4546, "5371-zlib-stream-chunking.cjs": 6071, "5372-zlib-stream-errors.cjs": 6496, @@ -4840,29 +4849,29 @@ "5377-zlib-stream-backpressure.cjs": 4992, "5378-zlib-sync-options.cjs": 4120, "5379-zlib-callback-options.ts": 4524, - "538-map-set-for-of.ts": 3571, - "5390-interface-loop-element-lifetimes.ts": 3555, - "5391-interface-dispatch-hierarchies.ts": 5018, - "5392-interface-receiver-bindings.ts": 2922, - "5393-interface-array-holes.ts": 4247, - "5394-interface-implementers.ts": 4974, - "5395-locale-compare-ascii.ts": 3055, - "5396-locale-compare-latin.ts": 5056, - "5397-locale-compare-sorting.ts": 5049, - "540-tuples-basics.ts": 4222, - "5400-json-parse-typed-keys.ts": 5019, - "5405-buffer-arraybuffer-window.ts": 3206, - "5406-util-types-keys.ts": 3783, - "5407-http-header-field-limit.ts": 3678, - "5408-http-unread-request-end.ts": 4813, - "5409-http-held-request-body.ts": 4829, - "541-ref-array-json.ts": 4046, - "5410-inspect-class-values.ts": 3502, - "5411-inspect-class-hierarchies.ts": 3285, - "5412-inspect-dynamic-collections.ts": 3541, - "5413-inspect-class-values.cjs": 4035, + "538-map-set-for-of.ts": 3029, + "5390-interface-loop-element-lifetimes.ts": 3566, + "5391-interface-dispatch-hierarchies.ts": 3731, + "5392-interface-receiver-bindings.ts": 3061, + "5393-interface-array-holes.ts": 2702, + "5394-interface-implementers.ts": 3603, + "5395-locale-compare-ascii.ts": 3587, + "5396-locale-compare-latin.ts": 4291, + "5397-locale-compare-sorting.ts": 3576, + "540-tuples-basics.ts": 3420, + "5400-json-parse-typed-keys.ts": 3141, + "5405-buffer-arraybuffer-window.ts": 3036, + "5406-util-types-keys.ts": 2954, + "5407-http-header-field-limit.ts": 3052, + "5408-http-unread-request-end.ts": 3992, + "5409-http-held-request-body.ts": 3771, + "541-ref-array-json.ts": 3761, + "5410-inspect-class-values.ts": 3124, + "5411-inspect-class-hierarchies.ts": 2423, + "5412-inspect-dynamic-collections.ts": 3042, + "5413-inspect-class-values.cjs": 3217, "5415-zlib-dynamic-inputs.cjs": 4054, - "542-union-element-arrays.ts": 4182, + "542-union-element-arrays.ts": 2812, "5420-readable-from-generators.ts": 5843, "5421-readable-from-generators.cjs": 3752, "5422-stream-async-push-wakeup.ts": 3679, @@ -4873,43 +4882,43 @@ "5427-pipeline-generator-backpressure.ts": 4175, "5428-pipeline-generator-stages.cjs": 9702, "5429-pipeline-generator-buffers.ts": 6406, - "5430-dyn-number-string-boxes.ts": 3692, - "5435-crypto-hash-algorithms.ts": 4078, - "5436-crypto-hash-names.js": 3345, - "5437-crypto-hmac-algorithms.ts": 3794, - "5438-crypto-kdf-digests.ts": 3694, - "5439-crypto-kdf-callbacks.js": 3780, - "5440-crypto-hash-encodings.js": 4405, - "5441-crypto-hash-output-length.ts": 4754, - "5442-crypto-random-values.ts": 5239, - "5443-crypto-random-arguments.js": 4330, - "5444-crypto-timing-safe-equal.js": 2751, - "5445-crypto-secret-key-objects.ts": 4863, - "5445-stream-buffer-chunks.ts": 4296, - "5446-crypto-secret-key-errors.js": 4577, - "5446-stream-buffer-chunks-dynamic.js": 8609, - "5447-fs-readdir-order.ts": 3829, - "5448-fs-glob-patterns.ts": 3945, - "5449-fs-glob-options.ts": 5046, - "5450-fs-glob-validation.js": 3911, - "5451-fs-promises-glob.ts": 5150, - "5452-fs-glob-callback.ts": 4895, - "5455-power-of-two-remainder.ts": 3875, - "5456-remainder-large-integer-dividends.ts": 3066, - "5457-lcg-modulus.ts": 3468, - "5458-fractional-remainder.ts": 3767, - "5460-locale-compare-contractions.ts": 3556, - "5461-locale-compare-equivalents.ts": 4015, - "5462-locale-compare-probe-sweep.ts": 5293, - "5463-locale-compare-combining-letters.ts": 4084, - "5464-locale-compare-fractions.ts": 3409, + "5430-dyn-number-string-boxes.ts": 3930, + "5435-crypto-hash-algorithms.ts": 3451, + "5436-crypto-hash-names.js": 3185, + "5437-crypto-hmac-algorithms.ts": 3269, + "5438-crypto-kdf-digests.ts": 3099, + "5439-crypto-kdf-callbacks.js": 4398, + "5440-crypto-hash-encodings.js": 4908, + "5441-crypto-hash-output-length.ts": 3959, + "5442-crypto-random-values.ts": 4791, + "5443-crypto-random-arguments.js": 3724, + "5444-crypto-timing-safe-equal.js": 4074, + "5445-crypto-secret-key-objects.ts": 4784, + "5445-stream-buffer-chunks.ts": 5661, + "5446-crypto-secret-key-errors.js": 3275, + "5446-stream-buffer-chunks-dynamic.js": 5780, + "5447-fs-readdir-order.ts": 3355, + "5448-fs-glob-patterns.ts": 3298, + "5449-fs-glob-options.ts": 3827, + "5450-fs-glob-validation.js": 4321, + "5451-fs-promises-glob.ts": 3074, + "5452-fs-glob-callback.ts": 3887, + "5455-power-of-two-remainder.ts": 4228, + "5456-remainder-large-integer-dividends.ts": 3551, + "5457-lcg-modulus.ts": 2909, + "5458-fractional-remainder.ts": 2650, + "5460-locale-compare-contractions.ts": 3201, + "5461-locale-compare-equivalents.ts": 3410, + "5462-locale-compare-probe-sweep.ts": 4164, + "5463-locale-compare-combining-letters.ts": 3755, + "5464-locale-compare-fractions.ts": 3312, "5465-dyn-index-read-arrays.ts": 3798, "5466-dyn-index-read-special.ts": 4384, - "5470-strip-vt-osc.cjs": 3494, - "5471-strip-vt-csi.cjs": 3770, - "5472-strip-vt-random.cjs": 3968, - "5473-strip-vt-unterminated.cjs": 4621, - "5474-strip-vt-surrogates.ts": 3567, + "5470-strip-vt-osc.cjs": 2708, + "5471-strip-vt-csi.cjs": 3038, + "5472-strip-vt-random.cjs": 2850, + "5473-strip-vt-unterminated.cjs": 4462, + "5474-strip-vt-surrogates.ts": 3554, "5510-assert-error-properties.js": 5349, "5511-assert-error-class.ts": 4329, "5512-assert-error-options.js": 3469, @@ -4930,20 +4939,20 @@ "5530-buffer-pool.ts": 4413, "5531-buffer-pool-first-slab.ts": 5557, "5532-buffer-pool-first-slab-untyped.mjs": 220640, - "5540-fs-callback-forms.cjs": 4591, - "5541-fs-stats-fields.cjs": 6904, - "5542-fs-promises-parity.cjs": 4673, - "5543-fs-promises-typed.ts": 5025, - "5544-fs-opendir.cjs": 4673, - "5545-fs-options-encoding.cjs": 5256, + "5540-fs-callback-forms.cjs": 3079, + "5541-fs-stats-fields.cjs": 4039, + "5542-fs-promises-parity.cjs": 3312, + "5543-fs-promises-typed.ts": 2944, + "5544-fs-opendir.cjs": 3622, + "5545-fs-options-encoding.cjs": 3497, "5546-fs-read-stream.cjs": 5295, "5547-fs-write-stream.cjs": 6075, - "5548-fs-callback-arguments.cjs": 4982, - "5549-fs-callback-option-checks.cjs": 4309, - "5550-locale-compare-ascii-words.ts": 3614, - "5551-array-search-references.ts": 4656, - "5552-string-appends.ts": 3810, - "5553-string-append-char-code.ts": 4013, + "5548-fs-callback-arguments.cjs": 3905, + "5549-fs-callback-option-checks.cjs": 3471, + "5550-locale-compare-ascii-words.ts": 2824, + "5551-array-search-references.ts": 3964, + "5552-string-appends.ts": 3653, + "5553-string-append-char-code.ts": 3292, "5554-fs-streams-typed.ts": 4873, "5555-fs-callback-turns.cjs": 3708, "5555-http-server-close-keep-alive.ts": 15618, @@ -4956,15 +4965,15 @@ "5562-https-verify-errors.ts": 4777, "5563-http-keep-alive-timeout.ts": 17783, "5564-http-request-signal.ts": 10735, - "5565-fs-dirent-untyped.mjs": 4337, - "5566-fs-dirent-dyn-boundaries/main.mjs": 4371, + "5565-fs-dirent-untyped.mjs": 2898, + "5566-fs-dirent-dyn-boundaries/main.mjs": 3333, "5567-fs-cpsync.ts": 4945, "5568-fs-cp-errors.js": 4099, "5569-fs-cp-symlinks.ts": 3686, "5570-fs-cp-async.ts": 4176, "5571-fs-cp-deep.ts": 5306, - "5585-record-results-inlined.ts": 3957, - "5595-net-ref-unref.ts": 5321, + "5585-record-results-inlined.ts": 3681, + "5595-net-ref-unref.ts": 3036, "5600-dyn-cycle-self.ts": 3365, "5601-dyn-cycle-mutual.ts": 4239, "5602-dyn-cycle-arrays.ts": 3453, @@ -4989,19 +4998,19 @@ "5624-timers-promises-unawaited.ts": 4420, "5625-promisify-exec.ts": 8488, "5626-promisify-forms.ts": 3100, - "5627-exec-callback.ts": 3311, + "5627-exec-callback.ts": 2500, "5628-promisify-timers.ts": 3913, "5629-promisify-stream.ts": 3357, "5630-promisify-zlib.ts": 3392, - "5631-promisify-crypto.ts": 3727, - "5632-promisify-dns.ts": 5476, - "5644-net-socket-addresses.ts": 3677, - "5645-net-socket-callbacks.ts": 4544, - "5646-net-server-connections.ts": 3663, - "5647-net-is-ip.ts": 3569, - "5648-dns-lookup-forms.ts": 5746, - "5649-dns-service-servers.ts": 4846, - "5650-dns-lookup-errors-untyped.cjs": 4466, + "5631-promisify-crypto.ts": 2600, + "5632-promisify-dns.ts": 2000, + "5644-net-socket-addresses.ts": 2393, + "5645-net-socket-callbacks.ts": 2060, + "5646-net-server-connections.ts": 2755, + "5647-net-is-ip.ts": 2560, + "5648-dns-lookup-forms.ts": 3416, + "5649-dns-service-servers.ts": 4916, + "5650-dns-lookup-errors-untyped.cjs": 3889, "5651-tls-socket-protocol.ts": 30873, "5652-http-client-trailer-overflow.ts": 3512, "5653-net-socket-read-ahead.ts": 6212, @@ -5014,7 +5023,7 @@ "5664-tls-client-identity.ts": 6340, "5674-union-instanceof-array-arms.ts": 3943, "5680-array-growth-after-copy.ts": 4581, - "5681-array-pop-and-length.ts": 4279, + "5681-array-pop-and-length.ts": 3216, "5682-publish-wide-objects.ts": 3376, "5700-cycle-release-retained.ts": 3414, "5701-cycle-release-old-edges.ts": 4210, @@ -5079,39 +5088,39 @@ "5795-worker-message-port-batches.ts": 2995, "5796-worker-message-channel.cjs": 3812, "5797-worker-message-port-transfer.ts": 3633, - "5800-broadcast-channel.ts": 40203, - "5801-broadcast-channel.cjs": 5126, - "5802-broadcast-channel-workers.ts": 4593, - "5803-worker-environment-data.ts": 5183, - "5804-worker-environment-data.cjs": 3173, - "5805-worker-receive-message-parent-port.ts": 2696, - "5806-worker-resource-limits.ts": 3922, - "5807-worker-error-values.ts": 6807, - "5808-worker-unhandled-rejections.ts": 7138, - "5809-process-exit-and-rejections.cjs": 33202, - "5810-mock-method-records.ts": 6251, - "5811-mock-tracker-restore.ts": 6093, - "5812-dyn-box-async-fields.ts": 3948, - "5813-mock-timers-module.ts": 5361, - "5814-mock-timers-date.ts": 7472, + "5800-broadcast-channel.ts": 28374, + "5801-broadcast-channel.cjs": 27251, + "5802-broadcast-channel-workers.ts": 27251, + "5803-worker-environment-data.ts": 29298, + "5804-worker-environment-data.cjs": 26404, + "5805-worker-receive-message-parent-port.ts": 30268, + "5806-worker-resource-limits.ts": 29711, + "5807-worker-error-values.ts": 35248, + "5808-worker-unhandled-rejections.ts": 33209, + "5809-process-exit-and-rejections.cjs": 30261, + "5810-mock-method-records.ts": 6363, + "5811-mock-tracker-restore.ts": 4503, + "5812-dyn-box-async-fields.ts": 5278, + "5813-mock-timers-module.ts": 4227, + "5814-mock-timers-date.ts": 17708, "5830-timers-promises-signal.ts": 4170, - "5831-util-types-brands.ts": 3902, - "5832-util-types-brands-dynamic.js": 4287, - "5833-url-search-params-iterators.ts": 3492, - "5834-url-search-params-iterators-dynamic.mjs": 3994, - "5835-util-format-integer-specifiers.ts": 3659, - "5836-url-search-params-tuple-pairs.ts": 3814, - "5837-util-format-json-circular.ts": 4225, - "5838-qs-stringify-bigint.ts": 5010, + "5831-util-types-brands.ts": 4380, + "5832-util-types-brands-dynamic.js": 3658, + "5833-url-search-params-iterators.ts": 5339, + "5834-url-search-params-iterators-dynamic.mjs": 3797, + "5835-util-format-integer-specifiers.ts": 2768, + "5836-url-search-params-tuple-pairs.ts": 3193, + "5837-util-format-json-circular.ts": 3408, + "5838-qs-stringify-bigint.ts": 3519, "5839-timers-promises-scheduler.ts": 3897, "5840-promise-with-resolvers-js.js": 3596, - "5841-json-typed-dyn-members.ts": 5082, - "5842-qs-parse-null-prototype.ts": 3325, - "5843-qs-parse-null-prototype-js.mjs": 3033, - "5844-date-unknown-values.ts": 4145, + "5841-json-typed-dyn-members.ts": 3238, + "5842-qs-parse-null-prototype.ts": 7077, + "5843-qs-parse-null-prototype-js.mjs": 5395, + "5844-date-unknown-values.ts": 4543, "5845-groupby-null-prototype.ts": 4290, - "5846-events-esm-default-max.ts": 2759, - "5847-events-cjs-default-max.cjs": 3509, + "5846-events-esm-default-max.ts": 3102, + "5847-events-cjs-default-max.cjs": 3039, "5849-class-view-observations.ts": 4659, "5850-using-disposable-values.ts": 3072, "5851-using-suppressed-error-values.ts": 3950, @@ -5120,46 +5129,46 @@ "5854-array-from-async.ts": 5635, "5855-array-from-async-js.js": 3433, "5856-error-is-error.ts": 3928, - "5857-regexp-unicode-sets.ts": 3859, - "5858-disposable-stack.ts": 5135, - "5859-disposable-stack-js.js": 3801, + "5857-regexp-unicode-sets.ts": 3900, + "5858-disposable-stack.ts": 3750, + "5859-disposable-stack-js.js": 3600, "5860-url-ipv4-hosts.ts": 4018, - "5870-worker-thread-names.ts": 7328, - "5871-worker-untransferable.cjs": 43661, + "5870-worker-thread-names.ts": 31697, + "5871-worker-untransferable.cjs": 27481, "5872-readline-positional-create-interface.mjs": 6166, "5873-readline-promises-namespace.cjs": 3811, - "5874-worker-stdio-streams.ts": 50741, - "5875-worker-stdout-pipe.cjs": 50279, - "5879-worker-stdin.ts": 57033, + "5874-worker-stdio-streams.ts": 27801, + "5875-worker-stdout-pipe.cjs": 31391, + "5879-worker-stdin.ts": 33232, "5880-emitter-leak-warning-delivery.ts": 4319, - "5881-inspect-weak-collections.ts": 3631, - "5882-string-decoder-runtime-encoding.ts": 3362, - "5883-os-set-priority.ts": 3308, - "5884-inspect-layout-options.ts": 4849, + "5881-inspect-weak-collections.ts": 2915, + "5882-string-decoder-runtime-encoding.ts": 3854, + "5883-os-set-priority.ts": 3417, + "5884-inspect-layout-options.ts": 3596, "5885-events-max-listener-helpers.ts": 3588, - "5886-inspect-dates.ts": 2966, - "5887-inspect-typed-arrays.ts": 3325, - "5888-inspect-sorted.ts": 3559, + "5886-inspect-dates.ts": 2736, + "5887-inspect-typed-arrays.ts": 2997, + "5888-inspect-sorted.ts": 2861, "5889-timers-scheduler-signal.ts": 8928, "5890-while-string-length-counters.ts": 3822, "5892-buffer-write-utf16le-runs.ts": 3465, - "5900-float16-array.ts": 3954, - "5901-float16-array-js.js": 3925, - "5904-async-generator-completion.ts": 6639, - "5905-array-from-async-generator.ts": 4467, - "5906-array-from-async-generator-js.js": 4458, - "5907-regex-groups-match-rows.ts": 4698, - "5910-set-prototype-of-primitive-object-kinds.ts": 4445, - "5911-dyn-class-to-primitive.ts": 5410, - "5912-dyn-class-conversion-methods.ts": 4298, - "5913-prototype-type-error-messages.ts": 3454, - "5914-dyn-in-class-prototype-members.ts": 3792, - "5915-dyn-error-string-conversions.ts": 3851, + "5900-float16-array.ts": 3750, + "5901-float16-array-js.js": 3700, + "5904-async-generator-completion.ts": 3800, + "5905-array-from-async-generator.ts": 3500, + "5906-array-from-async-generator-js.js": 3750, + "5907-regex-groups-match-rows.ts": 3750, + "5910-set-prototype-of-primitive-object-kinds.ts": 5033, + "5911-dyn-class-to-primitive.ts": 4732, + "5912-dyn-class-conversion-methods.ts": 4424, + "5913-prototype-type-error-messages.ts": 4068, + "5914-dyn-in-class-prototype-members.ts": 4327, + "5915-dyn-error-string-conversions.ts": 4247, "5919-record-unions-shared-arms.ts": 4941, "5920-promise-try-args.ts": 3195, "5921-promise-try-args-js.js": 3082, - "5922-matchall-groups-callbacks.ts": 5275, - "5923-matchall-groups-js.js": 4883, + "5922-matchall-groups-callbacks.ts": 5960, + "5923-matchall-groups-js.js": 6650, "5924-js-literal-identity.js": 3065, "5925-class-view-identity-observers.ts": 2685, "5926-class-view-switch-js.js": 3057, @@ -5180,862 +5189,871 @@ "5935-js-subclass-fields-and-element-calls.js": 4470, "5936-checked-js-class-types.js": 4183, "5937-override-narrowed-union-returns.ts": 3827, - "5938-object-literal-computed-keys-keep-methods.ts": 4019, - "5939-js-let-object-reassigned-wider.js": 4037, + "5938-object-literal-computed-keys-keep-methods.ts": 7194, + "5939-js-let-object-reassigned-wider.js": 4436, "5940-callback-helper-specialization.ts": 4548, "5941-callback-specialization-recursion.ts": 4448, "5942-callback-specialization-throws.ts": 3443, - "5943-fields-read-before-assignment.ts": 4319, - "5944-js-fields-read-before-assignment.js": 3945, - "5945-local-class-observed-methods.ts": 4458, - "5946-nested-record-field-optional-writes.ts": 3537, - "5950-tuple-predicate-methods.ts": 4018, - "5951-result-never-widening.ts": 3970, - "5952-record-missing-keys.ts": 5020, - "5953-nan-coded-method-returns.ts": 2689, - "5955-any-promise-methods.js": 3182, - "5956-erased-generic-members.ts": 5824, - "5958-asserted-union-receiver.ts": 3206, - "5959-date-to-json.ts": 3819, + "5943-fields-read-before-assignment.ts": 72293, + "5944-js-fields-read-before-assignment.js": 40310, + "5945-local-class-observed-methods.ts": 6212, + "5946-nested-record-field-optional-writes.ts": 68117, + "5950-tuple-predicate-methods.ts": 7790, + "5951-result-never-widening.ts": 6120, + "5952-record-missing-keys.ts": 20400, + "5953-nan-coded-method-returns.ts": 15600, + "5955-any-promise-methods.js": 5120, + "5956-erased-generic-members.ts": 8750, + "5958-asserted-union-receiver.ts": 3160, + "5959-date-to-json.ts": 4330, "5960-frame-records-own-references.ts": 3535, - "5960-generic-mapped-types.ts": 3052, + "5960-generic-mapped-types.ts": 3300, "5961-frame-spread-updates.ts": 3732, "5962-frame-tuples.ts": 3372, - "5970-net-connect-host-name.ts": 3461, - "5971-buffer-chunks-to-string.ts": 4886, - "5972-net-set-encoding-listeners.ts": 4672, + "5970-net-connect-host-name.ts": 2800, + "5971-buffer-chunks-to-string.ts": 3100, + "5972-net-set-encoding-listeners.ts": 3000, "5973-large-closure-environment.ts": 5145, - "5974-typeof-module-exports.cjs": 3216, - "5975-zlib-class-values.ts": 4063, - "5990-worker-uncloneable.mjs": 4117, - "5991-worker-async-dispose.mjs": 40350, - "5992-worker-thread-name-lifetime.mjs": 47859, + "5974-typeof-module-exports.cjs": 2500, + "5975-zlib-class-values.ts": 4200, + "5990-worker-uncloneable.mjs": 22432, + "5991-worker-async-dispose.mjs": 25768, + "5992-worker-thread-name-lifetime.mjs": 28932, "5993-array-length-loop-resizing.ts": 4127, "5994-array-length-sparse-loops.ts": 2815, "5995-array-dense-loop-boundaries.ts": 4171, - "600-closures-basic.ts": 3688, - "601-closures-loops.ts": 2905, - "602-closures-identity-recursion.ts": 3340, - "6020-class-extends-function-constructor.js": 3739, - "6021-asserted-literal-union-arm.ts": 3498, - "603-closures-rc-stress.ts": 2788, - "604-closures-for-of.ts": 3472, + "5996-rejections-between-macrotasks.cjs": 22172, + "600-closures-basic.ts": 2534, + "601-closures-loops.ts": 2297, + "602-closures-identity-recursion.ts": 2427, + "6020-class-extends-function-constructor.js": 7500, + "6021-asserted-literal-union-arm.ts": 7200, + "603-closures-rc-stress.ts": 2589, + "604-closures-for-of.ts": 3514, "6041-error-cause-redeclared.ts": 4631, "6042-regex-match-object-destructuring.ts": 3091, "6043-string-index-narrowed-union.ts": 3627, - "605-closures-forward-capture-tdz.ts": 4043, + "605-closures-forward-capture-tdz.ts": 4638, "6140-cjs-require-tdz-throws/main.js": 2989, "6141-cjs-require-tdz-checked/main.js": 4062, "6142-cjs-require-published-early/main.js": 5156, "6143-cjs-require-json/main.js": 3050, "6144-cjs-require-builtin-nested/main.js": 3329, "6145-cjs-require-cycle/main.js": 4761, - "700-classes-basic.ts": 2717, - "701-classes-composition.ts": 3694, - "702-classes-this-capture.ts": 3151, - "703-classes-rc-stress.ts": 3285, - "710-inheritance-basics.ts": 2592, - "711-inheritance-dispatch.ts": 3301, - "712-inheritance-instanceof.ts": 3603, - "713-inheritance-rc-stress.ts": 2631, - "720-accessors-basics.ts": 2515, - "721-accessors-eval-order.ts": 3454, - "722-accessors-inheritance.ts": 3466, - "723-accessors-rc-stress.ts": 3570, - "750-cycle-closure-box.ts": 3720, - "751-cycle-records-mutual.ts": 2782, - "752-cycle-classes.ts": 3168, - "753-cycle-owned-arrays.ts": 3490, - "754-cycle-external-ref.ts": 3578, - "755-cycle-async-promise.ts": 3053, - "756-cycle-inheritance.ts": 2275, - "757-cycle-cross-generation.ts": 3630, - "762-any-boundary.ts": 3627, - "764-any-async.ts": 3271, - "765-any-optional-chain.ts": 2987, - "766-any-union-boundary.ts": 3659, - "767-string-literal-keys.ts": 3306, - "768-any-uninitialized.ts": 3041, - "800-switch-basics.ts": 3127, - "801-switch-lazy-tests.ts": 3237, - "802-switch-loops.ts": 3396, - "803-switch-rc-stress.ts": 3243, - "804-switch-braced-blocks.ts": 3060, - "810-do-while.ts": 3366, - "820-multi-decl.ts": 3412, - "830-let-uninitialized.ts": 2806, - "900-records-basics.ts": 2799, - "901-records-eval-order.ts": 3424, - "902-records-functions-closures.ts": 2868, - "903-records-rc-stress.ts": 3996, - "904-records-optional-fields.ts": 3692, - "905-records-optional-rc-stress.ts": 3288, - "906-records-utility-types.ts": 2706, - "907-records-utility-generics.ts": 2748, - "908-records-index-signatures.ts": 3143, - "909-records-index-json.ts": 3697, - "910-records-index-rc-stress.ts": 4050, - "911-records-index-dot-access.ts": 3683, - "912-unknown-slots.ts": 2923, - "913-records-index-iteration.ts": 4112, - "914-records-from-entries.ts": 3768, - "915-unknown-tostring-eq.ts": 3915, - "916-unknown-bytes.ts": 3466, - "917-record-array-index-dot.ts": 3287, - "950-modules-basic/main.ts": 3531, - "951-modules-diamond/main.ts": 3176, - "952-modules-cross/main.ts": 2507, - "953-modules-default/main.ts": 2473, - "954-modules-reexport/main.ts": 2897, - "957-builtins-namespace.ts": 3213, - "960-generics-basics.ts": 2743, - "961-generics-recursion.ts": 3759, - "962-generics-closures.ts": 3551, - "963-generics-modules/main.ts": 3745, - "964-generics-rc-stress.ts": 3697, - "965-generics-async.ts": 3911, - "965-unions-retag.ts": 2955, - "966-unions-retag-rc-stress.ts": 3416, - "967-record-field-widening.ts": 3252, - "969-unions-arm-matrix.ts": 3502, - "970-unions-basics.ts": 3588, - "971-unions-switch.ts": 3755, - "972-unions-nested.ts": 2659, - "973-unions-rc-stress.ts": 3021, - "974-unions-modules/main.ts": 3329, - "975-unions-undefined.ts": 3414, - "976-unions-null.ts": 3240, - "977-unions-unit-rc-stress.ts": 3807, - "978-unions-nullish.ts": 3471, - "979-unions-optional-chaining.ts": 2680, - "980-exceptions-basics.ts": 3823, - "981-exceptions-values.ts": 3366, - "982-exceptions-rc-stress.ts": 3526, - "983-exceptions-control-flow.ts": 3306, - "984-exceptions-finally.ts": 3693, - "985-exceptions-call-chains.ts": 3523, - "986-exceptions-uncaught.ts": 3377, - "987-exceptions-result-unions.ts": 3446, - "990-process-basics.ts": 3175, - "991-process-exit.ts": 3461, - "992-fs-roundtrip.ts": 3411, - "993-fs-readdir.ts": 3612, - "994-fs-errors.ts": 3748, - "995-fs-uncaught.ts": 3089, - "996-fs-rc-stress.ts": 3714, - "997-fs-modules/main.ts": 3327, - "998-process-env.ts": 2498, - "abstract-property-dispatch.ts": 4365, - "arguments-arrow-capture.mjs": 3544, - "arguments-reexport/main.ts": 3373, - "array-argument-lifetimes-exits.ts": 2870, - "array-argument-lifetimes-mutation.ts": 3721, - "array-argument-lifetimes-strings.ts": 3794, - "array-argument-lifetimes-values.ts": 4076, - "array-buffer-conversions.js": 3267, - "array-buffer-storage.ts": 3982, - "array-checked-callback-results.mjs": 3822, - "array-checked-constructor.js": 3361, - "array-concat-widening.ts": 3515, + "700-classes-basic.ts": 2674, + "701-classes-composition.ts": 2606, + "702-classes-this-capture.ts": 2403, + "703-classes-rc-stress.ts": 3477, + "710-inheritance-basics.ts": 2972, + "711-inheritance-dispatch.ts": 2507, + "712-inheritance-instanceof.ts": 2847, + "713-inheritance-rc-stress.ts": 3484, + "720-accessors-basics.ts": 3144, + "721-accessors-eval-order.ts": 3241, + "722-accessors-inheritance.ts": 3694, + "723-accessors-rc-stress.ts": 2838, + "750-cycle-closure-box.ts": 3262, + "751-cycle-records-mutual.ts": 3163, + "752-cycle-classes.ts": 2239, + "753-cycle-owned-arrays.ts": 2204, + "754-cycle-external-ref.ts": 2593, + "755-cycle-async-promise.ts": 3154, + "756-cycle-inheritance.ts": 2213, + "757-cycle-cross-generation.ts": 3118, + "762-any-boundary.ts": 3063, + "764-any-async.ts": 3129, + "765-any-optional-chain.ts": 3899, + "766-any-union-boundary.ts": 3346, + "767-string-literal-keys.ts": 2340, + "768-any-uninitialized.ts": 2983, + "800-switch-basics.ts": 3128, + "801-switch-lazy-tests.ts": 2842, + "802-switch-loops.ts": 3486, + "803-switch-rc-stress.ts": 2321, + "804-switch-braced-blocks.ts": 3234, + "810-do-while.ts": 3326, + "820-multi-decl.ts": 2338, + "830-let-uninitialized.ts": 2579, + "900-records-basics.ts": 3473, + "901-records-eval-order.ts": 2890, + "902-records-functions-closures.ts": 3085, + "903-records-rc-stress.ts": 3146, + "904-records-optional-fields.ts": 2930, + "905-records-optional-rc-stress.ts": 2986, + "906-records-utility-types.ts": 2822, + "907-records-utility-generics.ts": 3048, + "908-records-index-signatures.ts": 2695, + "909-records-index-json.ts": 3037, + "910-records-index-rc-stress.ts": 2958, + "911-records-index-dot-access.ts": 4686, + "912-unknown-slots.ts": 3359, + "913-records-index-iteration.ts": 3265, + "914-records-from-entries.ts": 3414, + "915-unknown-tostring-eq.ts": 3349, + "916-unknown-bytes.ts": 3729, + "917-record-array-index-dot.ts": 3331, + "950-modules-basic/main.ts": 2717, + "951-modules-diamond/main.ts": 2315, + "952-modules-cross/main.ts": 2751, + "953-modules-default/main.ts": 3300, + "954-modules-reexport/main.ts": 2770, + "957-builtins-namespace.ts": 2759, + "960-generics-basics.ts": 3631, + "961-generics-recursion.ts": 3262, + "962-generics-closures.ts": 2245, + "963-generics-modules/main.ts": 2769, + "964-generics-rc-stress.ts": 3123, + "965-generics-async.ts": 3925, + "965-unions-retag.ts": 3882, + "966-unions-retag-rc-stress.ts": 3167, + "967-record-field-widening.ts": 2827, + "969-unions-arm-matrix.ts": 3297, + "970-unions-basics.ts": 3439, + "971-unions-switch.ts": 3593, + "972-unions-nested.ts": 2812, + "973-unions-rc-stress.ts": 2567, + "974-unions-modules/main.ts": 2485, + "975-unions-undefined.ts": 2505, + "976-unions-null.ts": 3528, + "977-unions-unit-rc-stress.ts": 2503, + "978-unions-nullish.ts": 2591, + "979-unions-optional-chaining.ts": 2499, + "980-exceptions-basics.ts": 2297, + "981-exceptions-values.ts": 3503, + "982-exceptions-rc-stress.ts": 3146, + "983-exceptions-control-flow.ts": 2518, + "984-exceptions-finally.ts": 2504, + "985-exceptions-call-chains.ts": 3540, + "986-exceptions-uncaught.ts": 3473, + "987-exceptions-result-unions.ts": 3527, + "990-process-basics.ts": 3510, + "991-process-exit.ts": 2297, + "992-fs-roundtrip.ts": 2694, + "993-fs-readdir.ts": 3781, + "994-fs-errors.ts": 2370, + "995-fs-uncaught.ts": 2239, + "996-fs-rc-stress.ts": 2822, + "997-fs-modules/main.ts": 2578, + "998-process-env.ts": 2181, + "abstract-property-dispatch.ts": 2739, + "arguments-arrow-capture.mjs": 3039, + "arguments-reexport/main.ts": 2635, + "array-argument-lifetimes-exits.ts": 3136, + "array-argument-lifetimes-mutation.ts": 3333, + "array-argument-lifetimes-strings.ts": 3015, + "array-argument-lifetimes-values.ts": 3223, + "array-buffer-conversions.js": 2594, + "array-buffer-storage.ts": 3699, + "array-checked-callback-results.mjs": 3402, + "array-checked-constructor.js": 3477, + "array-concat-widening.ts": 3858, "array-deque-unshift.ts": 4273, - "array-element-compound-updates.ts": 5390, - "array-fill-unit-values.ts": 3744, - "array-from-checked.js": 4644, - "array-from-value.mjs": 3261, - "array-isarray-value/main.js": 3569, - "array-numeric-own-keys.ts": 3719, - "array-optional-number-write-index.ts": 3067, - "array-primitive-ordering.ts": 4670, + "array-element-compound-updates.ts": 3591, + "array-fill-unit-values.ts": 2572, + "array-from-checked.js": 3097, + "array-from-value.mjs": 3428, + "array-isarray-value/main.js": 3143, + "array-numeric-own-keys.ts": 3632, + "array-optional-number-write-index.ts": 3380, + "array-primitive-ordering.ts": 3925, "array-queue-head-room.ts": 5069, - "array-read-helper-effects.ts": 3808, - "array-refined-storage.ts": 3910, - "array-sort-dense-effects.ts": 4754, - "array-sort-dense-values.ts": 4991, - "array-sort-holes-published.ts": 12914, - "array-sort-runs.ts": 11006, - "array-sort-runtime-comparator.ts": 7044, - "array-sort-unknown-comparator.ts": 2921, - "array-storage-transitions.ts": 4555, - "array-truncate-reuse.ts": 3342, - "async-backend-factory.mjs": 3685, - "async-local-typed-results.ts": 4110, - "atomics-integer-operations.ts": 4324, - "bigint-checked-casts.ts": 3538, - "bigint-checked-storage.js": 3582, - "bigint-union-conversion.ts": 3627, - "boxed-error-rethrows.mjs": 3074, - "buffer-codec-boundaries.ts": 2997, - "buffer-primitive-predicate.ts": 3212, - "builtin-prototype-method-values.mjs": 4169, - "byte-loop-bounds.ts": 3289, - "byte-number-pipeline.ts": 3830, - "byte-record-windows.ts": 4084, - "call-lifetimes-argument-order.ts": 2814, - "call-lifetimes-control-flow.ts": 3242, - "call-lifetimes-owned-boundaries.ts": 3884, - "call-lifetimes-projections.ts": 3960, - "call-lifetimes-union-values.ts": 3288, - "call-lifetimes-virtual-optionals.ts": 4204, - "callable-module-members.mjs": 3631, - "callable-properties.mjs": 3358, - "callable-property-cycles.js": 2892, - "callable-reexport/main.ts": 3566, - "captured-class-refinement.ts": 3716, - "catch-capture.ts": 3398, - "caught-class-identity.ts": 4607, - "caught-standalone-class.ts": 3366, - "caught-system-error-fields.ts": 3842, - "checked-addition.js": 3129, - "checked-any-addition.ts": 3239, - "checked-array-assignment.ts": 3271, - "checked-array-flat/main.ts": 3753, - "checked-bitwise/main.js": 3435, - "checked-builder-cycles.js": 2781, - "checked-byte-storage/main.ts": 3695, - "checked-callback-options.ts": 3641, - "checked-class-descriptors.mjs": 4373, - "checked-class-factory.mjs": 3282, - "checked-collection-iterators.ts": 3261, - "checked-collection-symbol-methods.ts": 2592, - "checked-dispatch-input-lifetimes.js": 2966, - "checked-increment/main.js": 3466, - "checked-inherited-fields.ts": 3091, - "checked-iterator-consumption.js": 4432, - "checked-numeric-arithmetic.js": 3676, - "checked-object-module-alias.js": 3750, - "checked-optional-calls.mjs": 2819, - "checked-promise-recovery.ts": 3546, - "checked-proxy-callback/main.ts": 3548, - "checked-record-constructor.ts": 3491, - "checked-renderer-defaults.js": 2925, - "checked-rest-function-adapters.js": 3233, - "checked-storage-transitions.js": 2999, - "checked-symbol-array.ts": 3209, - "checked-value-input-lifetimes.ts": 2736, - "class-accessor-returned-function.js": 3222, - "class-array-optional-return.ts": 3320, - "class-bracket-method-calls.js": 3856, - "class-brand-overload.js": 3204, - "class-callback-replacement.js": 4854, - "class-callback-storage.ts": 4827, - "class-checked-composites.ts": 3368, - "class-checked-upcast.ts": 3815, - "class-collection-insertion.ts": 5133, - "class-computed-presence.ts": 4064, - "class-computed-symbols.js": 4475, - "class-covariant-returns.ts": 3062, - "class-curried-factory.mjs": 3903, - "class-data-descriptors.js": 4613, - "class-factory-inherited-statics.mjs": 3165, - "class-factory-parameter-base.mjs": 4404, - "class-factory-record-base.mjs": 5117, - "class-factory-recursive-statics.mjs": 3656, - "class-factory-static-members.mjs": 3238, - "class-function-base/main.js": 3349, - "class-instance-constructor.js": 4347, - "class-interface-protocols.ts": 5479, - "class-interface-refinements.ts": 4411, - "class-json-checked.ts": 3478, - "class-local-function-base.mjs": 2889, - "class-method-spreads.ts": 5065, - "class-narrowed-views.ts": 2591, - "class-property-call-values.mjs": 3049, - "class-prototype-data.js": 3914, - "class-prototype-descriptor-copy.mjs": 3673, - "class-specialized-computed-base.mjs": 4340, - "class-static-data.js": 3321, - "class-subclass-assertions.ts": 3532, - "class-super-surplus-spread.mjs": 3433, - "class-symbol-accessors.ts": 3674, - "class-symbol-cache.mjs": 4312, - "class-value-constructor-exceptions.ts": 2729, + "array-read-helper-effects.ts": 3425, + "array-refined-storage.ts": 3909, + "array-sort-dense-effects.ts": 2917, + "array-sort-dense-values.ts": 5261, + "array-sort-holes-published.ts": 13040, + "array-sort-runs.ts": 10059, + "array-sort-runtime-comparator.ts": 5498, + "array-sort-unknown-comparator.ts": 2858, + "array-storage-transitions.ts": 2799, + "array-truncate-reuse.ts": 2407, + "async-backend-factory.mjs": 3609, + "async-local-typed-results.ts": 2487, + "atomics-integer-operations.ts": 3832, + "bigint-checked-casts.ts": 3603, + "bigint-checked-storage.js": 3992, + "bigint-union-conversion.ts": 3125, + "boxed-error-rethrows.mjs": 2646, + "buffer-codec-boundaries.ts": 3139, + "buffer-primitive-predicate.ts": 3495, + "builtin-prototype-method-values.mjs": 4297, + "byte-loop-bounds.ts": 3001, + "byte-number-pipeline.ts": 3966, + "byte-record-windows.ts": 3749, + "call-lifetimes-argument-order.ts": 2794, + "call-lifetimes-control-flow.ts": 3894, + "call-lifetimes-owned-boundaries.ts": 3881, + "call-lifetimes-projections.ts": 3082, + "call-lifetimes-union-values.ts": 3090, + "call-lifetimes-virtual-optionals.ts": 3774, + "callable-module-members.mjs": 2996, + "callable-properties.mjs": 3737, + "callable-property-cycles.js": 2394, + "callable-reexport/main.ts": 2995, + "captured-class-refinement.ts": 3815, + "catch-capture.ts": 2295, + "caught-class-identity.ts": 3893, + "caught-standalone-class.ts": 3591, + "caught-system-error-fields.ts": 3373, + "checked-addition.js": 3059, + "checked-any-addition.ts": 2638, + "checked-array-assignment.ts": 2861, + "checked-array-flat/main.ts": 2441, + "checked-bitwise/main.js": 3177, + "checked-builder-cycles.js": 3284, + "checked-byte-storage/main.ts": 3985, + "checked-callback-options.ts": 3034, + "checked-class-descriptors.mjs": 2786, + "checked-class-factory.mjs": 2348, + "checked-collection-iterators.ts": 3731, + "checked-collection-symbol-methods.ts": 3019, + "checked-dispatch-input-lifetimes.js": 3481, + "checked-increment/main.js": 2884, + "checked-inherited-fields.ts": 2756, + "checked-iterator-consumption.js": 4074, + "checked-numeric-arithmetic.js": 2874, + "checked-object-module-alias.js": 3204, + "checked-optional-calls.mjs": 2897, + "checked-promise-recovery.ts": 2819, + "checked-proxy-callback/main.ts": 3009, + "checked-record-constructor.ts": 3034, + "checked-renderer-defaults.js": 2935, + "checked-rest-function-adapters.js": 2965, + "checked-storage-transitions.js": 2510, + "checked-symbol-array.ts": 2504, + "checked-value-input-lifetimes.ts": 3033, + "class-accessor-returned-function.js": 2287, + "class-array-optional-return.ts": 3498, + "class-bracket-method-calls.js": 3071, + "class-brand-overload.js": 3526, + "class-callback-replacement.js": 3460, + "class-callback-storage.ts": 4585, + "class-checked-composites.ts": 3187, + "class-checked-upcast.ts": 3072, + "class-collection-insertion.ts": 4235, + "class-computed-presence.ts": 2974, + "class-computed-symbols.js": 3740, + "class-covariant-returns.ts": 3957, + "class-curried-factory.mjs": 4128, + "class-data-descriptors.js": 3270, + "class-factory-inherited-statics.mjs": 2538, + "class-factory-parameter-base.mjs": 2587, + "class-factory-record-base.mjs": 5836, + "class-factory-recursive-statics.mjs": 3651, + "class-factory-static-members.mjs": 3672, + "class-function-base/main.js": 2657, + "class-instance-constructor.js": 2942, + "class-interface-protocols.ts": 3713, + "class-interface-refinements.ts": 4567, + "class-json-checked.ts": 2571, + "class-local-function-base.mjs": 3643, + "class-method-spreads.ts": 3220, + "class-narrowed-views.ts": 3766, + "class-property-call-values.mjs": 3125, + "class-prototype-data.js": 4251, + "class-prototype-descriptor-copy.mjs": 3998, + "class-specialized-computed-base.mjs": 3397, + "class-static-data.js": 2157, + "class-subclass-assertions.ts": 3733, + "class-super-surplus-spread.mjs": 2301, + "class-symbol-accessors.ts": 2479, + "class-symbol-cache.mjs": 3721, + "class-value-constructor-exceptions.ts": 3210, "closed-virtual-dispatch-modules/main.ts": 3375, "closed-virtual-dispatch.ts": 4025, - "closure-nullable-union-return.ts": 4235, - "closure-union-locals.ts": 3743, - "collection-array-cycles.ts": 3119, - "collection-array-maps.ts": 3580, - "collection-array-missing.ts": 3529, - "collection-array-sets.ts": 3755, - "collection-copy-identities.ts": 3108, - "collection-data-unions.ts": 3651, - "collection-ingestion-mappers.ts": 3521, - "collection-ingestion-protocol/main.ts": 4669, - "collection-ingestion-references.ts": 4710, - "collection-ingestion.ts": 3512, - "collection-storage-copies.ts": 3878, - "collection-value-keys.ts": 3854, - "compound-field-receivers.ts": 3456, - "compound-presence-guards.ts": 3018, - "conditional-tuple-destructuring.ts": 3519, - "console-imports.cjs": 3565, - "console-native-value.js": 2620, - "const-enum-module-cycle/main.ts": 2768, - "constant-callback-dispatch.ts": 3226, - "constant-module-globals/main.ts": 3076, - "constant-number-remainders.ts": 3457, - "constructed-class-dispatch.ts": 3935, - "contextual-array-union-write.ts": 5322, - "contextual-return-layouts.ts": 4143, - "counted-loop-numbers.ts": 3668, - "counted-loop-storage.ts": 2925, - "crypto-hash-optional-input.ts": 3821, - "cycle-generations-long-lived.ts": 2954, - "cycle-growth-yield.ts": 4304, - "date-checked-native.js": 3239, - "declared-index-spread.ts": 4205, - "deep-reference-teardown.ts": 3431, - "default-undefined-parameters.ts": 4155, - "deferred-field-updates.ts": 2817, - "deferred-registry-many.ts": 4413, - "derived-numeric-updates.ts": 3113, - "destructure-call-assignment.js": 2699, - "destructure-inferred-row-defaults.js": 3698, - "destructure-union-arrays.ts": 3868, - "dynamic-function-descriptors.js": 3825, - "error-cause-writes.js": 3664, - "error-inherited-message.mjs": 4115, - "error-inherited-name.mjs": 4088, - "error-property-writes.mjs": 3831, - "error-prototype-tostring.js": 3723, - "error-stack-frames.ts": 3316, - "error-stack-limit.ts": 3521, - "error-tostring-overrides.ts": 2788, - "error-values-inspect.ts": 2913, - "exact-index-round-trip.ts": 3953, - "expression-runtime-values.ts": 3293, - "fiber-switch-stress.ts": 4327, - "fiberless-async-ordering.ts": 4160, - "fiberless-async-unhandled.ts": 2861, - "field-assignment-values.ts": 3670, - "file-handle-values.ts": 3758, - "file-read-storage.ts": 5381, - "file-url-percent-decoding.ts": 3379, - "final-field-borrows.ts": 3428, - "for-multiple-bindings.ts": 2948, - "for-multiple-lexical-bindings.ts": 3036, - "for-of-checked-iterator.js": 3188, - "for-of-subclass-elements.ts": 3369, - "forward-generic-signatures.ts": 3512, - "fresh-array-union-layout.js": 3601, - "frozen-checked-dictionaries.mjs": 2948, - "fs-native-realpath.ts": 3654, + "closure-nullable-union-return.ts": 2727, + "closure-union-locals.ts": 2878, + "collection-array-cycles.ts": 3240, + "collection-array-maps.ts": 4497, + "collection-array-missing.ts": 3865, + "collection-array-sets.ts": 3087, + "collection-copy-identities.ts": 2655, + "collection-data-unions.ts": 2993, + "collection-ingestion-mappers.ts": 3305, + "collection-ingestion-protocol/main.ts": 5059, + "collection-ingestion-references.ts": 4238, + "collection-ingestion.ts": 3626, + "collection-storage-copies.ts": 4163, + "collection-value-keys.ts": 4167, + "compound-field-receivers.ts": 2877, + "compound-presence-guards.ts": 3145, + "conditional-tuple-destructuring.ts": 3213, + "console-imports.cjs": 2893, + "console-native-value.js": 2516, + "const-enum-module-cycle/main.ts": 3456, + "constant-callback-dispatch.ts": 2916, + "constant-module-globals/main.ts": 2911, + "constant-number-remainders.ts": 2372, + "constructed-class-dispatch.ts": 3382, + "contextual-array-union-write.ts": 6417, + "contextual-return-layouts.ts": 3746, + "counted-loop-numbers.ts": 2724, + "counted-loop-storage.ts": 2302, + "crypto-hash-optional-input.ts": 3311, + "cycle-generations-long-lived.ts": 3514, + "cycle-growth-yield.ts": 3352, + "date-checked-native.js": 2676, + "declared-index-spread.ts": 2941, + "deep-reference-teardown.ts": 4427, + "default-undefined-parameters.ts": 3232, + "deferred-field-updates.ts": 3345, + "deferred-registry-many.ts": 3072, + "derived-numeric-updates.ts": 2702, + "destructure-call-assignment.js": 2978, + "destructure-inferred-row-defaults.js": 3175, + "destructure-union-arrays.ts": 3248, + "dynamic-function-descriptors.js": 2750, + "error-cause-writes.js": 3104, + "error-inherited-message.mjs": 3024, + "error-inherited-name.mjs": 2500, + "error-property-writes.mjs": 3373, + "error-prototype-tostring.js": 3874, + "error-stack-frames.ts": 2418, + "error-stack-limit.ts": 2675, + "error-tostring-overrides.ts": 3246, + "error-values-inspect.ts": 3043, + "exact-index-round-trip.ts": 3701, + "expression-runtime-values.ts": 2154, + "fiber-switch-stress.ts": 5012, + "fiberless-async-ordering.ts": 3413, + "fiberless-async-unhandled.ts": 2739, + "field-assignment-values.ts": 2662, + "file-handle-values.ts": 3133, + "file-read-storage.ts": 3685, + "file-url-percent-decoding.ts": 2659, + "final-field-borrows.ts": 3350, + "for-multiple-bindings.ts": 3223, + "for-multiple-lexical-bindings.ts": 3021, + "for-of-checked-iterator.js": 3541, + "for-of-subclass-elements.ts": 3037, + "forward-generic-signatures.ts": 2999, + "fresh-array-union-layout.js": 2679, + "frozen-checked-dictionaries.mjs": 3220, + "fs-native-realpath.ts": 2477, "fs-null-byte-paths-js.cjs": 3914, "fs-null-byte-paths.ts": 5084, - "fs-read-encodings.ts": 3336, + "fs-read-encodings.ts": 3111, "fs-read-utf8-edges.ts": 4161, "fs-read-utf8-handle-forms.ts": 3562, - "fs-remove-readonly.ts": 3293, - "fs-write-string-bytes-union.ts": 2935, - "function-apply-value.mjs": 3607, - "function-constructor-global.mjs": 3295, - "function-constructor-kinds/main.js": 2837, - "function-custom-prototype.js": 3522, - "function-custom-to-string.mjs": 3399, - "function-object-assign.js": 3758, - "function-own-prototype/main.js": 2807, - "generator-checked-protocol.ts": 3503, - "generator-checked-return.js": 3369, - "generator-custom-delegation/main.ts": 5410, - "generator-default-return-pattern.ts": 2666, - "generator-delegation-values.ts": 3515, - "generator-inferred-date.js": 3280, - "generator-mixed-checked-channels.ts": 3467, - "generator-untyped-consumer/main.ts": 2805, - "generic-base-specializations.ts": 3523, - "generic-binding-ownership.ts": 4463, - "generic-class-js-functions/main.ts": 2699, - "generic-class-recovery.ts": 4031, - "generic-namespace-factories/main.ts": 3082, - "generic-nullable-collections.ts": 3376, - "generic-pattern-bindings.ts": 3388, - "generic-record-index.ts": 3789, - "generic-visitor-void.ts": 3751, + "fs-remove-readonly.ts": 2708, + "fs-write-string-bytes-union.ts": 2772, + "function-apply-value.mjs": 2976, + "function-constructor-global.mjs": 2229, + "function-constructor-kinds/main.js": 3064, + "function-custom-prototype.js": 3165, + "function-custom-to-string.mjs": 3379, + "function-object-assign.js": 3235, + "function-own-prototype/main.js": 2539, + "generator-checked-protocol.ts": 3197, + "generator-checked-return.js": 3544, + "generator-custom-delegation/main.ts": 3611, + "generator-default-return-pattern.ts": 3352, + "generator-delegation-values.ts": 3047, + "generator-inferred-date.js": 3314, + "generator-mixed-checked-channels.ts": 3576, + "generator-untyped-consumer/main.ts": 3225, + "generic-base-specializations.ts": 2247, + "generic-binding-ownership.ts": 3517, + "generic-class-js-functions/main.ts": 2300, + "generic-class-recovery.ts": 2961, + "generic-namespace-factories/main.ts": 3104, + "generic-nullable-collections.ts": 2983, + "generic-pattern-bindings.ts": 3518, + "generic-record-index.ts": 3239, + "generic-visitor-void.ts": 3402, "global-accumulator-loops.ts": 3531, - "global-error-subclasses.ts": 2383, - "global-runtime-probes.js": 3149, - "global-stored-probes.js": 3656, - "global-string-cache/main.js": 2944, - "global-symbol-cache/main.js": 3152, - "guarded-native-iterables.ts": 3442, - "heap-input-aliases.ts": 3338, - "heap-input-collections.ts": 3866, - "in-array-runtime-index.ts": 4870, - "indexed-assignment-values.js": 3555, - "indexed-assignment-values.ts": 3263, - "indexed-element-field-reads.ts": 3648, - "inferred-array-assignment-values.mjs": 2599, - "inferred-class-default.mjs": 2738, - "inferred-compound-values.mjs": 3388, - "inferred-conditional-class.mjs": 2376, - "inferred-error-fields.js": 2452, - "inferred-map-patterns.mjs": 3504, - "inferred-method-override.js": 2889, - "inferred-partial-destructuring.mjs": 3489, - "inferred-primitive-properties.mjs": 2842, - "inferred-record-return.mjs": 3292, - "inferred-recursive-record.mjs": 3932, - "inferred-undefined-field.mjs": 2401, - "input-lifetime-intervals.ts": 3651, - "input-lifetimes-modules/main.ts": 3648, - "instanceof-class-record-union.ts": 3935, - "integer-flow-arithmetic.ts": 3336, - "integer-loop-forms.ts": 3549, - "integer-view-control.ts": 2594, - "integer-view-numbers.ts": 3585, - "integer-view-storage.ts": 3667, - "intl-grapheme-conformance/main.ts": 4680, - "intl-grapheme.ts": 4135, - "iterator-typed-returns.ts": 4766, - "js-abort-portable.js": 3961, - "js-array-constructor.js": 3335, - "js-array-default-buffer.js": 2734, - "js-array-iterators.js": 3671, - "js-arrow-bind.cjs": 5214, - "js-buffer-callback-brand.cjs": 4283, - "js-callable-proxy.js": 3329, - "js-chained-native-results.mjs": 3307, - "js-checked-array-iterator.js": 3738, - "js-checked-array-reference.js": 3849, - "js-checked-number-negation.mjs": 3465, - "js-checked-sort-result.js": 2437, - "js-child-error-listener.cjs": 2606, - "js-cjs-callable-snapshots/main.cjs": 3122, - "js-class-added-parameters.js": 3654, - "js-class-checked-overrides.js": 3726, - "js-class-computed-fields.js": 3260, - "js-class-enumeration.js": 4284, - "js-class-field-accessor-override.js": 3902, - "js-class-fluent-overrides.js": 3667, - "js-class-late-method-values.js": 3068, - "js-class-member-dispatch.js": 4117, - "js-class-return-shapes.js": 3935, - "js-class-shadowed-methods.js": 4040, - "js-class-stored-method-receiver.js": 2904, - "js-class-subclass-properties.js": 5036, - "js-class-symbol-spread.cjs": 3637, - "js-computed-prototype-additions.js": 2620, - "js-constructor-returned-callable.js": 2532, - "js-constructor-spread.js": 3024, - "js-dataview-dispatch.js": 3608, - "js-declared-fields.cjs": 5015, - "js-default-listener-arguments.cjs": 2326, - "js-default-options/main.ts": 3910, - "js-deferred-field-initializers.js": 2418, - "js-deferred-registry-effects.js": 3462, - "js-derived-constructor-hoisting.js": 2798, - "js-dormant-array-write.js": 3572, - "js-dormant-overrides.js": 2747, - "js-expando-records.js": 3967, - "js-implicit-call-results.js": 2920, - "js-inferred-callback-exports/main.js": 4360, - "js-inferred-class-array-return.js": 3664, - "js-inferred-object-values.js": 3561, - "js-inherited-field-storage.js": 2906, - "js-inherited-parameter-abi.js": 2442, - "js-iterable-spread.js": 2766, - "js-loose-dynamic-primitives.js": 3050, - "js-map-object-seeds.js": 3816, - "js-member-increment.js": 4372, - "js-module-function-values.js": 3724, - "js-mutable-null-members.js": 3894, - "js-nested-native-descriptors.js": 3332, - "js-normalize-dispatch.js": 3662, - "js-nullish-inherited-fields.mjs": 3226, - "js-object-receiver-storage.js": 3635, - "js-object-returning-constructors.mjs": 3324, - "js-object-shared-arrays.js": 3926, - "js-omitted-typed-arguments.js": 3274, - "js-open-binding-writes.js": 3161, - "js-optional-class-fields.js": 3414, - "js-optional-member-call.js": 3623, - "js-primitive-union-addition.js": 3186, - "js-promise-all-values.js": 3364, - "js-promise-catch-handler.js": 2469, - "js-promise-finally-order.js": 3631, - "js-promise-pending-reactions.js": 3621, - "js-prototype-host-boundary.js": 40863, - "js-reflect-receivers.js": 3717, - "js-regex-record-captures.js": 4129, - "js-scalar-iterables.js": 3831, - "js-shared-method-dispatch.js": 3185, - "js-specialized-field-method.js": 2772, - "js-static-accessors.js": 3403, - "js-static-method-values.js": 3866, - "js-static-registries.cjs": 3795, - "js-super-accessor-initialization.js": 3887, - "js-uninitialized-native-fields.js": 3361, - "json-guarded-map-values.ts": 3542, - "json-output-bulk.ts": 3334, - "json-runtime-options.mjs": 2995, - "json-stringify-value.js": 3147, - "json-typed-parse-direct.ts": 3768, + "global-error-subclasses.ts": 2754, + "global-runtime-probes.js": 2804, + "global-stored-probes.js": 3113, + "global-string-cache/main.js": 2090, + "global-symbol-cache/main.js": 3628, + "guarded-native-iterables.ts": 3327, + "heap-input-aliases.ts": 3457, + "heap-input-collections.ts": 3653, + "in-array-runtime-index.ts": 3275, + "indexed-assignment-values.js": 3011, + "indexed-assignment-values.ts": 2182, + "indexed-element-field-reads.ts": 3247, + "inferred-array-assignment-values.mjs": 2906, + "inferred-class-default.mjs": 2977, + "inferred-compound-values.mjs": 2759, + "inferred-conditional-class.mjs": 3292, + "inferred-error-fields.js": 3405, + "inferred-map-patterns.mjs": 2764, + "inferred-method-override.js": 2696, + "inferred-partial-destructuring.mjs": 2539, + "inferred-primitive-properties.mjs": 2255, + "inferred-record-return.mjs": 2589, + "inferred-recursive-record.mjs": 2186, + "inferred-undefined-field.mjs": 2551, + "input-lifetime-intervals.ts": 3191, + "input-lifetimes-modules/main.ts": 3221, + "instanceof-class-record-union.ts": 3279, + "integer-flow-arithmetic.ts": 3347, + "integer-loop-forms.ts": 2940, + "integer-view-control.ts": 2093, + "integer-view-numbers.ts": 2680, + "integer-view-storage.ts": 3947, + "intl-grapheme-conformance/main.ts": 5064, + "intl-grapheme.ts": 2412, + "iterator-typed-returns.ts": 3466, + "js-abort-portable.js": 4587, + "js-array-constructor.js": 3296, + "js-array-default-buffer.js": 3604, + "js-array-iterators.js": 3215, + "js-arrow-bind.cjs": 3596, + "js-buffer-callback-brand.cjs": 3526, + "js-builder-string-method-names/main.ts": 5400, + "js-callable-builder.js": 10100, + "js-callable-proxy.js": 3865, + "js-chained-native-results.mjs": 3076, + "js-checked-array-iterator.js": 2790, + "js-checked-array-reference.js": 2884, + "js-checked-number-negation.mjs": 2418, + "js-checked-sort-result.js": 2906, + "js-child-error-listener.cjs": 2538, + "js-cjs-callable-snapshots/main.cjs": 2461, + "js-class-added-parameters.js": 2522, + "js-class-checked-overrides.js": 2542, + "js-class-computed-fields.js": 2281, + "js-class-constructor-returns/main.ts": 5400, + "js-class-enumeration.js": 3084, + "js-class-field-accessor-override.js": 3865, + "js-class-fluent-overrides.js": 3368, + "js-class-late-method-values.js": 2526, + "js-class-member-dispatch.js": 3846, + "js-class-return-shapes.js": 2639, + "js-class-shadowed-methods.js": 2891, + "js-class-stored-method-receiver.js": 2685, + "js-class-subclass-properties.js": 3775, + "js-class-symbol-spread.cjs": 3550, + "js-computed-prototype-additions.js": 3462, + "js-constructor-returned-callable.js": 3346, + "js-constructor-spread.js": 3311, + "js-dataview-dispatch.js": 2423, + "js-declared-fields.cjs": 3098, + "js-default-listener-arguments.cjs": 2941, + "js-default-options/main.ts": 3442, + "js-deferred-field-initializers.js": 2409, + "js-deferred-registry-effects.js": 2980, + "js-derived-constructor-hoisting.js": 2695, + "js-dormant-array-write.js": 2014, + "js-dormant-overrides.js": 3783, + "js-expando-records.js": 2526, + "js-function-prototype-value.js": 5100, + "js-implicit-call-results.js": 2892, + "js-inferred-callback-exports/main.js": 3776, + "js-inferred-class-array-return.js": 3477, + "js-inferred-object-values.js": 3358, + "js-inherited-field-storage.js": 3527, + "js-inherited-parameter-abi.js": 3324, + "js-iterable-spread.js": 3504, + "js-loose-dynamic-primitives.js": 2079, + "js-map-object-seeds.js": 3322, + "js-member-increment.js": 4257, + "js-module-function-values.js": 3135, + "js-mutable-null-members.js": 2750, + "js-nested-native-descriptors.js": 2725, + "js-normalize-dispatch.js": 3264, + "js-nullish-inherited-fields.mjs": 3080, + "js-number-parse-dynamic.js": 4350, + "js-object-receiver-storage.js": 3515, + "js-object-returning-constructors.mjs": 3015, + "js-object-shared-arrays.js": 2539, + "js-omitted-typed-arguments.js": 2295, + "js-open-binding-writes.js": 1944, + "js-optional-class-fields.js": 3252, + "js-optional-member-call.js": 3095, + "js-primitive-union-addition.js": 2779, + "js-process-destructure.mjs": 4600, + "js-promise-all-values.js": 3443, + "js-promise-catch-handler.js": 2034, + "js-promise-finally-order.js": 2084, + "js-promise-pending-reactions.js": 3602, + "js-prototype-host-boundary.js": 4779, + "js-reflect-receivers.js": 3486, + "js-regex-record-captures.js": 2214, + "js-reshaped-object-literal.js": 7750, + "js-scalar-iterables.js": 3719, + "js-shared-method-dispatch.js": 2114, + "js-specialized-field-method.js": 3011, + "js-static-accessors.js": 3435, + "js-static-method-values.js": 3174, + "js-static-registries.cjs": 3047, + "js-super-accessor-initialization.js": 2998, + "js-uninitialized-native-fields.js": 2354, + "json-guarded-map-values.ts": 2502, + "json-output-bulk.ts": 3214, + "json-runtime-options.mjs": 2794, + "json-stringify-value.js": 2833, + "json-typed-parse-direct.ts": 3580, "json-typed-parse-index-signatures.ts": 3707, "json-typed-parse-optional-members.ts": 4645, "json-typed-parse-union-members.ts": 2884, - "literal-switch-dispatch.ts": 3317, - "live-reference-shared-converters.ts": 9504, - "llvm-read-receiver-lifetime.ts": 4439, - "local-class-call-spreads.js": 3630, - "local-class-declaration.ts": 3068, - "local-class-evaluation.ts": 3450, - "local-class-inheritance.ts": 3339, - "local-class-lifetimes.ts": 3623, - "local-class-namespace/main.js": 3916, - "local-class-prototype-data.js": 3797, - "local-class-specialization.js": 3033, - "local-class-unknown.ts": 2900, - "local-class-values.ts": 2584, - "local-union-storage.ts": 3820, - "locale-compare-root-order.ts": 3234, - "logical-assignment-dynamic.js": 3066, - "logical-assignment-values.ts": 3751, - "logical-runtime-optional-record.ts": 3473, - "loop-reference-lifetimes.ts": 2819, - "map-checked-boundary/main.ts": 3663, - "map-checked-seed.js": 3370, + "literal-switch-dispatch.ts": 2951, + "live-reference-shared-converters.ts": 19276, + "llvm-read-receiver-lifetime.ts": 3803, + "local-class-call-spreads.js": 3495, + "local-class-declaration.ts": 2661, + "local-class-evaluation.ts": 3104, + "local-class-inheritance.ts": 2552, + "local-class-lifetimes.ts": 3344, + "local-class-namespace/main.js": 3630, + "local-class-prototype-data.js": 3990, + "local-class-specialization.js": 2812, + "local-class-unknown.ts": 3002, + "local-class-values.ts": 2009, + "local-union-storage.ts": 3026, + "locale-compare-root-order.ts": 3444, + "logical-assignment-dynamic.js": 3230, + "logical-assignment-values.ts": 3566, + "logical-runtime-optional-record.ts": 3322, + "loop-reference-lifetimes.ts": 3339, + "map-checked-boundary/main.ts": 2843, + "map-checked-seed.js": 2966, "map-get-set-fusion.ts": 3638, - "map-number-keys-dense.ts": 4412, - "map-read-lifetimes-exits.ts": 2579, - "map-read-lifetimes.ts": 3849, - "map-seeds-and-spreads.ts": 3171, - "map-typed-array-values.ts": 3666, - "math-function-values.js": 2486, - "missing-read-lambda-results.ts": 3345, - "missing-read-narrowed-storage.ts": 3729, - "missing-read-number-conversions.ts": 3696, - "module-byte-loops.ts": 3029, - "module-fallback-functions/main.js": 3321, - "narrowed-nullish-values.ts": 3184, - "native-any-timer-callback.ts": 2884, - "native-array-borrowed-find-last.js": 3352, - "native-array-borrowed-slice.js": 3286, - "native-array-copying-methods.js": 2464, - "native-array-fill-copywithin.js": 2771, - "native-array-frozen-noops.js": 3256, - "native-array-index-boundaries.js": 2917, - "native-array-integrity.js": 2583, - "native-array-length.js": 2372, - "native-array-named-properties.js": 3684, - "native-array-prototype/main.js": 3743, - "native-array-read-lifetimes.ts": 3932, - "native-array-reduce-find-last.js": 2450, - "native-array-search-from-index.js": 2847, - "native-array-splice-coercion.js": 3405, - "native-array-splice-flat.js": 3104, - "native-buffer-coercion.js": 3322, - "native-callback-dispatch.ts": 3832, - "native-class-array-boundaries.ts": 3342, - "native-class-cache.js": 3840, - "native-class-properties.cjs": 5572, - "native-class-property-cycles.cjs": 3155, - "native-class-property-order.cjs": 3170, - "native-class-type-predicates.ts": 3052, - "native-factory-records.js": 3387, - "native-method-values.js": 4924, - "native-method-values.ts": 3868, - "native-npm-imports/main.ts": 3901, - "native-object-descriptors.js": 3247, - "native-object-for-in-minimal.js": 3446, - "native-object-property-attributes.js": 3224, - "native-object-prototype.js": 2952, - "native-property-names.ts": 2920, - "native-proxy-env.js": 4531, - "native-worker-arena-reuse.ts": 9740, - "native-worker-bounded-errors.ts": 3428, - "native-worker-buffer-consumers.ts": 4341, - "native-worker-cancel-hot.ts": 3046, - "native-worker-class-fields.ts": 3987, - "native-worker-clone-errors.ts": 3205, - "native-worker-commonjs.cjs": 3563, - "native-worker-delayed-messages.ts": 3820, - "native-worker-discarded-heaps.ts": 9491, - "native-worker-environment.ts": 3678, - "native-worker-error.ts": 3443, - "native-worker-exception-state.ts": 3795, - "native-worker-exit-listeners.ts": 3786, - "native-worker-io.ts": 3497, - "native-worker-loop-cancellation.ts": 3485, - "native-worker-message-graphs.ts": 3324, - "native-worker-messages.ts": 3248, - "native-worker-poll-exceptions.ts": 3463, - "native-worker-port-lifetime.ts": 3679, - "native-worker-process-exit.ts": 25459, - "native-worker-publish-classes.ts": 39360, - "native-worker-publish-refusals.ts": 3725, - "native-worker-published-graphs.ts": 3934, - "native-worker-references.ts": 4072, - "native-worker-roots/main.ts": 3317, - "native-worker-shared-views.ts": 34203, - "native-worker-stack-overflow.ts": 3534, - "native-worker-terminate-exception-state.ts": 4664, - "native-worker-terminate-loop.ts": 3303, - "native-worker-terminate-recursion.ts": 4325, - "native-worker-terminate-suspended.ts": 3580, - "native-worker-terminate-tested-loops.ts": 3001, - "native-worker-terminate-wait.ts": 3399, - "native-worker-typed-arrays.ts": 3056, - "nested-map-cycles.ts": 2892, - "nested-map-values.ts": 4020, - "never-returning-calls.ts": 3353, - "next-tick-commonjs-entry.cjs": 3537, - "node24-buffer-encoding-errors.ts": 3190, - "node24-buffer-encoding.ts": 3056, - "node24-crypto-kdf-errors.ts": 3983, - "node24-crypto-kdf-options.ts": 3444, - "node24-crypto-kdf.ts": 3815, - "node24-crypto-sha2.ts": 3261, - "node24-deep-equality-properties.js": 3213, - "node24-deep-equality.cjs": 4348, - "node24-deep-equality.ts": 4931, - "node24-env-files-errors.ts": 3190, - "node24-env-files.ts": 3237, - "node24-env-imports.cjs": 2806, - "node24-env-parse-errors.ts": 3175, - "node24-env-parse.ts": 2442, - "node24-esm-metadata/main.mjs": 3178, - "node24-file-url-buffer.ts": 2578, - "node24-file-url-errors.js": 3662, - "node24-file-url-options.ts": 3335, - "node24-fs-links-callbacks.cjs": 2914, - "node24-fs-links-errors.cjs": 2718, - "node24-fs-links-options.cjs": 5212, - "node24-fs-links-promise-errors.cjs": 3623, - "node24-fs-links-promises.ts": 3653, - "node24-fs-links.ts": 2754, - "node24-fs-statfs-callbacks.cjs": 3304, - "node24-fs-statfs-errors.cjs": 3642, - "node24-fs-statfs-options.cjs": 3933, - "node24-fs-statfs.ts": 3769, - "node24-fs-timestamps-callbacks.cjs": 3563, - "node24-fs-timestamps-errors.cjs": 3595, - "node24-fs-timestamps-promises.ts": 4047, - "node24-fs-timestamps-symlinks.ts": 2514, - "node24-fs-timestamps.ts": 3364, - "node24-no-error-assertions-coercion.js": 3593, - "node24-no-error-assertions.cjs": 2425, - "node24-no-error-assertions.ts": 4527, - "node24-parseargs.js": 5067, - "node24-string-decoder.ts": 2945, - "node24-style-text-environment.js": 3145, - "node24-style-text-validation.js": 4525, - "node24-style-text.cjs": 3538, - "node24-style-text.ts": 3894, - "node24-system-error-validation.js": 3199, - "node24-system-errors.cjs": 2805, - "node24-system-errors.ts": 3782, - "node24-text-codec-properties.ts": 3181, - "node24-text-encode-into.ts": 2752, - "node24-text-utilities-coercion.js": 2713, - "node24-text-utilities-validation.js": 3711, - "node24-text-utilities.cjs": 3142, - "node24-text-utilities.ts": 3686, - "node24-url-authority-coercion.js": 3699, - "node24-url-authority.ts": 3174, - "node24-url-factories.ts": 3606, - "node24-url-factory-errors.ts": 3314, - "node24-url-mutation-coercion.js": 3050, - "node24-url-mutation.ts": 2529, - "node24-util-types.cjs": 2859, - "node24-util-types.js": 3337, - "node24-util-types.ts": 3883, - "non-null-class-iteration.ts": 3145, - "nonnull-element-arguments.ts": 2747, - "nonnull-forwarded-class-values.ts": 3637, - "nullable-object-extension.mjs": 3028, - "nullish-asserted-class-arms.ts": 2996, - "nullish-assignment-values.ts": 3685, - "nullish-long-chain.ts": 4539, - "number-parse-statics.ts": 2378, - "number-predicates-unknown.ts": 3263, - "numeric-call-specialization.ts": 3397, - "object-enumeration-array-reads.ts": 3721, - "object-from-checked-entries.js": 4400, - "object-inherited-to-string.js": 3338, - "object-key-indexes.js": 4004, - "object-prototype-identity.mjs": 3277, - "object-reexport/main.js": 3532, - "object-spread-computed.ts": 3618, - "opentui-byte-queue.js": 2761, - "optional-callback-arity.ts": 2368, - "optional-class-flows.ts": 2553, - "optional-element-defaults.ts": 3275, - "optional-flag-comparisons.ts": 3105, - "optional-native-callables.js": 3200, - "optional-node-list-iteration.ts": 3422, - "optional-string-index/main.ts": 2937, - "path-to-file-url-options.ts": 3680, - "performance-presence.ts": 3328, - "primitive-and-function-descriptors.js": 3559, - "primitive-union-string.ts": 3162, - "process-builtin-values.js": 4636, - "process-constrained-memory.ts": 2246, - "process-env-computed-keys.js": 3276, - "process-hrtime.js": 3203, - "process-named-signals.cjs": 3440, - "process-uncaught-handler-throws.cjs": 2812, - "process-uncaught-loop.cjs": 2427, - "process-uncaught-module.mjs": 2982, - "process-uncaught-monitor.cjs": 3049, - "process-uncaught-rejection.cjs": 2978, - "process-uncaught-sync.cjs": 2919, - "process-version-pin.ts": 3275, - "process-versions-storage.ts": 3558, - "projected-collection-lifetimes.ts": 3501, - "promise-checked-rejections.ts": 2387, - "promise-resolve-void.ts": 2676, - "prototype-method-overrides.mjs": 7058, - "prototype-named-data-records.ts": 3518, + "map-number-keys-dense.ts": 2773, + "map-read-lifetimes-exits.ts": 2761, + "map-read-lifetimes.ts": 3024, + "map-seeds-and-spreads.ts": 3502, + "map-typed-array-values.ts": 3300, + "math-function-values.js": 2815, + "missing-read-lambda-results.ts": 3370, + "missing-read-narrowed-storage.ts": 2854, + "missing-read-number-conversions.ts": 2326, + "module-byte-loops.ts": 2961, + "module-fallback-functions/main.js": 2737, + "narrowed-nullish-values.ts": 3160, + "native-any-timer-callback.ts": 2388, + "native-array-borrowed-find-last.js": 2571, + "native-array-borrowed-slice.js": 3010, + "native-array-copying-methods.js": 3608, + "native-array-fill-copywithin.js": 2996, + "native-array-frozen-noops.js": 3132, + "native-array-index-boundaries.js": 2225, + "native-array-integrity.js": 3091, + "native-array-length.js": 2365, + "native-array-named-properties.js": 2772, + "native-array-prototype/main.js": 3257, + "native-array-read-lifetimes.ts": 3805, + "native-array-reduce-find-last.js": 2524, + "native-array-search-from-index.js": 2027, + "native-array-splice-coercion.js": 2902, + "native-array-splice-flat.js": 2702, + "native-buffer-coercion.js": 2533, + "native-callback-dispatch.ts": 3850, + "native-class-array-boundaries.ts": 3272, + "native-class-cache.js": 3290, + "native-class-properties.cjs": 4583, + "native-class-property-cycles.cjs": 2888, + "native-class-property-order.cjs": 2105, + "native-class-type-predicates.ts": 2960, + "native-factory-records.js": 3080, + "native-method-values.js": 3222, + "native-method-values.ts": 2808, + "native-npm-imports/main.ts": 2750, + "native-object-descriptors.js": 2979, + "native-object-for-in-minimal.js": 2411, + "native-object-property-attributes.js": 3057, + "native-object-prototype.js": 3409, + "native-property-names.ts": 2077, + "native-proxy-env.js": 4372, + "native-worker-arena-reuse.ts": 33854, + "native-worker-bounded-errors.ts": 2556, + "native-worker-buffer-consumers.ts": 38253, + "native-worker-cancel-hot.ts": 28908, + "native-worker-class-fields.ts": 3286, + "native-worker-clone-errors.ts": 3629, + "native-worker-commonjs.cjs": 3085, + "native-worker-delayed-messages.ts": 28752, + "native-worker-discarded-heaps.ts": 39440, + "native-worker-environment.ts": 27133, + "native-worker-error.ts": 2958, + "native-worker-exception-state.ts": 3945, + "native-worker-exit-listeners.ts": 4052, + "native-worker-io.ts": 3361, + "native-worker-loop-cancellation.ts": 2798, + "native-worker-message-graphs.ts": 2738, + "native-worker-messages.ts": 3079, + "native-worker-poll-exceptions.ts": 2575, + "native-worker-port-lifetime.ts": 3213, + "native-worker-process-exit.ts": 4104, + "native-worker-publish-classes.ts": 24713, + "native-worker-publish-refusals.ts": 2820, + "native-worker-published-graphs.ts": 3534, + "native-worker-references.ts": 3358, + "native-worker-roots/main.ts": 2808, + "native-worker-shared-views.ts": 3012, + "native-worker-stack-overflow.ts": 2597, + "native-worker-terminate-exception-state.ts": 3340, + "native-worker-terminate-loop.ts": 2222, + "native-worker-terminate-recursion.ts": 2829, + "native-worker-terminate-suspended.ts": 4348, + "native-worker-terminate-tested-loops.ts": 3576, + "native-worker-terminate-wait.ts": 3222, + "native-worker-typed-arrays.ts": 2653, + "nested-map-cycles.ts": 3041, + "nested-map-values.ts": 2382, + "never-returning-calls.ts": 2642, + "next-tick-commonjs-entry.cjs": 2624, + "node24-buffer-encoding-errors.ts": 2695, + "node24-buffer-encoding.ts": 3038, + "node24-crypto-kdf-errors.ts": 2745, + "node24-crypto-kdf-options.ts": 2029, + "node24-crypto-kdf.ts": 3632, + "node24-crypto-sha2.ts": 2849, + "node24-deep-equality-properties.js": 3355, + "node24-deep-equality.cjs": 2682, + "node24-deep-equality.ts": 4058, + "node24-env-files-errors.ts": 3202, + "node24-env-files.ts": 3044, + "node24-env-imports.cjs": 2529, + "node24-env-parse-errors.ts": 2062, + "node24-env-parse.ts": 3684, + "node24-esm-metadata/main.mjs": 2492, + "node24-file-url-buffer.ts": 2158, + "node24-file-url-errors.js": 3331, + "node24-file-url-options.ts": 2772, + "node24-fs-links-callbacks.cjs": 3549, + "node24-fs-links-errors.cjs": 2633, + "node24-fs-links-options.cjs": 3571, + "node24-fs-links-promise-errors.cjs": 2445, + "node24-fs-links-promises.ts": 2105, + "node24-fs-links.ts": 2967, + "node24-fs-statfs-callbacks.cjs": 3035, + "node24-fs-statfs-errors.cjs": 2969, + "node24-fs-statfs-options.cjs": 3557, + "node24-fs-statfs.ts": 3067, + "node24-fs-timestamps-callbacks.cjs": 3095, + "node24-fs-timestamps-errors.cjs": 3110, + "node24-fs-timestamps-promises.ts": 3573, + "node24-fs-timestamps-symlinks.ts": 3390, + "node24-fs-timestamps.ts": 3032, + "node24-no-error-assertions-coercion.js": 2850, + "node24-no-error-assertions.cjs": 2814, + "node24-no-error-assertions.ts": 4358, + "node24-parseargs.js": 5971, + "node24-string-decoder.ts": 3185, + "node24-style-text-environment.js": 4225, + "node24-style-text-validation.js": 3673, + "node24-style-text.cjs": 3476, + "node24-style-text.ts": 3037, + "node24-system-error-validation.js": 3005, + "node24-system-errors.cjs": 3631, + "node24-system-errors.ts": 2849, + "node24-text-codec-properties.ts": 30185, + "node24-text-encode-into.ts": 3601, + "node24-text-utilities-coercion.js": 3094, + "node24-text-utilities-validation.js": 2330, + "node24-text-utilities.cjs": 2768, + "node24-text-utilities.ts": 3312, + "node24-url-authority-coercion.js": 3307, + "node24-url-authority.ts": 2639, + "node24-url-factories.ts": 3240, + "node24-url-factory-errors.ts": 2819, + "node24-url-mutation-coercion.js": 2399, + "node24-url-mutation.ts": 3257, + "node24-util-types.cjs": 3263, + "node24-util-types.js": 2199, + "node24-util-types.ts": 3506, + "non-null-class-iteration.ts": 3295, + "nonnull-element-arguments.ts": 2857, + "nonnull-forwarded-class-values.ts": 3303, + "nullable-object-extension.mjs": 2652, + "nullish-asserted-class-arms.ts": 2669, + "nullish-assignment-values.ts": 2125, + "nullish-long-chain.ts": 2641, + "number-parse-statics.ts": 2471, + "number-predicates-unknown.ts": 2568, + "numeric-call-specialization.ts": 2498, + "object-enumeration-array-reads.ts": 2246, + "object-from-checked-entries.js": 3478, + "object-inherited-to-string.js": 2987, + "object-key-indexes.js": 3206, + "object-prototype-identity.mjs": 3083, + "object-reexport/main.js": 2466, + "object-spread-computed.ts": 2806, + "opentui-byte-queue.js": 3532, + "optional-callback-arity.ts": 2417, + "optional-class-flows.ts": 2497, + "optional-element-defaults.ts": 2632, + "optional-flag-comparisons.ts": 2536, + "optional-native-callables.js": 2751, + "optional-node-list-iteration.ts": 2564, + "optional-string-index/main.ts": 3419, + "path-to-file-url-options.ts": 2301, + "performance-presence.ts": 2913, + "primitive-and-function-descriptors.js": 3070, + "primitive-union-string.ts": 3434, + "process-builtin-values.js": 2781, + "process-constrained-memory.ts": 2857, + "process-env-computed-keys.js": 3185, + "process-hrtime.js": 2662, + "process-named-signals.cjs": 3171, + "process-uncaught-handler-throws.cjs": 2344, + "process-uncaught-loop.cjs": 3141, + "process-uncaught-module.mjs": 2646, + "process-uncaught-monitor.cjs": 2837, + "process-uncaught-rejection.cjs": 2664, + "process-uncaught-sync.cjs": 2858, + "process-version-pin.ts": 3005, + "process-versions-storage.ts": 2055, + "projected-collection-lifetimes.ts": 3232, + "promise-checked-rejections.ts": 2914, + "promise-resolve-void.ts": 2846, + "prototype-method-overrides.mjs": 4119, + "prototype-named-data-records.ts": 3179, "rc-last-use-moves.ts": 4127, "rc-private-array-writes.ts": 4075, - "record-field-presence.ts": 4445, - "record-key-order.ts": 2786, - "record-optional-json-presence.ts": 3499, - "record-presence-copies.ts": 4175, - "record-presence-delete-json.ts": 2958, - "record-unchecked-read-presence.ts": 3597, - "record-unknown-values.ts": 4381, - "reflect-own-keys.mjs": 2660, - "reflect-record-union-keys.mjs": 2359, - "reflect-typed-record-keys.ts": 2855, - "regex-callback-replacements.ts": 3541, - "regex-callback-values.js": 3624, - "regex-checked-casts.ts": 3867, - "regex-checked-storage.js": 3704, - "regex-exec-long-subject.ts": 8130, + "record-field-presence.ts": 3698, + "record-key-order.ts": 2706, + "record-optional-json-presence.ts": 3216, + "record-presence-copies.ts": 3381, + "record-presence-delete-json.ts": 3160, + "record-unchecked-read-presence.ts": 2953, + "record-unknown-values.ts": 4095, + "reflect-own-keys.mjs": 2705, + "reflect-record-union-keys.mjs": 2815, + "reflect-typed-record-keys.ts": 2683, + "regex-callback-replacements.ts": 2631, + "regex-callback-values.js": 3741, + "regex-checked-casts.ts": 2405, + "regex-checked-storage.js": 3560, + "regex-exec-long-subject.ts": 5584, "regex-exec-result-arrays.ts": 4036, "regex-fs-text-surfaces.ts": 4013, - "regex-input-lifetimes.ts": 2860, - "regex-native-matcher.ts": 4866, - "regex-optional-captures.ts": 3208, - "regex-optional-templates.ts": 3554, - "regex-split-captures.ts": 3707, - "regex-text-paths.ts": 2943, - "regexp-constructor-repeat.ts": 3471, - "regexp-optional-constructor.ts": 3547, - "regexp-string-coercion.js": 2902, - "renderer-export-dictionaries.js": 2853, - "renderer-null-state.js": 3392, - "renderer-specializations.js": 3361, - "repeat-and-typed-read-errors.ts": 3813, - "rest-optional-array-arguments.ts": 4116, - "rest-optional-elements.ts": 3072, - "return-void-through-finally.ts": 2672, - "runtime-optional-string-flows.ts": 3420, - "scalar-string-slices.ts": 3228, - "set-checked-methods.js": 3654, - "set-checked-storage.ts": 3542, - "set-iterator-seed-references.ts": 3832, - "set-iterator-seeds.ts": 3864, - "set-optional-seeds.ts": 3189, - "small-collection-transitions.ts": 3703, + "regex-input-lifetimes.ts": 3241, + "regex-native-matcher.ts": 3652, + "regex-optional-captures.ts": 2740, + "regex-optional-templates.ts": 2802, + "regex-split-captures.ts": 3590, + "regex-text-paths.ts": 2840, + "regexp-constructor-repeat.ts": 2602, + "regexp-optional-constructor.ts": 2950, + "regexp-string-coercion.js": 2621, + "renderer-export-dictionaries.js": 3415, + "renderer-null-state.js": 2259, + "renderer-specializations.js": 2837, + "repeat-and-typed-read-errors.ts": 3220, + "rest-optional-array-arguments.ts": 2860, + "rest-optional-elements.ts": 2445, + "return-void-through-finally.ts": 2861, + "runtime-optional-string-flows.ts": 2977, + "scalar-string-slices.ts": 2840, + "set-checked-methods.js": 3072, + "set-checked-storage.ts": 2667, + "set-iterator-seed-references.ts": 3159, + "set-iterator-seeds.ts": 3269, + "set-optional-seeds.ts": 2164, + "small-collection-transitions.ts": 3586, "speculative-integer-globals.ts": 2999, "speculative-integer-loops.ts": 4097, "speculative-integer-reads.ts": 3960, - "stack-depth-async-bodies.ts": 3593, - "stack-overflow-async.ts": 3327, - "stack-overflow-caught.ts": 3619, - "stack-overflow-finally.ts": 4048, - "stack-overflow-shapes.ts": 4840, - "stack-overflow-uncaught.ts": 3019, + "stack-depth-async-bodies.ts": 2727, + "stack-overflow-async.ts": 2942, + "stack-overflow-caught.ts": 3056, + "stack-overflow-finally.ts": 3694, + "stack-overflow-shapes.ts": 3565, + "stack-overflow-uncaught.ts": 2532, "stackless-async-concurrency.ts": 5553, "stackless-async-context.ts": 3712, "stackless-async-exceptions.ts": 4059, "stackless-async-ordering.ts": 4230, "stackless-async-unhandled.ts": 3409, - "static-field-updates/main.ts": 3160, - "static-method-receivers.ts": 3269, - "stdio-values.mjs": 3241, - "stdio-write-errors.mjs": 3357, - "stdio-write-overrides.mjs": 3279, - "stored-native-builtins.js": 3593, - "stored-object-helpers.js": 3366, + "static-field-updates/main.ts": 2914, + "static-method-receivers.ts": 2350, + "stdio-values.mjs": 2761, + "stdio-write-errors.mjs": 2672, + "stdio-write-overrides.mjs": 3205, + "stored-native-builtins.js": 3341, + "stored-object-helpers.js": 2959, "stream-dynamic-entry-kinds.cjs": 8165, "stream-dynamic-entry-kinds.ts": 2619, "stream-encoded-from-entries.cjs": 4394, "stream-encoded-from-entries.ts": 4716, - "string-char-code-integer-loops.ts": 3604, - "string-code-points.ts": 2747, - "string-concat-number-parts.ts": 3145, - "string-construction-order.ts": 3430, + "string-char-code-integer-loops.ts": 2575, + "string-code-points.ts": 2460, + "string-concat-number-parts.ts": 2155, + "string-construction-order.ts": 3307, "string-field-append.ts": 3228, - "string-lifetimes-boundaries.ts": 3759, - "string-lifetimes-evaluation.ts": 3595, - "string-lifetimes-iteration.ts": 2950, - "string-lifetimes-operations.ts": 3231, - "string-normalize.ts": 3407, - "string-pattern-replacement.ts": 3745, - "string-scan-fast-paths.ts": 3455, - "string-split-checked-separator.mjs": 3539, - "string-split-traversal.ts": 4073, - "structural-class-properties.ts": 3685, - "structured-text-boundaries.js": 4089, - "structured-text-storage.ts": 3938, - "switch-integer-dispatch.ts": 3542, - "symbol-checked-boundary/main.ts": 3823, - "symbol-class-fields.ts": 3105, - "symbol-class-fields/main.cjs": 3306, - "symbol-class-methods/main.ts": 3168, - "symbol-fields-deferred-factory.ts": 2465, - "symbol-fields-inferred.js": 2781, - "symbol-object-properties/main.js": 2729, - "synchronous-callback-lifetimes.ts": 3805, - "terminal-stream-properties.ts": 2859, - "text-codec-values/main.ts": 24961, - "text-codec-var.ts": 35233, - "text-encode-into-boundaries.ts": 2835, - "timers-clear-many.ts": 3438, - "tuple-and-string-search.ts": 3771, - "tuple-array-union.ts": 3450, - "tuple-callback-visitation.ts": 3975, - "tuple-forof-visitation.ts": 3491, - "typed-array-bulk-conversion.mjs": 5922, - "typed-array-byte-io.js": 9466, - "typed-array-checked-index.js": 3008, - "typed-array-constructor-alias.ts": 3321, - "typed-array-constructor-identity.js": 3143, - "typed-array-constructor-union.ts": 2529, - "typed-array-constructor-values.mjs": 3170, - "typed-array-dynamic-methods.js": 4053, - "typed-array-integer-widths.ts": 3519, - "typed-array-nan-coded-reads.ts": 3945, - "typed-array-numeric-import.ts": 4121, - "typed-array-present-reads.ts": 3332, - "typed-array-reversed-storage.ts": 2465, - "typed-array-unknown.ts": 3664, - "typed-collection-iterator-references.ts": 4059, - "typed-collection-iterators.ts": 4014, - "typed-collection-views/main.ts": 2915, - "typed-index-arguments.ts": 3055, - "typed-prototype-methods.ts": 3929, - "typed-rest-callables.ts": 2298, - "typed-rest-filtered-return.ts": 3531, - "typedarray-native-inputs.js": 3581, - "typeof-checked-comparison.js": 2656, - "uint8array-sort-domains.ts": 3223, - "unicode-case-paths.ts": 2409, - "unicode-process-argv.ts": 3053, - "union-discriminant-width.ts": 4248, - "union-literal-scalar-discriminants.ts": 4306, - "union-literal-slot-conversion.ts": 3424, - "union-nested-layout-discriminant.ts": 3343, - "union-optional-semantic-identity.ts": 4104, - "union-record-clone.ts": 3572, - "union-record-structural-copy.ts": 2990, - "union-reference-comparison.ts": 4026, - "unknown-array-holes.ts": 3098, - "unknown-collections.ts": 4172, - "unknown-object-enumeration.ts": 5046, - "unknown-record-views.ts": 2982, - "url-runtime-base.ts": 2879, - "utf8-span-decoding.ts": 37919, - "util-parseargs-wrapped/main.ts": 4014, - "virtual-runtime-optional-returns.ts": 4644, - "weak-map-array-buffer.ts": 3584, - "weak-map-fresh-array.js": 2803, - "weak-map-native.js": 3743, - "weak-native-class-identity.ts": 3008, - "weak-set-native.js": 2800, - "worker-class-instance-clone.ts": 39705 + "string-lifetimes-boundaries.ts": 3304, + "string-lifetimes-evaluation.ts": 2835, + "string-lifetimes-iteration.ts": 2037, + "string-lifetimes-operations.ts": 2789, + "string-normalize.ts": 2348, + "string-pattern-replacement.ts": 3823, + "string-scan-fast-paths.ts": 3224, + "string-split-checked-separator.mjs": 2349, + "string-split-traversal.ts": 3258, + "structural-class-properties.ts": 2627, + "structured-text-boundaries.js": 3452, + "structured-text-storage.ts": 3201, + "switch-integer-dispatch.ts": 2387, + "symbol-checked-boundary/main.ts": 2796, + "symbol-class-fields.ts": 2814, + "symbol-class-fields/main.cjs": 2659, + "symbol-class-methods/main.ts": 1948, + "symbol-fields-deferred-factory.ts": 2721, + "symbol-fields-inferred.js": 2792, + "symbol-object-properties/main.js": 3376, + "synchronous-callback-lifetimes.ts": 2872, + "terminal-stream-properties.ts": 2946, + "text-codec-values/main.ts": 18964, + "text-codec-var.ts": 3480, + "text-encode-into-boundaries.ts": 2224, + "timers-clear-many.ts": 3073, + "truthy-object-logical.ts": 4450, + "tuple-and-string-search.ts": 2595, + "tuple-array-union.ts": 3305, + "tuple-callback-visitation.ts": 3801, + "tuple-forof-visitation.ts": 3276, + "typed-array-bulk-conversion.mjs": 5346, + "typed-array-byte-io.js": 41314, + "typed-array-checked-index.js": 2607, + "typed-array-constructor-alias.ts": 2778, + "typed-array-constructor-identity.js": 2769, + "typed-array-constructor-union.ts": 2366, + "typed-array-constructor-values.mjs": 3448, + "typed-array-dynamic-methods.js": 3373, + "typed-array-integer-widths.ts": 3014, + "typed-array-nan-coded-reads.ts": 4239, + "typed-array-numeric-import.ts": 3499, + "typed-array-present-reads.ts": 3561, + "typed-array-reversed-storage.ts": 2954, + "typed-array-unknown.ts": 3453, + "typed-collection-iterator-references.ts": 3531, + "typed-collection-iterators.ts": 3385, + "typed-collection-views/main.ts": 2577, + "typed-index-arguments.ts": 3036, + "typed-prototype-methods.ts": 2475, + "typed-rest-callables.ts": 2463, + "typed-rest-filtered-return.ts": 2800, + "typedarray-native-inputs.js": 3164, + "typeof-checked-comparison.js": 2913, + "uint8array-sort-domains.ts": 2505, + "unicode-case-paths.ts": 2924, + "unicode-process-argv.ts": 2793, + "union-discriminant-width.ts": 3726, + "union-literal-scalar-discriminants.ts": 3704, + "union-literal-slot-conversion.ts": 2972, + "union-nested-layout-discriminant.ts": 2841, + "union-optional-semantic-identity.ts": 3100, + "union-record-clone.ts": 3480, + "union-record-structural-copy.ts": 3563, + "union-reference-comparison.ts": 3338, + "unknown-array-holes.ts": 2088, + "unknown-collections.ts": 3765, + "unknown-object-enumeration.ts": 4219, + "unknown-record-views.ts": 3040, + "url-runtime-base.ts": 2778, + "utf8-span-decoding.ts": 2655, + "util-parseargs-wrapped/main.ts": 2482, + "virtual-runtime-optional-returns.ts": 3876, + "weak-map-array-buffer.ts": 2826, + "weak-map-fresh-array.js": 2495, + "weak-map-native.js": 3627, + "weak-native-class-identity.ts": 2943, + "weak-set-native.js": 3056, + "worker-class-instance-clone.ts": 35222 } }