Skip to content

Fix BigInt Test262 compliance gaps#361

Merged
frostney merged 1 commit intomainfrom
t3code/fix-bigint-test262-compliance
Apr 20, 2026
Merged

Fix BigInt Test262 compliance gaps#361
frostney merged 1 commit intomainfrom
t3code/fix-bigint-test262-compliance

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 20, 2026

Summary

  • Tightened BigInt builtins to match Test262 and ES2026 expectations, including BigInt.prototype metadata and BigInt.asIntN/asUintN coercion behavior.
  • Added constructor checks for native functions so new BigInt() and other non-constructable natives now throw consistent TypeErrors in both interpreter and VM paths.
  • Improved Reflect.construct handling, including constructor detection and newTarget prototype behavior for native and class constructors.
  • Updated harness helpers so Test262 property and Temporal tests work more reliably in this runtime.
  • Fixed BigInteger conversion for large IEEE-754 integer values by routing through decimal-string parsing.

- align BigInt, Reflect.construct, and global property semantics with Test262 expectations
- add non-constructable native function support and BigInt conversion fixes
- expand harness helpers for constructor and subclassing cases
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 20, 2026

📝 Walkthrough

Walkthrough

This PR enhances ES2026 spec compliance by introducing a NotConstructable flag for native functions to prevent certain built-ins from being called with new, refactoring Reflect.construct validation logic, improving BigInt conversion and prototype handling, and updating global property definition semantics to use explicit descriptors.

Changes

Cohort / File(s) Summary
Test harness updates
scripts/test262_harness/isConstructor.js, scripts/test262_harness/propertyHelper.js, scripts/test262_harness/temporalHelpers.js, scripts/test262_harness/testTypedArray.js
Constructor validation shifted from error-message pattern matching to Reflect.construct; property helpers now fall back to globalThis for null/undefined targets; extensive new subclassing check helper methods added; BigInt typed array test comment clarified.
BigInteger implementation
source/shared/BigInteger.pas
FromDouble now formats doubles as base-10 decimal strings and delegates to FromDecimalString instead of extracting limbs via floating-point operations.
BigInt builtins
source/units/Goccia.Builtins.GlobalBigInt.pas
Added ToBigIntValue conversion helper implementing ES2026 ToBigInt semantics; reworked BigInt.prototype exposure via DefineProperty with explicit constructor/@@toStringTag; added NotConstructable checks; updated asIntN/asUintN registration flags.
Reflect and constructor semantics
source/units/Goccia.Builtins.GlobalReflect.pas, source/units/Goccia.Evaluator.pas, source/units/Goccia.VM.pas
Reflect.construct now uses unified IsConstructor predicate and branches handling for classes vs. native functions; new operator and ConstructValue VM method both enforce NotConstructable checks.
Native function representation
source/units/Goccia.Values.NativeFunction.pas, source/units/Goccia.ObjectModel.Types.pas, source/units/Goccia.ObjectModel.pas
Added NotConstructable boolean property to TGocciaNativeFunctionValue; introduced gmfNotConstructable member flag; propagate flag during native function creation from member definitions.
Global property definition
source/units/Goccia.Engine.pas, source/units/Goccia.Runtime.Bootstrap.pas
Global object properties and bindings now created via DefineProperty with explicit pfWritable/pfConfigurable descriptor flags instead of AssignProperty.
BigInt prototype methods
source/units/Goccia.Values.BigIntValue.pas
Prototype methods (BigIntToString, BigIntValueOf, BigIntToLocaleString) marked with gmfNotConstructable flag.

Sequence Diagram

sequenceDiagram
    participant Caller
    participant ReflectConstruct
    participant IsConstructorCheck
    participant ConstructLogic
    participant TargetType
    participant NewTargetType
    participant Instance
    participant Prototype

    Caller->>ReflectConstruct: Reflect.construct(target, args, newTarget?)
    ReflectConstruct->>IsConstructorCheck: Validate target is constructor
    alt target not constructor
        ReflectConstruct-->>Caller: TypeError
    end
    alt newTarget provided
        ReflectConstruct->>IsConstructorCheck: Validate newTarget is constructor
        alt newTarget not constructor
            ReflectConstruct-->>Caller: TypeError
        end
    end
    
    ReflectConstruct->>TargetType: Determine target type
    alt target is class
        TargetType->>ConstructLogic: ClassPath
        alt newTarget is class (different from target)
            ConstructLogic->>Instance: Instantiate with newTarget class
        else newTarget is native function
            ConstructLogic->>Instance: Instantiate with target class
            ConstructLogic->>NewTargetType: Get newTarget.[[prototype]]
            alt prototype is object
                ConstructLogic->>Prototype: Set instance prototype from newTarget
            end
        else no newTarget
            ConstructLogic->>Instance: Instantiate with target class
        end
    else target is native function
        TargetType->>ConstructLogic: NativeFunctionPath
        ConstructLogic->>Instance: Invoke target as constructor via Call
    end
    
    ConstructLogic->>Caller: Return instance
Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~35 minutes

Possibly related PRs

  • frostney/GocciaScript#241: Modifies Reflect.construct and instance prototype behavior during construction, directly overlapping with this PR's rework of the construct dispatch logic.
  • frostney/GocciaScript#234: Extends test262 harness utilities including constructor validation helpers, aligning with this PR's test harness improvements.
  • frostney/GocciaScript#136: Introduces or refactors member flags and registration infrastructure in TGocciaMemberFlag/ObjectModel.Types, which this PR extends with gmfNotConstructable.

Suggested labels

spec compliance, bug, internal

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Description check ⚠️ Warning The PR description covers all main objectives and implementation details. However, the Testing section is completely unchecked, showing no testing has been performed or documented despite the template requiring verification. Mark the Testing checkboxes as completed once verification is done, or document why testing was deferred. At minimum, confirm test runs with provided commands.
✅ Passed checks (2 passed)
Check name Status Explanation
Title check ✅ Passed The title 'Fix BigInt Test262 compliance gaps' directly addresses the main objective of the PR: improving BigInt builtins and related runtime functionality to match Test262 and ES2026 specifications.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

✏️ Tip: You can configure your own custom pre-merge checks in the settings.


Comment @coderabbitai help to get the list of available commands and usage tips.

@coderabbitai coderabbitai Bot added bug Something isn't working spec compliance Mismatch against official JavaScript/TypeScript specification internal Refactoring, CI, tooling, cleanup labels Apr 20, 2026
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

🧹 Nitpick comments (1)
source/units/Goccia.Builtins.GlobalBigInt.pas (1)

230-290: Well-implemented ToBigIntValue for ES2026 §7.1.13 ToBigInt.

The implementation correctly:

  • Applies ToPrimitive(argument, number) for objects
  • Returns BigInt primitives directly
  • Converts Boolean and String primitives appropriately
  • Throws TypeError for Number/undefined/null/symbol (as ToBigInt differs from BigInt() function)

The forward declaration pattern (line 231) works but is unnecessary in Pascal when the function appears before its only caller. Consider removing the forward declaration for clarity.

♻️ Optional: Remove redundant forward declaration
-// ES2026 §7.1.13 ToBigInt(argument) — forward declaration
-function ToBigIntValue(const AValue: TGocciaValue): TGocciaBigIntValue; forward;
-
 // ES2026 §7.1.13 ToBigInt — apply ToPrimitive then convert primitive to BigInt
 function ToBigIntValue(const AValue: TGocciaValue): TGocciaBigIntValue;
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.

In `@source/units/Goccia.Builtins.GlobalBigInt.pas` around lines 230 - 290, The
file contains an unnecessary forward declaration for function ToBigIntValue
(function ToBigIntValue(const AValue: TGocciaValue): TGocciaBigIntValue;
forward;) even though the actual implementation appears before any other
callers; remove that forward declaration line and any matching forward-only
prototype so the single implementation of ToBigIntValue remains, ensuring no
other references rely on the forward prototype.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/test262_harness/temporalHelpers.js`:
- Around line 399-407: The helper checkSubclassSpeciesThrows is missing a call
to resultAssertions(result), so after creating the instance, forcing
constructor[Symbol.species] to throw, invoking the method, and asserting the
result prototype with assert.sameValue(Object.getPrototypeOf(result),
construct.prototype), add a call to resultAssertions(result) to run the same
result validations other checkSubclass* helpers perform; update the function
checkSubclassSpeciesThrows (parameters construct, constructArgs, method,
methodArgs, resultAssertions) to invoke resultAssertions(result) immediately
after the prototype assertion.

---

Nitpick comments:
In `@source/units/Goccia.Builtins.GlobalBigInt.pas`:
- Around line 230-290: The file contains an unnecessary forward declaration for
function ToBigIntValue (function ToBigIntValue(const AValue: TGocciaValue):
TGocciaBigIntValue; forward;) even though the actual implementation appears
before any other callers; remove that forward declaration line and any matching
forward-only prototype so the single implementation of ToBigIntValue remains,
ensuring no other references rely on the forward prototype.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 95e22d8d-92c4-4439-8178-6d694938de99

📥 Commits

Reviewing files that changed from the base of the PR and between 24e56f7 and 6a95ac4.

📒 Files selected for processing (15)
  • scripts/test262_harness/isConstructor.js
  • scripts/test262_harness/propertyHelper.js
  • scripts/test262_harness/temporalHelpers.js
  • scripts/test262_harness/testTypedArray.js
  • source/shared/BigInteger.pas
  • source/units/Goccia.Builtins.GlobalBigInt.pas
  • source/units/Goccia.Builtins.GlobalReflect.pas
  • source/units/Goccia.Engine.pas
  • source/units/Goccia.Evaluator.pas
  • source/units/Goccia.ObjectModel.Types.pas
  • source/units/Goccia.ObjectModel.pas
  • source/units/Goccia.Runtime.Bootstrap.pas
  • source/units/Goccia.VM.pas
  • source/units/Goccia.Values.BigIntValue.pas
  • source/units/Goccia.Values.NativeFunction.pas

Comment thread scripts/test262_harness/temporalHelpers.js
@github-actions
Copy link
Copy Markdown
Contributor

Benchmark Results

386 benchmarks

Interpreted: 🟢 35 improved · 🔴 102 regressed · 249 unchanged · avg +0.1%
Bytecode: 🟢 19 improved · 🔴 320 regressed · 47 unchanged · avg -6.8%

arraybuffer.js — Interp: 🔴 2, 12 unch. · avg +0.1% · Bytecode: 🔴 9, 5 unch. · avg -5.2%
Benchmark Interpreted Δ Bytecode Δ
create ArrayBuffer(0) 211,272 ops/sec [184,086..214,186] → 211,173 ops/sec [174,896..213,613] ~ overlap (-0.0%) 237,900 ops/sec [190,038..253,166] → 232,614 ops/sec [227,184..234,161] ~ overlap (-2.2%)
create ArrayBuffer(64) 206,334 ops/sec [204,419..208,363] → 202,521 ops/sec [201,321..203,345] 🔴 -1.8% 224,097 ops/sec [182,577..240,570] → 222,307 ops/sec [219,926..222,863] ~ overlap (-0.8%)
create ArrayBuffer(1024) 172,484 ops/sec [168,792..174,877] → 173,313 ops/sec [172,418..174,441] ~ overlap (+0.5%) 189,136 ops/sec [185,520..189,875] → 186,221 ops/sec [185,692..187,884] ~ overlap (-1.5%)
create ArrayBuffer(8192) 80,623 ops/sec [45,582..88,972] → 87,773 ops/sec [84,982..89,526] ~ overlap (+8.9%) 86,317 ops/sec [84,350..87,862] → 92,259 ops/sec [67,030..94,225] ~ overlap (+6.9%)
slice full buffer (64 bytes) 232,655 ops/sec [228,615..234,481] → 231,616 ops/sec [229,210..234,219] ~ overlap (-0.4%) 289,341 ops/sec [287,393..291,685] → 271,416 ops/sec [266,125..273,519] 🔴 -6.2%
slice half buffer (512 of 1024 bytes) 204,957 ops/sec [200,800..207,028] → 202,824 ops/sec [202,238..204,766] ~ overlap (-1.0%) 250,713 ops/sec [246,685..255,421] → 237,794 ops/sec [237,347..238,334] 🔴 -5.2%
slice with negative indices 187,805 ops/sec [182,978..191,764] → 184,534 ops/sec [183,161..185,812] ~ overlap (-1.7%) 261,388 ops/sec [259,373..265,514] → 244,086 ops/sec [242,741..244,708] 🔴 -6.6%
slice empty range 220,097 ops/sec [216,590..222,361] → 214,077 ops/sec [208,763..217,921] ~ overlap (-2.7%) 276,844 ops/sec [270,270..280,035] → 255,871 ops/sec [254,335..256,551] 🔴 -7.6%
byteLength access 602,986 ops/sec [598,738..604,196] → 583,775 ops/sec [566,102..589,935] 🔴 -3.2% 790,786 ops/sec [775,279..796,591] → 713,277 ops/sec [709,893..717,553] 🔴 -9.8%
Symbol.toStringTag access 471,291 ops/sec [457,871..475,518] → 464,720 ops/sec [462,284..468,309] ~ overlap (-1.4%) 503,521 ops/sec [492,420..508,359] → 462,409 ops/sec [455,104..468,585] 🔴 -8.2%
ArrayBuffer.isView 327,273 ops/sec [325,421..328,197] → 330,647 ops/sec [326,479..332,339] ~ overlap (+1.0%) 389,668 ops/sec [387,225..393,834] → 355,807 ops/sec [354,235..357,825] 🔴 -8.7%
clone ArrayBuffer(64) 197,517 ops/sec [195,064..201,840] → 199,372 ops/sec [197,046..200,988] ~ overlap (+0.9%) 251,454 ops/sec [233,554..254,617] → 224,350 ops/sec [222,635..224,860] 🔴 -10.8%
clone ArrayBuffer(1024) 164,752 ops/sec [162,741..167,285] → 165,316 ops/sec [164,051..165,766] ~ overlap (+0.3%) 197,216 ops/sec [194,230..199,163] → 184,472 ops/sec [178,504..187,243] 🔴 -6.5%
clone ArrayBuffer inside object 133,901 ops/sec [132,101..134,864] → 136,476 ops/sec [134,213..138,089] ~ overlap (+1.9%) 155,429 ops/sec [144,114..162,187] → 145,531 ops/sec [145,225..146,830] ~ overlap (-6.4%)
arrays.js — Interp: 🟢 1, 🔴 5, 13 unch. · avg -1.2% · Bytecode: 🔴 19 · avg -8.9%
Benchmark Interpreted Δ Bytecode Δ
Array.from length 100 5,702 ops/sec [4,877..5,929] → 5,829 ops/sec [5,717..5,850] ~ overlap (+2.2%) 7,728 ops/sec [7,518..7,769] → 7,027 ops/sec [6,528..7,139] 🔴 -9.1%
Array.from 10 elements 101,787 ops/sec [101,146..102,467] → 101,077 ops/sec [100,097..101,657] ~ overlap (-0.7%) 111,025 ops/sec [107,647..111,854] → 98,407 ops/sec [97,936..98,831] 🔴 -11.4%
Array.of 10 elements 124,677 ops/sec [107,607..125,380] → 123,248 ops/sec [121,848..124,490] ~ overlap (-1.1%) 144,293 ops/sec [140,880..145,540] → 128,940 ops/sec [127,672..129,544] 🔴 -10.6%
spread into new array 160,717 ops/sec [158,834..163,619] → 152,381 ops/sec [148,803..157,220] 🔴 -5.2% 92,611 ops/sec [90,262..93,322] → 80,943 ops/sec [75,806..83,747] 🔴 -12.6%
map over 50 elements 10,132 ops/sec [9,971..10,215] → 10,027 ops/sec [9,871..10,041] ~ overlap (-1.0%) 14,555 ops/sec [14,380..14,606] → 13,254 ops/sec [11,898..13,516] 🔴 -8.9%
filter over 50 elements 9,354 ops/sec [9,146..9,374] → 9,274 ops/sec [9,136..9,315] ~ overlap (-0.9%) 14,252 ops/sec [14,126..14,366] → 13,100 ops/sec [12,971..13,225] 🔴 -8.1%
reduce sum 50 elements 10,994 ops/sec [10,935..11,035] → 10,586 ops/sec [10,395..10,609] 🔴 -3.7% 14,050 ops/sec [13,912..14,184] → 12,641 ops/sec [12,434..12,825] 🔴 -10.0%
forEach over 50 elements 9,432 ops/sec [9,335..9,533] → 9,767 ops/sec [9,468..9,823] ~ overlap (+3.6%) 13,598 ops/sec [13,112..13,836] → 12,207 ops/sec [12,085..12,342] 🔴 -10.2%
find in 50 elements 14,378 ops/sec [14,339..14,456] → 14,554 ops/sec [14,521..14,565] 🟢 +1.2% 20,813 ops/sec [20,703..20,881] → 18,758 ops/sec [18,644..19,254] 🔴 -9.9%
sort 20 elements 5,224 ops/sec [5,166..5,297] → 5,263 ops/sec [5,196..5,294] ~ overlap (+0.7%) 7,927 ops/sec [7,820..8,072] → 7,109 ops/sec [7,015..7,152] 🔴 -10.3%
flat nested array 55,919 ops/sec [55,750..56,122] → 55,010 ops/sec [54,412..56,502] ~ overlap (-1.6%) 62,328 ops/sec [61,943..62,822] → 55,276 ops/sec [54,803..56,017] 🔴 -11.3%
flatMap 34,729 ops/sec [34,386..35,015] → 33,459 ops/sec [32,882..34,150] 🔴 -3.7% 41,323 ops/sec [40,606..41,508] → 38,252 ops/sec [37,932..38,657] 🔴 -7.4%
map inside map (5x5) 9,315 ops/sec [9,236..9,337] → 9,056 ops/sec [8,924..9,143] 🔴 -2.8% 11,689 ops/sec [11,582..11,736] → 10,828 ops/sec [10,726..10,839] 🔴 -7.4%
filter inside map (5x10) 6,857 ops/sec [6,737..7,038] → 6,719 ops/sec [6,622..6,816] ~ overlap (-2.0%) 9,341 ops/sec [9,292..9,417] → 8,884 ops/sec [8,827..8,977] 🔴 -4.9%
reduce inside map (5x10) 8,322 ops/sec [8,143..8,448] → 8,020 ops/sec [7,913..8,097] 🔴 -3.6% 10,876 ops/sec [10,822..10,942] → 9,947 ops/sec [9,824..10,142] 🔴 -8.5%
forEach inside forEach (5x10) 6,939 ops/sec [6,782..7,004] → 7,006 ops/sec [6,861..7,036] ~ overlap (+1.0%) 10,667 ops/sec [10,624..10,720] → 9,861 ops/sec [9,585..9,986] 🔴 -7.6%
find inside some (10x10) 5,994 ops/sec [5,965..6,072] → 5,877 ops/sec [5,789..5,983] ~ overlap (-1.9%) 8,464 ops/sec [8,428..8,514] → 7,753 ops/sec [7,652..7,806] 🔴 -8.4%
map+filter chain nested (5x20) 2,187 ops/sec [2,149..2,208] → 2,136 ops/sec [2,112..2,158] ~ overlap (-2.3%) 3,166 ops/sec [3,159..3,173] → 2,970 ops/sec [2,947..2,993] 🔴 -6.2%
reduce flatten (10x5) 19,760 ops/sec [19,455..19,923] → 19,595 ops/sec [19,348..19,729] ~ overlap (-0.8%) 8,889 ops/sec [8,481..9,073] → 8,283 ops/sec [8,253..8,307] 🔴 -6.8%
async-await.js — Interp: 🔴 3, 3 unch. · avg +0.6% · Bytecode: 🔴 5, 1 unch. · avg -9.8%
Benchmark Interpreted Δ Bytecode Δ
single await 155,570 ops/sec [114,735..171,978] → 166,441 ops/sec [125,559..176,121] ~ overlap (+7.0%) 188,429 ops/sec [163,753..196,516] → 177,333 ops/sec [173,929..179,456] ~ overlap (-5.9%)
multiple awaits 79,452 ops/sec [78,965..80,358] → 77,679 ops/sec [77,239..78,001] 🔴 -2.2% 82,353 ops/sec [76,873..84,062] → 74,979 ops/sec [73,265..76,072] 🔴 -9.0%
await non-Promise value 378,249 ops/sec [376,987..384,776] → 372,951 ops/sec [372,307..373,703] 🔴 -1.4% 520,855 ops/sec [520,400..522,381] → 461,874 ops/sec [443,193..463,601] 🔴 -11.3%
await with try/catch 160,949 ops/sec [129,166..174,910] → 166,736 ops/sec [164,524..169,873] ~ overlap (+3.6%) 189,358 ops/sec [185,262..191,810] → 167,851 ops/sec [165,117..170,427] 🔴 -11.4%
await Promise.all 24,527 ops/sec [24,361..24,750] → 24,122 ops/sec [23,409..24,347] 🔴 -1.7% 26,159 ops/sec [26,138..26,169] → 22,942 ops/sec [19,573..23,313] 🔴 -12.3%
nested async function call 92,308 ops/sec [90,712..93,656] → 90,962 ops/sec [90,082..92,109] ~ overlap (-1.5%) 115,183 ops/sec [111,542..116,229] → 105,056 ops/sec [102,814..105,343] 🔴 -8.8%
base64.js — Interp: 10 unch. · avg -0.3% · Bytecode: 🔴 10 · avg -7.9%
Benchmark Interpreted Δ Bytecode Δ
short ASCII (13 chars) 6,639 ops/sec [4,757..6,773] → 6,647 ops/sec [6,479..6,710] ~ overlap (+0.1%) 7,357 ops/sec [7,242..7,412] → 6,626 ops/sec [6,448..6,678] 🔴 -9.9%
medium ASCII (450 chars) 268 ops/sec [265..272] → 269 ops/sec [266..272] ~ overlap (+0.3%) 287 ops/sec [268..300] → 263 ops/sec [259..264] 🔴 -8.4%
Latin-1 characters 7,007 ops/sec [4,973..7,214] → 7,222 ops/sec [6,941..7,471] ~ overlap (+3.1%) 7,715 ops/sec [7,629..7,918] → 6,937 ops/sec [6,814..7,042] 🔴 -10.1%
short base64 (20 chars) 3,097 ops/sec [3,017..3,187] → 3,107 ops/sec [3,082..3,198] ~ overlap (+0.3%) 3,368 ops/sec [3,339..3,477] → 3,103 ops/sec [2,982..3,168] 🔴 -7.9%
medium base64 (600 chars) 135 ops/sec [132..135] → 136 ops/sec [135..137] ~ overlap (+0.8%) 141 ops/sec [140..143] → 134 ops/sec [132..138] 🔴 -5.5%
Latin-1 output 4,459 ops/sec [4,401..4,511] → 4,468 ops/sec [4,447..4,488] ~ overlap (+0.2%) 4,798 ops/sec [4,777..4,811] → 4,463 ops/sec [4,427..4,502] 🔴 -7.0%
forgiving (no padding) 6,661 ops/sec [6,624..6,670] → 6,576 ops/sec [6,001..6,625] ~ overlap (-1.3%) 7,246 ops/sec [7,128..7,275] → 6,507 ops/sec [6,475..6,548] 🔴 -10.2%
with whitespace 2,845 ops/sec [2,762..2,880] → 2,756 ops/sec [2,745..2,815] ~ overlap (-3.1%) 3,012 ops/sec [2,956..3,032] → 2,819 ops/sec [2,809..2,832] 🔴 -6.4%
atob(btoa(short)) 2,143 ops/sec [2,121..2,153] → 2,132 ops/sec [2,110..2,141] ~ overlap (-0.5%) 2,335 ops/sec [2,296..2,377] → 2,194 ops/sec [2,180..2,198] 🔴 -6.0%
atob(btoa(medium)) 92 ops/sec [89..93] → 89 ops/sec [88..90] ~ overlap (-3.2%) 96 ops/sec [94..97] → 89 ops/sec [88..89] 🔴 -7.3%
classes.js — Interp: 🟢 1, 🔴 10, 20 unch. · avg -1.2% · Bytecode: 🔴 13, 18 unch. · avg -4.7%
Benchmark Interpreted Δ Bytecode Δ
simple class new 69,338 ops/sec [69,191..69,826] → 68,511 ops/sec [68,214..68,859] 🔴 -1.2% 100,649 ops/sec [99,378..101,321] → 92,954 ops/sec [92,749..93,418] 🔴 -7.6%
class with defaults 53,733 ops/sec [53,122..53,887] → 54,991 ops/sec [54,409..56,297] 🟢 +2.3% 68,068 ops/sec [66,855..68,191] → 62,292 ops/sec [61,652..63,396] 🔴 -8.5%
50 instances via Array.from 2,741 ops/sec [2,703..2,760] → 2,668 ops/sec [2,652..2,673] 🔴 -2.7% 4,035 ops/sec [3,953..4,142] → 3,790 ops/sec [3,767..3,822] 🔴 -6.1%
instance method call 33,561 ops/sec [33,204..34,028] → 33,780 ops/sec [33,557..34,307] ~ overlap (+0.7%) 47,366 ops/sec [46,941..47,807] → 44,566 ops/sec [44,214..45,500] 🔴 -5.9%
static method call 54,489 ops/sec [53,604..54,853] → 53,342 ops/sec [52,627..54,664] ~ overlap (-2.1%) 93,014 ops/sec [77,178..95,139] → 86,676 ops/sec [85,317..87,832] ~ overlap (-6.8%)
single-level inheritance 27,905 ops/sec [27,682..28,380] → 27,402 ops/sec [27,233..27,475] 🔴 -1.8% 36,739 ops/sec [32,755..37,314] → 33,514 ops/sec [33,197..33,940] ~ overlap (-8.8%)
two-level inheritance 24,703 ops/sec [24,582..24,788] → 23,963 ops/sec [23,160..24,006] 🔴 -3.0% 29,842 ops/sec [27,820..30,421] → 27,617 ops/sec [27,263..28,124] ~ overlap (-7.5%)
private field access 35,848 ops/sec [35,533..36,563] → 36,470 ops/sec [35,375..36,662] ~ overlap (+1.7%) 49,856 ops/sec [49,158..50,213] → 45,958 ops/sec [45,377..46,290] 🔴 -7.8%
private methods 39,449 ops/sec [39,223..39,851] → 40,078 ops/sec [39,834..40,373] ~ overlap (+1.6%) 52,754 ops/sec [52,263..53,389] → 49,637 ops/sec [49,135..49,961] 🔴 -5.9%
getter/setter access 37,673 ops/sec [36,926..37,897] → 37,271 ops/sec [36,555..37,519] ~ overlap (-1.1%) 54,513 ops/sec [51,245..56,796] → 51,506 ops/sec [51,329..51,878] ~ overlap (-5.5%)
class decorator (identity) 48,066 ops/sec [47,677..48,482] → 46,777 ops/sec [46,191..47,790] ~ overlap (-2.7%) 55,299 ops/sec [54,810..56,624] → 52,277 ops/sec [51,882..52,859] 🔴 -5.5%
class decorator (wrapping) 28,707 ops/sec [28,327..29,181] → 28,365 ops/sec [27,716..28,937] ~ overlap (-1.2%) 30,826 ops/sec [30,408..31,052] → 28,945 ops/sec [28,811..29,084] 🔴 -6.1%
identity method decorator 34,144 ops/sec [33,738..34,925] → 34,008 ops/sec [33,831..34,077] ~ overlap (-0.4%) 46,853 ops/sec [45,266..49,158] → 45,312 ops/sec [43,614..46,328] ~ overlap (-3.3%)
wrapping method decorator 27,784 ops/sec [26,466..28,162] → 27,755 ops/sec [27,172..28,437] ~ overlap (-0.1%) 33,345 ops/sec [32,252..33,936] → 32,009 ops/sec [31,152..32,708] ~ overlap (-4.0%)
stacked method decorators (x3) 18,567 ops/sec [18,247..18,642] → 18,309 ops/sec [17,185..18,792] ~ overlap (-1.4%) 23,020 ops/sec [22,171..23,668] → 22,350 ops/sec [21,735..22,946] ~ overlap (-2.9%)
identity field decorator 37,526 ops/sec [37,167..38,501] → 37,473 ops/sec [36,724..38,084] ~ overlap (-0.1%) 41,143 ops/sec [39,752..42,164] → 38,729 ops/sec [37,983..39,391] 🔴 -5.9%
field initializer decorator 32,072 ops/sec [31,351..32,374] → 31,597 ops/sec [30,701..32,217] ~ overlap (-1.5%) 34,813 ops/sec [33,873..35,594] → 34,324 ops/sec [33,804..34,709] ~ overlap (-1.4%)
getter decorator (identity) 35,785 ops/sec [35,533..36,305] → 34,364 ops/sec [33,802..34,696] 🔴 -4.0% 40,760 ops/sec [40,287..41,292] → 39,194 ops/sec [39,104..39,239] 🔴 -3.8%
setter decorator (identity) 29,532 ops/sec [29,419..29,746] → 29,251 ops/sec [28,784..29,455] ~ overlap (-1.0%) 33,843 ops/sec [33,314..34,226] → 31,800 ops/sec [31,655..31,925] 🔴 -6.0%
static method decorator 37,464 ops/sec [37,203..38,037] → 37,173 ops/sec [36,675..37,442] ~ overlap (-0.8%) 46,974 ops/sec [46,246..48,256] → 46,034 ops/sec [44,614..46,721] ~ overlap (-2.0%)
static field decorator 43,752 ops/sec [43,196..44,615] → 43,381 ops/sec [43,040..44,854] ~ overlap (-0.8%) 48,476 ops/sec [46,517..51,083] → 45,910 ops/sec [44,069..46,558] ~ overlap (-5.3%)
private method decorator 29,006 ops/sec [28,566..29,863] → 28,184 ops/sec [26,022..28,497] 🔴 -2.8% 39,005 ops/sec [36,604..40,853] → 37,072 ops/sec [36,495..37,776] ~ overlap (-5.0%)
private field decorator 31,966 ops/sec [31,653..32,242] → 31,231 ops/sec [30,828..31,505] 🔴 -2.3% 34,541 ops/sec [33,593..36,006] → 35,150 ops/sec [32,946..36,807] ~ overlap (+1.8%)
plain auto-accessor (no decorator) 54,768 ops/sec [54,303..57,316] → 54,033 ops/sec [52,809..57,116] ~ overlap (-1.3%) 52,073 ops/sec [50,970..53,414] → 51,107 ops/sec [49,487..53,894] ~ overlap (-1.9%)
auto-accessor with decorator 30,443 ops/sec [30,323..31,867] → 30,149 ops/sec [29,631..31,060] ~ overlap (-1.0%) 31,609 ops/sec [31,051..33,232] → 29,968 ops/sec [29,074..31,223] ~ overlap (-5.2%)
decorator writing metadata 24,732 ops/sec [24,526..25,092] → 24,355 ops/sec [23,911..24,784] ~ overlap (-1.5%) 27,272 ops/sec [26,947..28,508] → 25,819 ops/sec [25,667..25,965] 🔴 -5.3%
static getter read 69,459 ops/sec [68,717..70,999] → 69,425 ops/sec [68,799..69,976] ~ overlap (-0.1%) 92,063 ops/sec [90,256..93,786] → 88,602 ops/sec [88,230..89,260] 🔴 -3.8%
static getter/setter pair 53,239 ops/sec [52,982..53,476] → 52,808 ops/sec [51,901..53,057] ~ overlap (-0.8%) 67,160 ops/sec [62,970..67,975] → 63,302 ops/sec [62,512..64,333] ~ overlap (-5.7%)
inherited static getter 42,950 ops/sec [42,888..43,146] → 41,753 ops/sec [39,549..42,379] 🔴 -2.8% 51,271 ops/sec [50,664..52,009] → 51,507 ops/sec [50,996..51,911] ~ overlap (+0.5%)
inherited static setter 46,492 ops/sec [46,113..47,493] → 44,826 ops/sec [44,540..45,310] 🔴 -3.6% 54,994 ops/sec [54,689..55,106] → 54,132 ops/sec [53,960..54,945] ~ overlap (-1.6%)
inherited static getter with this binding 39,297 ops/sec [38,884..39,395] → 38,337 ops/sec [37,979..38,536] 🔴 -2.4% 46,763 ops/sec [46,040..47,493] → 46,067 ops/sec [45,524..46,226] ~ overlap (-1.5%)
closures.js — Interp: 🔴 2, 9 unch. · avg -0.4% · Bytecode: 🔴 11 · avg -8.6%
Benchmark Interpreted Δ Bytecode Δ
closure over single variable 63,339 ops/sec [62,811..63,635] → 61,863 ops/sec [60,726..62,082] 🔴 -2.3% 148,083 ops/sec [147,547..148,864] → 134,114 ops/sec [132,593..134,856] 🔴 -9.4%
closure over multiple variables 58,310 ops/sec [56,428..59,158] → 57,570 ops/sec [55,961..58,330] ~ overlap (-1.3%) 139,409 ops/sec [132,026..144,857] → 129,288 ops/sec [127,787..129,482] 🔴 -7.3%
nested closures 63,478 ops/sec [63,301..63,543] → 63,943 ops/sec [63,537..65,074] ~ overlap (+0.7%) 142,568 ops/sec [138,358..145,736] → 132,058 ops/sec [129,537..132,656] 🔴 -7.4%
function as argument 44,211 ops/sec [43,395..44,710] → 45,014 ops/sec [44,683..45,521] ~ overlap (+1.8%) 145,931 ops/sec [142,533..146,736] → 132,620 ops/sec [132,414..132,961] 🔴 -9.1%
function returning function 57,739 ops/sec [57,629..58,133] → 57,366 ops/sec [56,784..57,702] ~ overlap (-0.6%) 164,502 ops/sec [160,138..168,316] → 150,424 ops/sec [149,411..151,237] 🔴 -8.6%
compose two functions 34,596 ops/sec [32,197..35,608] → 33,876 ops/sec [33,757..34,147] ~ overlap (-2.1%) 92,063 ops/sec [90,467..94,342] → 85,598 ops/sec [85,176..86,866] 🔴 -7.0%
fn.call 74,539 ops/sec [73,791..76,545] → 74,588 ops/sec [74,478..74,989] ~ overlap (+0.1%) 101,787 ops/sec [98,210..104,624] → 93,605 ops/sec [92,024..95,642] 🔴 -8.0%
fn.apply 56,645 ops/sec [55,539..57,620] → 56,579 ops/sec [55,784..57,040] ~ overlap (-0.1%) 99,627 ops/sec [98,839..102,479] → 92,166 ops/sec [91,410..92,598] 🔴 -7.5%
fn.bind 69,680 ops/sec [69,138..70,015] → 71,454 ops/sec [69,814..72,027] ~ overlap (+2.5%) 179,910 ops/sec [175,145..182,978] → 163,280 ops/sec [162,150..164,949] 🔴 -9.2%
recursive sum to 50 5,274 ops/sec [5,092..5,288] → 5,287 ops/sec [5,068..5,346] ~ overlap (+0.2%) 17,952 ops/sec [17,818..18,544] → 15,915 ops/sec [15,847..15,945] 🔴 -11.3%
recursive tree traversal 10,568 ops/sec [10,465..10,637] → 10,234 ops/sec [9,982..10,362] 🔴 -3.2% 20,130 ops/sec [19,480..20,985] → 18,263 ops/sec [18,193..18,339] 🔴 -9.3%
collections.js — Interp: 🟢 2, 🔴 1, 9 unch. · avg +0.1% · Bytecode: 🔴 12 · avg -11.4%
Benchmark Interpreted Δ Bytecode Δ
add 50 elements 3,410 ops/sec [3,375..3,459] → 3,495 ops/sec [3,474..3,497] 🟢 +2.5% 4,051 ops/sec [4,025..4,071] → 3,622 ops/sec [3,601..3,690] 🔴 -10.6%
has lookup (50 elements) 44,647 ops/sec [44,179..44,755] → 45,719 ops/sec [45,204..45,828] 🟢 +2.4% 55,346 ops/sec [55,131..55,554] → 49,248 ops/sec [48,173..49,524] 🔴 -11.0%
delete elements 24,399 ops/sec [23,867..24,504] → 24,792 ops/sec [24,316..25,042] ~ overlap (+1.6%) 28,531 ops/sec [28,140..28,766] → 25,489 ops/sec [25,284..25,634] 🔴 -10.7%
forEach iteration 7,295 ops/sec [7,166..7,310] → 7,102 ops/sec [7,015..7,156] 🔴 -2.6% 9,635 ops/sec [9,494..9,841] → 8,493 ops/sec [8,338..8,581] 🔴 -11.9%
spread to array 16,624 ops/sec [16,470..16,766] → 16,546 ops/sec [16,083..16,912] ~ overlap (-0.5%) 120,529 ops/sec [118,396..123,226] → 108,773 ops/sec [108,141..109,588] 🔴 -9.8%
deduplicate array 21,589 ops/sec [21,361..21,858] → 21,584 ops/sec [21,272..21,882] ~ overlap (-0.0%) 40,271 ops/sec [40,120..40,380] → 35,223 ops/sec [35,124..35,924] 🔴 -12.5%
set 50 entries 2,716 ops/sec [2,637..2,739] → 2,646 ops/sec [2,637..2,662] ~ overlap (-2.6%) 3,025 ops/sec [3,003..3,041] → 2,701 ops/sec [2,646..2,728] 🔴 -10.7%
get lookup (50 entries) 43,282 ops/sec [42,750..44,086] → 43,678 ops/sec [43,042..44,083] ~ overlap (+0.9%) 50,091 ops/sec [49,863..50,409] → 43,551 ops/sec [43,351..43,696] 🔴 -13.1%
has check 64,098 ops/sec [63,345..64,586] → 64,014 ops/sec [61,512..65,643] ~ overlap (-0.1%) 75,346 ops/sec [75,135..75,892] → 66,498 ops/sec [65,848..66,800] 🔴 -11.7%
delete entries 23,701 ops/sec [23,565..23,825] → 23,529 ops/sec [23,229..23,617] ~ overlap (-0.7%) 26,627 ops/sec [26,479..26,863] → 23,436 ops/sec [22,169..24,131] 🔴 -12.0%
forEach iteration 6,999 ops/sec [6,973..7,038] → 7,030 ops/sec [6,992..7,051] ~ overlap (+0.4%) 9,739 ops/sec [9,685..9,786] → 8,493 ops/sec [8,410..8,544] 🔴 -12.8%
keys/values/entries 4,519 ops/sec [4,429..4,575] → 4,511 ops/sec [4,485..4,535] ~ overlap (-0.2%) 15,860 ops/sec [15,375..16,007] → 14,255 ops/sec [14,238..14,406] 🔴 -10.1%
csv.js — Interp: 🔴 3, 10 unch. · avg -0.7% · Bytecode: 🔴 13 · avg -8.7%
Benchmark Interpreted Δ Bytecode Δ
parse simple 3-column CSV 51,696 ops/sec [51,483..51,823] → 50,097 ops/sec [49,445..50,331] 🔴 -3.1% 55,628 ops/sec [55,450..55,830] → 51,114 ops/sec [50,669..51,634] 🔴 -8.1%
parse 10-row CSV 14,004 ops/sec [13,661..14,157] → 13,587 ops/sec [13,399..13,802] ~ overlap (-3.0%) 15,379 ops/sec [15,227..15,867] → 14,265 ops/sec [13,978..14,507] 🔴 -7.2%
parse 100-row CSV 2,172 ops/sec [2,166..2,190] → 2,174 ops/sec [2,120..2,188] ~ overlap (+0.1%) 2,401 ops/sec [2,376..2,416] → 2,208 ops/sec [2,200..2,224] 🔴 -8.1%
parse CSV with quoted fields 74,017 ops/sec [72,710..77,741] → 74,333 ops/sec [73,691..74,703] ~ overlap (+0.4%) 81,935 ops/sec [81,750..82,330] → 73,930 ops/sec [73,416..74,390] 🔴 -9.8%
parse without headers (array of arrays) 5,831 ops/sec [5,792..5,876] → 5,719 ops/sec [5,675..5,747] 🔴 -1.9% 6,526 ops/sec [6,308..6,609] → 5,859 ops/sec [5,772..5,885] 🔴 -10.2%
parse with semicolon delimiter 9,903 ops/sec [9,835..9,931] → 9,687 ops/sec [9,593..9,784] 🔴 -2.2% 10,669 ops/sec [10,633..10,732] → 10,140 ops/sec [10,091..10,159] 🔴 -5.0%
stringify array of objects 71,031 ops/sec [70,664..72,645] → 71,813 ops/sec [71,047..73,499] ~ overlap (+1.1%) 84,038 ops/sec [83,194..86,308] → 77,360 ops/sec [76,930..77,898] 🔴 -7.9%
stringify array of arrays 24,738 ops/sec [24,523..25,012] → 25,221 ops/sec [24,981..25,418] ~ overlap (+2.0%) 28,595 ops/sec [27,852..29,476] → 26,028 ops/sec [25,900..26,142] 🔴 -9.0%
stringify with values needing escaping 52,131 ops/sec [51,850..52,574] → 52,510 ops/sec [52,325..54,064] ~ overlap (+0.7%) 62,943 ops/sec [60,838..63,344] → 55,208 ops/sec [54,916..55,593] 🔴 -12.3%
reviver converts numbers 1,500 ops/sec [1,493..1,524] → 1,508 ops/sec [1,466..1,526] ~ overlap (+0.5%) 1,744 ops/sec [1,699..1,759] → 1,614 ops/sec [1,596..1,627] 🔴 -7.4%
reviver filters empty to null 13,969 ops/sec [13,831..14,201] → 13,819 ops/sec [13,804..13,884] ~ overlap (-1.1%) 15,666 ops/sec [15,533..15,832] → 14,342 ops/sec [14,296..14,368] 🔴 -8.5%
parse then stringify 8,612 ops/sec [8,463..8,651] → 8,435 ops/sec [8,318..8,474] ~ overlap (-2.1%) 9,819 ops/sec [9,391..9,986] → 8,692 ops/sec [8,637..8,734] 🔴 -11.5%
stringify then parse 8,280 ops/sec [8,066..8,567] → 8,209 ops/sec [8,148..8,323] ~ overlap (-0.9%) 9,315 ops/sec [9,180..9,526] → 8,506 ops/sec [8,464..8,521] 🔴 -8.7%
destructuring.js — Interp: 🔴 7, 15 unch. · avg -1.3% · Bytecode: 🔴 22 · avg -7.7%
Benchmark Interpreted Δ Bytecode Δ
simple array destructuring 201,038 ops/sec [198,422..202,061] → 200,944 ops/sec [196,036..201,163] ~ overlap (-0.0%) 135,755 ops/sec [132,905..139,543] → 123,345 ops/sec [121,484..126,670] 🔴 -9.1%
with rest element 129,207 ops/sec [126,708..131,704] → 130,045 ops/sec [128,815..130,755] ~ overlap (+0.6%) 102,956 ops/sec [100,228..106,895] → 93,890 ops/sec [89,550..94,688] 🔴 -8.8%
with defaults 205,185 ops/sec [203,580..207,186] → 201,779 ops/sec [195,517..202,176] 🔴 -1.7% 161,299 ops/sec [157,687..168,249] → 144,197 ops/sec [141,637..146,429] 🔴 -10.6%
skip elements 217,548 ops/sec [215,731..219,448] → 207,317 ops/sec [206,055..213,098] 🔴 -4.7% 146,521 ops/sec [145,038..147,940] → 135,053 ops/sec [132,389..137,434] 🔴 -7.8%
nested array destructuring 95,220 ops/sec [94,813..95,967] → 94,770 ops/sec [93,614..95,022] ~ overlap (-0.5%) 49,844 ops/sec [49,130..50,647] → 45,543 ops/sec [44,223..46,784] 🔴 -8.6%
swap variables 265,824 ops/sec [264,191..267,687] → 269,274 ops/sec [262,910..272,125] ~ overlap (+1.3%) 184,489 ops/sec [182,819..185,783] → 164,881 ops/sec [163,490..166,958] 🔴 -10.6%
simple object destructuring 166,718 ops/sec [164,508..169,022] → 168,971 ops/sec [164,522..170,278] ~ overlap (+1.4%) 190,386 ops/sec [189,992..191,181] → 173,621 ops/sec [169,941..176,473] 🔴 -8.8%
with defaults 188,795 ops/sec [186,471..190,874] → 187,429 ops/sec [183,708..191,551] ~ overlap (-0.7%) 259,164 ops/sec [257,768..259,634] → 234,873 ops/sec [230,322..239,134] 🔴 -9.4%
with renaming 180,495 ops/sec [179,182..180,951] → 175,587 ops/sec [167,266..181,159] ~ overlap (-2.7%) 190,583 ops/sec [188,629..193,926] → 179,709 ops/sec [176,004..182,259] 🔴 -5.7%
nested object destructuring 86,481 ops/sec [85,553..87,451] → 84,340 ops/sec [81,502..85,598] ~ overlap (-2.5%) 93,964 ops/sec [91,939..94,784] → 87,369 ops/sec [86,063..88,469] 🔴 -7.0%
rest properties 105,432 ops/sec [105,056..107,635] → 102,702 ops/sec [101,566..104,147] 🔴 -2.6% 89,796 ops/sec [89,308..90,876] → 83,760 ops/sec [83,320..85,571] 🔴 -6.7%
object parameter 51,273 ops/sec [51,034..51,672] → 51,448 ops/sec [49,836..52,411] ~ overlap (+0.3%) 74,149 ops/sec [70,095..75,520] → 68,610 ops/sec [67,276..69,442] 🔴 -7.5%
array parameter 64,558 ops/sec [64,286..64,848] → 63,128 ops/sec [62,224..63,821] 🔴 -2.2% 67,387 ops/sec [66,571..68,269] → 63,175 ops/sec [62,528..63,737] 🔴 -6.3%
mixed destructuring in map 15,512 ops/sec [14,903..15,636] → 15,666 ops/sec [15,256..15,910] ~ overlap (+1.0%) 20,804 ops/sec [20,374..20,898] → 19,593 ops/sec [19,579..19,619] 🔴 -5.8%
forEach with array destructuring 33,271 ops/sec [32,662..33,423] → 32,572 ops/sec [32,077..32,683] ~ overlap (-2.1%) 26,039 ops/sec [25,563..26,358] → 24,131 ops/sec [23,076..24,396] 🔴 -7.3%
map with array destructuring 33,575 ops/sec [32,986..33,953] → 33,537 ops/sec [33,232..33,723] ~ overlap (-0.1%) 24,658 ops/sec [24,495..24,892] → 23,112 ops/sec [22,923..23,276] 🔴 -6.3%
filter with array destructuring 35,544 ops/sec [35,195..36,473] → 34,252 ops/sec [33,172..34,586] 🔴 -3.6% 27,157 ops/sec [26,688..27,582] → 24,812 ops/sec [24,232..25,078] 🔴 -8.6%
reduce with array destructuring 38,236 ops/sec [37,308..39,003] → 37,230 ops/sec [37,036..37,661] ~ overlap (-2.6%) 27,282 ops/sec [26,777..27,757] → 25,322 ops/sec [25,072..25,615] 🔴 -7.2%
map with object destructuring 35,143 ops/sec [34,656..35,194] → 34,987 ops/sec [34,280..35,151] ~ overlap (-0.4%) 47,202 ops/sec [45,872..48,322] → 44,203 ops/sec [43,387..45,079] 🔴 -6.4%
map with nested destructuring 28,723 ops/sec [28,643..28,860] → 28,345 ops/sec [27,815..28,640] 🔴 -1.3% 42,377 ops/sec [42,102..43,019] → 39,893 ops/sec [38,835..40,154] 🔴 -5.9%
map with rest in destructuring 21,638 ops/sec [20,969..21,823] → 21,387 ops/sec [21,130..21,616] ~ overlap (-1.2%) 14,403 ops/sec [14,262..14,827] → 13,368 ops/sec [13,153..13,682] 🔴 -7.2%
map with defaults in destructuring 27,575 ops/sec [27,342..27,674] → 26,643 ops/sec [26,400..26,845] 🔴 -3.4% 35,426 ops/sec [35,234..35,795] → 32,858 ops/sec [32,639..33,125] 🔴 -7.2%
fibonacci.js — Interp: 🟢 1, 7 unch. · avg -0.7% · Bytecode: 🔴 8 · avg -7.0%
Benchmark Interpreted Δ Bytecode Δ
recursive fib(15) 136 ops/sec [131..144] → 137 ops/sec [135..139] ~ overlap (+0.4%) 501 ops/sec [495..508] → 450 ops/sec [446..452] 🔴 -10.1%
recursive fib(20) 12 ops/sec [12..13] → 12 ops/sec [12..12] ~ overlap (-1.3%) 46 ops/sec [45..46] → 41 ops/sec [41..41] 🔴 -10.7%
recursive fib(15) typed 140 ops/sec [138..145] → 137 ops/sec [135..149] ~ overlap (-2.1%) 389 ops/sec [379..399] → 376 ops/sec [373..378] 🔴 -3.2%
recursive fib(20) typed 13 ops/sec [12..13] → 12 ops/sec [12..13] ~ overlap (-0.9%) 35 ops/sec [35..36] → 34 ops/sec [34..35] 🔴 -2.4%
iterative fib(20) via reduce 6,489 ops/sec [6,354..6,593] → 6,248 ops/sec [6,195..6,400] ~ overlap (-3.7%) 10,817 ops/sec [10,786..10,877] → 9,789 ops/sec [9,674..9,967] 🔴 -9.5%
iterator fib(20) 4,977 ops/sec [4,972..4,990] → 5,024 ops/sec [4,995..5,068] 🟢 +0.9% 8,695 ops/sec [8,650..8,856] → 8,055 ops/sec [7,942..8,176] 🔴 -7.4%
iterator fib(20) via Iterator.from + take 7,746 ops/sec [7,635..7,975] → 7,910 ops/sec [7,799..7,930] ~ overlap (+2.1%) 10,093 ops/sec [9,773..10,226] → 9,478 ops/sec [9,240..9,527] 🔴 -6.1%
iterator fib(20) last value via reduce 5,904 ops/sec [5,746..6,093] → 5,846 ops/sec [5,777..5,919] ~ overlap (-1.0%) 7,272 ops/sec [7,038..7,409] → 6,766 ops/sec [6,645..6,808] 🔴 -6.9%
float16array.js — Interp: 🟢 3, 🔴 5, 24 unch. · avg +0.0% · Bytecode: 🟢 4, 🔴 26, 2 unch. · avg -4.9%
Benchmark Interpreted Δ Bytecode Δ
new Float16Array(0) 172,231 ops/sec [169,900..173,734] → 168,576 ops/sec [163,639..171,433] ~ overlap (-2.1%) 190,910 ops/sec [189,712..199,709] → 182,782 ops/sec [179,480..183,882] 🔴 -4.3%
new Float16Array(100) 162,622 ops/sec [156,645..164,468] → 158,482 ops/sec [155,128..160,518] ~ overlap (-2.5%) 187,051 ops/sec [185,968..189,637] → 170,273 ops/sec [167,978..172,601] 🔴 -9.0%
new Float16Array(1000) 132,041 ops/sec [130,227..133,838] → 130,384 ops/sec [128,138..131,606] ~ overlap (-1.3%) 142,555 ops/sec [139,618..145,950] → 140,939 ops/sec [134,745..143,878] ~ overlap (-1.1%)
Float16Array.from([...100]) 91,293 ops/sec [90,785..91,936] → 94,527 ops/sec [93,301..95,184] 🟢 +3.5% 104,322 ops/sec [102,752..105,086] → 98,737 ops/sec [98,215..99,672] 🔴 -5.4%
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5) 155,116 ops/sec [154,506..156,364] → 152,593 ops/sec [151,803..153,292] 🔴 -1.6% 126,101 ops/sec [125,099..126,602] → 116,616 ops/sec [113,353..118,678] 🔴 -7.5%
new Float16Array(float64Array) 104,584 ops/sec [103,882..105,829] → 100,464 ops/sec [98,693..101,386] 🔴 -3.9% 120,649 ops/sec [118,172..121,680] → 104,690 ops/sec [102,302..105,409] 🔴 -13.2%
sequential write 100 elements 1,659 ops/sec [1,639..1,695] → 1,689 ops/sec [1,657..1,709] ~ overlap (+1.8%) 3,909 ops/sec [3,871..3,941] → 3,555 ops/sec [3,471..3,574] 🔴 -9.1%
sequential read 100 elements 1,914 ops/sec [1,910..1,918] → 1,931 ops/sec [1,899..1,949] ~ overlap (+0.9%) 5,977 ops/sec [5,864..6,015] → 5,281 ops/sec [5,218..5,328] 🔴 -11.6%
write special values (NaN, Inf, -0) 100,132 ops/sec [99,704..100,506] → 95,243 ops/sec [92,870..98,140] 🔴 -4.9% 139,338 ops/sec [138,552..139,876] → 120,580 ops/sec [119,489..122,102] 🔴 -13.5%
Float16Array write 1,712 ops/sec [1,679..1,742] → 1,700 ops/sec [1,666..1,715] ~ overlap (-0.7%) 3,782 ops/sec [3,646..3,928] → 3,539 ops/sec [3,430..3,602] 🔴 -6.4%
Float32Array write 1,649 ops/sec [1,638..1,668] → 1,736 ops/sec [1,708..1,771] 🟢 +5.3% 3,905 ops/sec [3,876..3,940] → 3,543 ops/sec [3,499..3,610] 🔴 -9.3%
Float64Array write 1,705 ops/sec [1,688..1,732] → 1,724 ops/sec [1,666..1,747] ~ overlap (+1.1%) 3,935 ops/sec [3,929..3,950] → 3,579 ops/sec [3,509..3,604] 🔴 -9.0%
Float16Array read 1,826 ops/sec [1,799..1,838] → 1,865 ops/sec [1,829..1,894] ~ overlap (+2.2%) 5,302 ops/sec [5,124..5,449] → 5,104 ops/sec [5,100..5,108] 🔴 -3.7%
Float32Array read 1,880 ops/sec [1,843..1,884] → 1,805 ops/sec [1,793..1,913] ~ overlap (-4.0%) 5,999 ops/sec [5,912..6,204] → 5,432 ops/sec [5,415..5,446] 🔴 -9.4%
Float64Array read 1,891 ops/sec [1,875..1,911] → 1,874 ops/sec [1,824..1,925] ~ overlap (-0.9%) 5,926 ops/sec [5,839..6,148] → 5,439 ops/sec [5,392..5,486] 🔴 -8.2%
fill(1.5) 22,188 ops/sec [22,066..22,232] → 23,367 ops/sec [23,208..23,396] 🟢 +5.3% 24,119 ops/sec [23,930..24,429] → 22,609 ops/sec [22,382..22,762] 🔴 -6.3%
slice() 95,040 ops/sec [92,261..95,663] → 94,807 ops/sec [94,054..96,137] ~ overlap (-0.2%) 101,208 ops/sec [99,485..102,014] → 98,957 ops/sec [98,004..100,115] ~ overlap (-2.2%)
map(x => x * 2) 3,470 ops/sec [3,442..3,514] → 3,478 ops/sec [3,423..3,513] ~ overlap (+0.2%) 4,436 ops/sec [4,411..4,488] → 3,825 ops/sec [3,771..3,844] 🔴 -13.8%
filter(x => x > 25) 3,774 ops/sec [3,632..3,805] → 3,739 ops/sec [3,733..3,784] ~ overlap (-0.9%) 4,737 ops/sec [4,684..4,749] → 4,298 ops/sec [4,169..4,345] 🔴 -9.3%
reduce (sum) 3,486 ops/sec [3,475..3,509] → 3,515 ops/sec [3,465..3,589] ~ overlap (+0.8%) 3,890 ops/sec [3,700..3,976] → 3,643 ops/sec [3,592..3,669] 🔴 -6.3%
sort() 21,330 ops/sec [21,104..21,472] → 21,233 ops/sec [21,149..21,498] ~ overlap (-0.5%) 18,064 ops/sec [17,972..18,202] → 21,491 ops/sec [21,374..21,637] 🟢 +19.0%
indexOf() 117,629 ops/sec [117,125..118,961] → 118,827 ops/sec [114,365..120,272] ~ overlap (+1.0%) 115,021 ops/sec [114,902..116,534] → 130,123 ops/sec [129,518..131,119] 🟢 +13.1%
reverse() 120,648 ops/sec [119,478..121,440] → 121,986 ops/sec [120,643..126,122] ~ overlap (+1.1%) 138,875 ops/sec [137,885..139,761] → 133,175 ops/sec [131,386..133,333] 🔴 -4.1%
toReversed() 57,728 ops/sec [56,960..58,209] → 57,751 ops/sec [56,694..58,458] ~ overlap (+0.0%) 54,069 ops/sec [53,537..54,743] → 60,108 ops/sec [59,131..61,181] 🟢 +11.2%
toSorted() 818 ops/sec [812..823] → 816 ops/sec [812..827] ~ overlap (-0.2%) 688 ops/sec [682..693] → 822 ops/sec [817..825] 🟢 +19.6%
create view over existing buffer 198,321 ops/sec [195,717..203,724] → 197,952 ops/sec [195,762..200,894] ~ overlap (-0.2%) 236,342 ops/sec [230,822..242,558] → 213,773 ops/sec [209,461..217,228] 🔴 -9.5%
subarray() 223,130 ops/sec [222,526..225,358] → 219,311 ops/sec [215,857..222,544] ~ overlap (-1.7%) 291,524 ops/sec [290,618..293,149] → 264,064 ops/sec [257,616..265,810] 🔴 -9.4%
set() from array 267,218 ops/sec [263,964..268,015] → 260,250 ops/sec [255,560..262,957] 🔴 -2.6% 313,217 ops/sec [312,296..317,601] → 282,247 ops/sec [277,329..286,764] 🔴 -9.9%
for-of loop 2,599 ops/sec [2,581..2,617] → 2,655 ops/sec [2,603..2,685] ~ overlap (+2.1%) 8,220 ops/sec [8,191..8,409] → 7,540 ops/sec [7,393..7,647] 🔴 -8.3%
spread into array 9,750 ops/sec [9,720..9,834] → 9,647 ops/sec [9,612..9,665] 🔴 -1.1% 47,113 ops/sec [46,020..47,492] → 44,309 ops/sec [43,788..44,649] 🔴 -6.0%
f16round(1.337) 324,857 ops/sec [316,223..335,901] → 331,643 ops/sec [330,893..335,687] ~ overlap (+2.1%) 310,448 ops/sec [308,450..312,629] → 290,819 ops/sec [289,044..292,653] 🔴 -6.3%
f16round over 100 values 1,774 ops/sec [1,738..1,843] → 1,807 ops/sec [1,768..1,842] ~ overlap (+1.9%) 3,706 ops/sec [3,673..3,743] → 3,418 ops/sec [3,382..3,500] 🔴 -7.8%
for-of.js — Interp: 🔴 2, 5 unch. · avg -1.2% · Bytecode: 🔴 7 · avg -10.0%
Benchmark Interpreted Δ Bytecode Δ
for...of with 10-element array 24,319 ops/sec [24,037..24,636] → 23,946 ops/sec [23,452..24,161] ~ overlap (-1.5%) 104,715 ops/sec [103,081..105,827] → 92,560 ops/sec [91,791..93,238] 🔴 -11.6%
for...of with 100-element array 2,734 ops/sec [2,699..2,754] → 2,758 ops/sec [2,719..2,791] ~ overlap (+0.9%) 12,272 ops/sec [12,226..12,312] → 10,832 ops/sec [10,792..10,959] 🔴 -11.7%
for...of with string (10 chars) 18,146 ops/sec [17,824..18,243] → 17,833 ops/sec [17,762..17,919] ~ overlap (-1.7%) 39,124 ops/sec [38,577..39,565] → 36,916 ops/sec [36,629..37,091] 🔴 -5.6%
for...of with Set (10 elements) 24,238 ops/sec [23,866..24,423] → 23,772 ops/sec [23,347..23,862] 🔴 -1.9% 98,749 ops/sec [97,084..99,065] → 86,994 ops/sec [86,541..88,118] 🔴 -11.9%
for...of with Map entries (10 entries) 15,688 ops/sec [15,454..15,773] → 15,405 ops/sec [15,246..15,481] ~ overlap (-1.8%) 17,821 ops/sec [17,436..18,002] → 16,285 ops/sec [16,151..16,463] 🔴 -8.6%
for...of with destructuring 20,212 ops/sec [19,769..20,448] → 20,150 ops/sec [19,754..20,241] ~ overlap (-0.3%) 23,326 ops/sec [23,022..23,577] → 21,150 ops/sec [20,897..22,030] 🔴 -9.3%
for-await-of with sync array 23,205 ops/sec [23,089..23,729] → 22,733 ops/sec [22,014..22,859] 🔴 -2.0% 72,343 ops/sec [71,262..74,079] → 64,302 ops/sec [63,227..66,573] 🔴 -11.1%
helpers/bench-module.js — Interp: 0 · Bytecode: 0
Benchmark Interpreted Δ Bytecode Δ
iterators.js — Interp: 🟢 7, 🔴 8, 27 unch. · avg -0.1% · Bytecode: 🔴 40, 2 unch. · avg -8.5%
Benchmark Interpreted Δ Bytecode Δ
Iterator.from({next}).toArray() — 20 elements 7,902 ops/sec [7,780..7,940] → 7,872 ops/sec [7,789..7,937] ~ overlap (-0.4%) 10,308 ops/sec [10,284..10,494] → 9,450 ops/sec [9,359..9,638] 🔴 -8.3%
Iterator.from({next}).toArray() — 50 elements 3,415 ops/sec [3,370..3,444] → 3,392 ops/sec [3,351..3,445] ~ overlap (-0.7%) 4,593 ops/sec [4,562..4,644] → 4,201 ops/sec [4,171..4,233] 🔴 -8.5%
spread pre-wrapped iterator — 20 elements 6,089 ops/sec [6,027..6,140] → 6,028 ops/sec [5,993..6,044] ~ overlap (-1.0%) 10,112 ops/sec [10,044..10,228] → 9,401 ops/sec [9,246..9,465] 🔴 -7.0%
Iterator.from({next}).forEach — 50 elements 2,256 ops/sec [2,187..2,266] → 2,219 ops/sec [2,188..2,269] ~ overlap (-1.6%) 3,125 ops/sec [3,114..3,173] → 2,824 ops/sec [2,812..2,840] 🔴 -9.6%
Iterator.from({next}).reduce — 50 elements 2,280 ops/sec [2,274..2,306] → 2,245 ops/sec [2,207..2,283] ~ overlap (-1.6%) 3,040 ops/sec [3,028..3,057] → 2,744 ops/sec [2,695..2,779] 🔴 -9.7%
wrap array iterator 83,081 ops/sec [82,224..83,701] → 81,053 ops/sec [80,320..82,434] ~ overlap (-2.4%) 95,479 ops/sec [94,096..96,391] → 84,237 ops/sec [83,869..85,683] 🔴 -11.8%
wrap plain {next()} object 5,430 ops/sec [5,411..5,449] → 5,457 ops/sec [5,424..5,481] ~ overlap (+0.5%) 7,271 ops/sec [7,237..7,332] → 6,578 ops/sec [6,435..6,725] 🔴 -9.5%
map + toArray (50 elements) 2,293 ops/sec [2,288..2,295] → 2,213 ops/sec [2,194..2,231] 🔴 -3.5% 3,170 ops/sec [3,144..3,179] → 2,894 ops/sec [2,866..2,927] 🔴 -8.7%
filter + toArray (50 elements) 2,257 ops/sec [2,245..2,272] → 2,209 ops/sec [2,189..2,240] 🔴 -2.1% 3,213 ops/sec [3,191..3,263] → 2,817 ops/sec [2,762..2,884] 🔴 -12.3%
take(10) + toArray (50 element source) 14,408 ops/sec [14,325..14,490] → 14,356 ops/sec [14,194..14,445] ~ overlap (-0.4%) 18,926 ops/sec [18,689..19,189] → 17,475 ops/sec [16,600..17,547] 🔴 -7.7%
drop(40) + toArray (50 element source) 3,394 ops/sec [3,375..3,414] → 3,377 ops/sec [3,373..3,426] ~ overlap (-0.5%) 4,599 ops/sec [4,575..4,632] → 4,190 ops/sec [4,101..4,245] 🔴 -8.9%
chained map + filter + take (100 element source) 4,044 ops/sec [4,029..4,051] → 4,134 ops/sec [4,086..4,154] 🟢 +2.2% 5,654 ops/sec [5,608..5,706] → 5,100 ops/sec [5,017..5,151] 🔴 -9.8%
some + every (50 elements) 1,315 ops/sec [1,308..1,321] → 1,385 ops/sec [1,357..1,412] 🟢 +5.3% 1,851 ops/sec [1,841..1,857] → 1,659 ops/sec [1,648..1,667] 🔴 -10.4%
find (50 elements) 2,950 ops/sec [2,908..2,978] → 3,019 ops/sec [2,990..3,040] 🟢 +2.4% 3,965 ops/sec [3,936..4,009] → 3,587 ops/sec [3,558..3,613] 🔴 -9.5%
concat 2 arrays (10 + 10 elements) 81,703 ops/sec [80,540..82,481] → 85,274 ops/sec [85,031..85,428] 🟢 +4.4% 92,777 ops/sec [91,021..93,189] → 83,139 ops/sec [82,478..85,173] 🔴 -10.4%
concat 5 arrays (10 elements each) 49,213 ops/sec [48,834..49,421] → 53,495 ops/sec [51,793..54,034] 🟢 +8.7% 55,743 ops/sec [55,097..56,722] → 51,486 ops/sec [50,489..52,534] 🔴 -7.6%
concat 2 arrays (20 + 20 elements) 72,010 ops/sec [71,021..72,973] → 72,492 ops/sec [69,674..72,672] ~ overlap (+0.7%) 81,596 ops/sec [80,609..81,771] → 73,929 ops/sec [73,401..74,458] 🔴 -9.4%
concat + filter + toArray (20 + 20 elements) 7,560 ops/sec [7,484..7,614] → 7,428 ops/sec [7,353..7,440] 🔴 -1.8% 10,956 ops/sec [10,685..11,117] → 10,492 ops/sec [10,438..10,514] 🔴 -4.2%
concat + map + take (20 + 20 elements, take 10) 22,827 ops/sec [22,578..23,275] → 22,819 ops/sec [22,190..23,159] ~ overlap (-0.0%) 30,716 ops/sec [30,233..30,830] → 29,274 ops/sec [28,979..29,387] 🔴 -4.7%
concat Sets (15 + 15 elements) 73,750 ops/sec [72,927..74,031] → 73,364 ops/sec [71,950..74,644] ~ overlap (-0.5%) 81,527 ops/sec [79,635..82,317] → 77,578 ops/sec [77,371..78,282] 🔴 -4.8%
concat strings (13 + 13 characters) 52,726 ops/sec [51,731..53,083] → 52,138 ops/sec [51,361..53,160] ~ overlap (-1.1%) 57,710 ops/sec [56,925..58,196] → 54,029 ops/sec [53,273..54,436] 🔴 -6.4%
zip 2 arrays (10 + 10 elements) 30,787 ops/sec [30,194..31,043] → 30,532 ops/sec [30,178..31,114] ~ overlap (-0.8%) 33,933 ops/sec [33,696..34,116] → 31,679 ops/sec [31,389..32,031] 🔴 -6.6%
zip 3 arrays (10 elements each) 28,313 ops/sec [28,095..28,570] → 28,796 ops/sec [28,338..29,455] ~ overlap (+1.7%) 31,271 ops/sec [30,778..31,915] → 29,755 ops/sec [29,476..29,934] 🔴 -4.9%
zip 2 arrays (20 + 20 elements) 20,618 ops/sec [19,904..20,899] → 20,618 ops/sec [20,304..20,874] ~ overlap (-0.0%) 22,131 ops/sec [21,508..22,707] → 21,172 ops/sec [21,135..21,393] 🔴 -4.3%
zip 2 arrays (50 + 50 elements) 10,095 ops/sec [9,728..10,259] → 10,357 ops/sec [10,164..10,498] ~ overlap (+2.6%) 11,293 ops/sec [11,142..11,467] → 10,675 ops/sec [10,587..10,696] 🔴 -5.5%
zip shortest mode (20 + 10 elements) 31,194 ops/sec [30,800..31,308] → 30,629 ops/sec [30,226..30,887] ~ overlap (-1.8%) 33,637 ops/sec [33,580..34,048] → 32,040 ops/sec [31,786..32,346] 🔴 -4.7%
zip longest mode (10 + 20 elements) 18,068 ops/sec [17,635..18,173] → 18,132 ops/sec [17,781..18,325] ~ overlap (+0.4%) 20,419 ops/sec [20,374..20,538] → 18,713 ops/sec [18,677..18,853] 🔴 -8.4%
zip strict mode (20 + 20 elements) 19,741 ops/sec [19,596..19,956] → 19,450 ops/sec [19,176..19,894] ~ overlap (-1.5%) 21,758 ops/sec [19,474..22,032] → 19,815 ops/sec [19,259..20,193] ~ overlap (-8.9%)
zip + map + toArray (20 + 20 elements) 8,754 ops/sec [8,726..8,808] → 8,762 ops/sec [8,689..8,989] ~ overlap (+0.1%) 6,474 ops/sec [6,417..6,508] → 6,012 ops/sec [5,998..6,023] 🔴 -7.1%
zip + filter + toArray (20 + 20 elements) 8,574 ops/sec [8,305..8,664] → 8,304 ops/sec [8,023..8,425] ~ overlap (-3.2%) 6,599 ops/sec [6,472..6,642] → 6,118 ops/sec [6,069..6,254] 🔴 -7.3%
zip Sets (15 + 15 elements) 25,070 ops/sec [24,883..25,081] → 24,643 ops/sec [24,016..24,783] 🔴 -1.7% 26,516 ops/sec [26,244..26,663] → 24,370 ops/sec [24,081..24,468] 🔴 -8.1%
zipKeyed 2 keys (10 elements each) 30,732 ops/sec [30,329..30,991] → 29,824 ops/sec [29,002..30,009] 🔴 -3.0% 32,991 ops/sec [32,612..33,300] → 31,198 ops/sec [30,854..31,447] 🔴 -5.4%
zipKeyed 3 keys (20 elements each) 15,498 ops/sec [15,317..15,636] → 15,021 ops/sec [14,707..15,129] 🔴 -3.1% 16,715 ops/sec [16,559..16,837] → 15,511 ops/sec [15,382..15,745] 🔴 -7.2%
zipKeyed longest mode (10 + 20 elements) 17,394 ops/sec [17,205..17,494] → 16,973 ops/sec [16,836..17,164] 🔴 -2.4% 18,476 ops/sec [18,354..18,589] → 17,837 ops/sec [17,584..17,939] 🔴 -3.5%
zipKeyed strict mode (20 + 20 elements) 18,416 ops/sec [18,328..18,540] → 17,978 ops/sec [17,921..18,095] 🔴 -2.4% 19,586 ops/sec [18,922..19,757] → 18,714 ops/sec [18,526..18,878] 🔴 -4.5%
zipKeyed + filter + map (20 elements) 6,225 ops/sec [6,150..6,295] → 6,193 ops/sec [6,077..6,259] ~ overlap (-0.5%) 8,725 ops/sec [8,550..8,835] → 7,187 ops/sec [7,120..7,220] 🔴 -17.6%
array.values().map().filter().toArray() 3,746 ops/sec [3,564..3,811] → 3,774 ops/sec [3,531..3,801] ~ overlap (+0.7%) 5,637 ops/sec [5,612..5,697] → 4,643 ops/sec [4,559..4,667] 🔴 -17.6%
array.values().take(5).toArray() 110,765 ops/sec [110,606..111,006] → 112,952 ops/sec [111,384..113,151] 🟢 +2.0% 140,080 ops/sec [139,480..145,096] → 120,536 ops/sec [118,921..121,745] 🔴 -14.0%
array.values().drop(45).toArray() 104,020 ops/sec [102,661..104,510] → 102,819 ops/sec [102,619..104,232] ~ overlap (-1.2%) 131,361 ops/sec [129,708..133,770] → 115,437 ops/sec [113,008..119,551] 🔴 -12.1%
map.entries() chained helpers 5,002 ops/sec [4,892..5,179] → 5,126 ops/sec [5,063..5,208] ~ overlap (+2.5%) 3,622 ops/sec [3,333..3,790] → 3,173 ops/sec [3,080..3,203] 🔴 -12.4%
set.values() chained helpers 7,801 ops/sec [7,704..7,822] → 8,067 ops/sec [8,039..8,191] 🟢 +3.4% 11,379 ops/sec [11,063..11,607] → 10,303 ops/sec [10,098..10,505] 🔴 -9.5%
string iterator map + toArray 7,206 ops/sec [6,992..7,357] → 7,098 ops/sec [7,028..7,144] ~ overlap (-1.5%) 7,942 ops/sec [6,913..8,039] → 7,411 ops/sec [7,344..7,485] ~ overlap (-6.7%)
json.js — Interp: 🔴 7, 13 unch. · avg -2.2% · Bytecode: 🔴 19, 1 unch. · avg -10.2%
Benchmark Interpreted Δ Bytecode Δ
parse simple object 75,719 ops/sec [73,667..76,010] → 74,270 ops/sec [73,507..75,267] ~ overlap (-1.9%) 80,998 ops/sec [77,168..81,549] → 74,722 ops/sec [74,468..74,852] 🔴 -7.7%
parse nested object 51,853 ops/sec [49,849..52,779] → 49,609 ops/sec [49,318..50,359] ~ overlap (-4.3%) 53,656 ops/sec [52,680..54,040] → 50,401 ops/sec [50,040..50,517] 🔴 -6.1%
parse array of objects 30,598 ops/sec [30,048..30,971] → 29,446 ops/sec [29,053..29,792] 🔴 -3.8% 31,682 ops/sec [31,380..31,889] → 29,333 ops/sec [28,814..29,584] 🔴 -7.4%
parse large flat object 32,362 ops/sec [32,178..32,544] → 31,687 ops/sec [30,824..32,035] 🔴 -2.1% 35,276 ops/sec [35,108..35,409] → 31,164 ops/sec [31,119..31,230] 🔴 -11.7%
parse mixed types 38,870 ops/sec [38,360..39,238] → 35,719 ops/sec [35,504..35,907] 🔴 -8.1% 38,393 ops/sec [37,940..38,918] → 35,828 ops/sec [35,693..36,130] 🔴 -6.7%
stringify simple object 84,194 ops/sec [83,298..88,039] → 82,809 ops/sec [81,601..83,557] ~ overlap (-1.6%) 84,369 ops/sec [83,096..85,900] → 78,506 ops/sec [78,248..78,837] 🔴 -6.9%
stringify nested object 47,657 ops/sec [45,827..48,856] → 47,746 ops/sec [47,375..48,157] ~ overlap (+0.2%) 49,334 ops/sec [48,006..52,869] → 42,919 ops/sec [42,497..43,169] 🔴 -13.0%
stringify array of objects 19,355 ops/sec [19,107..19,881] → 19,632 ops/sec [19,190..19,763] ~ overlap (+1.4%) 25,230 ops/sec [24,911..25,357] → 19,421 ops/sec [19,148..19,720] 🔴 -23.0%
stringify mixed types 36,083 ops/sec [35,479..38,415] → 36,595 ops/sec [35,416..36,810] ~ overlap (+1.4%) 38,324 ops/sec [38,201..38,439] → 32,793 ops/sec [32,289..33,322] 🔴 -14.4%
reviver doubles numbers 18,438 ops/sec [18,183..18,909] → 17,897 ops/sec [17,405..18,195] ~ overlap (-2.9%) 20,702 ops/sec [19,991..21,499] → 17,742 ops/sec [17,611..17,984] 🔴 -14.3%
reviver filters properties 17,217 ops/sec [17,208..17,374] → 16,642 ops/sec [16,379..16,787] 🔴 -3.3% 19,128 ops/sec [18,978..19,239] → 16,033 ops/sec [15,929..16,210] 🔴 -16.2%
reviver on nested object 21,691 ops/sec [21,300..22,274] → 20,301 ops/sec [19,901..20,407] 🔴 -6.4% 21,486 ops/sec [21,241..21,598] → 19,644 ops/sec [19,461..19,678] 🔴 -8.6%
reviver on array 10,924 ops/sec [10,740..10,981] → 10,832 ops/sec [10,669..10,891] ~ overlap (-0.8%) 11,527 ops/sec [10,955..11,984] → 10,985 ops/sec [10,494..11,118] ~ overlap (-4.7%)
replacer function doubles numbers 21,635 ops/sec [21,373..21,900] → 21,194 ops/sec [20,975..21,587] ~ overlap (-2.0%) 23,688 ops/sec [23,230..23,935] → 22,055 ops/sec [21,796..22,114] 🔴 -6.9%
replacer function excludes properties 29,587 ops/sec [29,409..29,944] → 29,036 ops/sec [28,960..29,168] 🔴 -1.9% 28,684 ops/sec [27,869..28,988] → 26,528 ops/sec [26,294..26,894] 🔴 -7.5%
array replacer (allowlist) 52,095 ops/sec [50,793..52,326] → 51,687 ops/sec [51,511..51,747] ~ overlap (-0.8%) 51,802 ops/sec [51,120..52,653] → 47,362 ops/sec [46,066..47,495] 🔴 -8.6%
stringify with 2-space indent 40,884 ops/sec [40,585..41,659] → 40,992 ops/sec [40,805..41,602] ~ overlap (+0.3%) 43,922 ops/sec [43,616..44,497] → 40,049 ops/sec [39,805..40,437] 🔴 -8.8%
stringify with tab indent 41,668 ops/sec [41,021..42,382] → 41,602 ops/sec [40,553..42,021] ~ overlap (-0.2%) 43,793 ops/sec [43,395..44,627] → 38,692 ops/sec [38,496..39,156] 🔴 -11.6%
parse then stringify 24,743 ops/sec [24,162..24,866] → 23,787 ops/sec [23,293..24,182] ~ overlap (-3.9%) 26,910 ops/sec [26,897..27,002] → 24,441 ops/sec [24,156..24,569] 🔴 -9.2%
stringify then parse 14,431 ops/sec [14,018..14,634] → 13,825 ops/sec [13,566..13,958] 🔴 -4.2% 15,901 ops/sec [15,413..16,171] → 14,063 ops/sec [14,005..14,134] 🔴 -11.6%
jsx.jsx — Interp: 🟢 3, 🔴 5, 13 unch. · avg -0.9% · Bytecode: 🔴 18, 3 unch. · avg -7.2%
Benchmark Interpreted Δ Bytecode Δ
simple element 115,405 ops/sec [113,249..115,941] → 111,960 ops/sec [110,805..115,767] ~ overlap (-3.0%) 160,639 ops/sec [155,906..161,720] → 145,166 ops/sec [143,135..146,436] 🔴 -9.6%
self-closing element 120,210 ops/sec [119,196..121,560] → 124,821 ops/sec [123,785..125,070] 🟢 +3.8% 180,238 ops/sec [175,504..182,854] → 162,506 ops/sec [158,268..164,269] 🔴 -9.8%
element with string attribute 98,391 ops/sec [97,425..99,470] → 100,108 ops/sec [100,014..100,353] 🟢 +1.7% 128,070 ops/sec [123,944..129,419] → 120,788 ops/sec [117,980..121,452] 🔴 -5.7%
element with multiple attributes 86,527 ops/sec [85,615..87,472] → 86,350 ops/sec [85,414..87,241] ~ overlap (-0.2%) 98,974 ops/sec [97,585..100,918] → 90,881 ops/sec [90,541..91,551] 🔴 -8.2%
element with expression attribute 92,807 ops/sec [90,825..93,484] → 91,831 ops/sec [90,741..92,065] ~ overlap (-1.1%) 131,135 ops/sec [129,593..135,114] → 119,748 ops/sec [118,202..121,797] 🔴 -8.7%
text child 117,874 ops/sec [117,065..120,550] → 117,791 ops/sec [110,940..121,675] ~ overlap (-0.1%) 159,183 ops/sec [158,466..161,433] → 144,713 ops/sec [143,540..147,238] 🔴 -9.1%
expression child 113,169 ops/sec [110,049..115,719] → 111,857 ops/sec [109,553..114,683] ~ overlap (-1.2%) 159,083 ops/sec [155,404..161,581] → 146,340 ops/sec [144,914..147,318] 🔴 -8.0%
mixed text and expression 106,815 ops/sec [106,102..108,886] → 104,710 ops/sec [103,364..105,541] 🔴 -2.0% 138,432 ops/sec [134,592..141,447] → 132,317 ops/sec [128,404..134,683] ~ overlap (-4.4%)
nested elements (3 levels) 44,466 ops/sec [43,766..45,198] → 42,653 ops/sec [41,351..43,331] 🔴 -4.1% 59,921 ops/sec [59,253..60,570] → 55,855 ops/sec [55,635..56,824] 🔴 -6.8%
sibling children 32,679 ops/sec [32,545..32,814] → 31,413 ops/sec [30,906..32,041] 🔴 -3.9% 43,556 ops/sec [42,261..43,722] → 40,563 ops/sec [40,144..41,124] 🔴 -6.9%
component element 84,533 ops/sec [83,975..85,017] → 82,138 ops/sec [81,335..82,669] 🔴 -2.8% 114,344 ops/sec [112,648..117,061] → 115,013 ops/sec [113,589..116,038] ~ overlap (+0.6%)
component with children 53,305 ops/sec [51,537..53,573] → 50,460 ops/sec [49,885..50,586] 🔴 -5.3% 68,040 ops/sec [66,985..69,054] → 62,818 ops/sec [61,955..68,401] ~ overlap (-7.7%)
dotted component 72,139 ops/sec [71,189..72,988] → 71,898 ops/sec [71,130..72,389] ~ overlap (-0.3%) 87,805 ops/sec [87,564..89,703] → 81,259 ops/sec [80,715..82,462] 🔴 -7.5%
empty fragment 121,570 ops/sec [120,133..122,874] → 122,658 ops/sec [121,515..123,034] ~ overlap (+0.9%) 192,948 ops/sec [188,774..198,089] → 177,207 ops/sec [176,277..178,335] 🔴 -8.2%
fragment with children 33,559 ops/sec [32,762..33,912] → 32,711 ops/sec [32,386..33,056] ~ overlap (-2.5%) 43,914 ops/sec [42,181..44,112] → 40,306 ops/sec [39,820..41,058] 🔴 -8.2%
spread attributes 60,716 ops/sec [60,185..64,183] → 61,244 ops/sec [60,935..61,473] ~ overlap (+0.9%) 67,740 ops/sec [66,812..68,260] → 62,880 ops/sec [61,567..63,083] 🔴 -7.2%
spread with overrides 54,374 ops/sec [53,384..55,009] → 54,574 ops/sec [53,859..54,841] ~ overlap (+0.4%) 59,399 ops/sec [57,812..60,394] → 55,119 ops/sec [54,792..55,585] 🔴 -7.2%
shorthand props 90,981 ops/sec [89,397..91,701] → 92,232 ops/sec [92,073..92,945] 🟢 +1.4% 114,339 ops/sec [111,380..116,653] → 106,466 ops/sec [105,477..107,664] 🔴 -6.9%
nav bar structure 15,636 ops/sec [15,537..15,776] → 15,744 ops/sec [15,703..15,827] ~ overlap (+0.7%) 19,602 ops/sec [18,977..20,143] → 18,335 ops/sec [18,242..18,480] 🔴 -6.5%
card component tree 18,287 ops/sec [17,934..18,424] → 18,012 ops/sec [17,675..18,038] ~ overlap (-1.5%) 22,125 ops/sec [21,706..22,494] → 20,369 ops/sec [20,154..20,442] 🔴 -7.9%
10 list items via Array.from 8,323 ops/sec [8,190..8,441] → 8,177 ops/sec [8,127..8,229] ~ overlap (-1.7%) 9,625 ops/sec [9,530..9,646] → 8,812 ops/sec [8,653..8,943] 🔴 -8.4%
modules.js — Interp: 🔴 5, 4 unch. · avg -1.9% · Bytecode: 🔴 9 · avg -13.0%
Benchmark Interpreted Δ Bytecode Δ
call imported function 217,259 ops/sec [215,736..219,403] → 206,557 ops/sec [199,056..213,090] 🔴 -4.9% 748,615 ops/sec [727,911..761,317] → 670,363 ops/sec [663,764..672,578] 🔴 -10.5%
call two imported functions 119,884 ops/sec [118,265..120,112] → 117,317 ops/sec [115,803..117,592] 🔴 -2.1% 453,772 ops/sec [452,442..454,177] → 406,281 ops/sec [404,969..411,238] 🔴 -10.5%
read imported constant 737,649 ops/sec [725,724..752,840] → 718,308 ops/sec [709,391..732,011] ~ overlap (-2.6%) 2,275,395 ops/sec [2,252,405..2,341,464] → 2,011,061 ops/sec [1,975,074..2,021,731] 🔴 -11.6%
read imported string 768,379 ops/sec [763,651..771,377] → 740,306 ops/sec [728,716..746,132] 🔴 -3.7% 2,272,582 ops/sec [2,247,918..2,327,908] → 1,976,867 ops/sec [1,974,132..1,986,343] 🔴 -13.0%
read JSON string property 774,666 ops/sec [771,785..776,777] → 749,402 ops/sec [733,435..757,515] 🔴 -3.3% 2,316,387 ops/sec [2,267,966..2,329,215] → 1,985,480 ops/sec [1,962,988..1,991,229] 🔴 -14.3%
read JSON number property 769,063 ops/sec [758,983..772,667] → 736,161 ops/sec [727,717..740,582] 🔴 -4.3% 2,318,510 ops/sec [2,307,021..2,329,006] → 1,981,439 ops/sec [1,963,821..1,984,064] 🔴 -14.5%
read JSON boolean property 746,968 ops/sec [744,678..772,651] → 750,088 ops/sec [741,159..756,558] ~ overlap (+0.4%) 2,285,335 ops/sec [2,271,171..2,327,057] → 1,979,057 ops/sec [1,968,135..1,985,693] 🔴 -13.4%
read JSON array property 749,837 ops/sec [745,187..758,579] → 749,104 ops/sec [739,163..758,933] ~ overlap (-0.1%) 2,327,760 ops/sec [2,314,318..2,337,438] → 1,981,475 ops/sec [1,958,511..1,984,229] 🔴 -14.9%
read multiple JSON properties 407,753 ops/sec [405,180..418,393] → 420,299 ops/sec [398,905..422,660] ~ overlap (+3.1%) 1,886,383 ops/sec [1,871,093..1,892,753] → 1,616,844 ops/sec [1,585,378..1,626,370] 🔴 -14.3%
numbers.js — Interp: 🔴 3, 8 unch. · avg -2.2% · Bytecode: 🟢 2, 🔴 9 · avg -3.1%
Benchmark Interpreted Δ Bytecode Δ
integer arithmetic 226,469 ops/sec [220,842..228,517] → 220,961 ops/sec [215,858..223,324] ~ overlap (-2.4%) 609,250 ops/sec [607,663..616,276] → 689,404 ops/sec [677,222..695,957] 🟢 +13.2%
floating point arithmetic 258,710 ops/sec [257,557..260,713] → 259,575 ops/sec [258,158..269,148] ~ overlap (+0.3%) 384,758 ops/sec [369,076..390,709] → 413,671 ops/sec [409,996..415,604] 🟢 +7.5%
number coercion 82,092 ops/sec [79,880..83,867] → 82,364 ops/sec [80,836..83,400] ~ overlap (+0.3%) 98,617 ops/sec [96,260..100,127] → 92,323 ops/sec [91,396..94,281] 🔴 -6.4%
toFixed 54,180 ops/sec [52,711..54,656] → 53,621 ops/sec [52,554..53,953] ~ overlap (-1.0%) 59,656 ops/sec [59,251..61,702] → 57,120 ops/sec [56,879..57,412] 🔴 -4.3%
toString 80,025 ops/sec [78,535..81,109] → 77,521 ops/sec [76,624..79,135] ~ overlap (-3.1%) 92,937 ops/sec [91,342..93,666] → 87,154 ops/sec [86,676..88,418] 🔴 -6.2%
valueOf 114,321 ops/sec [113,571..116,400] → 110,994 ops/sec [109,120..113,092] 🔴 -2.9% 132,300 ops/sec [128,503..133,615] → 125,430 ops/sec [125,049..127,360] 🔴 -5.2%
toPrecision 75,308 ops/sec [73,476..76,169] → 73,232 ops/sec [72,265..74,225] ~ overlap (-2.8%) 82,051 ops/sec [80,615..84,206] → 78,921 ops/sec [78,558..79,011] 🔴 -3.8%
Number.isNaN 140,848 ops/sec [136,276..144,092] → 141,305 ops/sec [135,912..145,393] ~ overlap (+0.3%) 142,958 ops/sec [136,314..147,869] → 131,972 ops/sec [129,884..133,202] 🔴 -7.7%
Number.isFinite 145,381 ops/sec [144,473..146,037] → 138,110 ops/sec [136,826..141,043] 🔴 -5.0% 137,632 ops/sec [136,305..138,626] → 127,358 ops/sec [125,442..127,811] 🔴 -7.5%
Number.isInteger 148,726 ops/sec [146,341..151,616] → 142,049 ops/sec [141,827..147,177] ~ overlap (-4.5%) 150,279 ops/sec [146,066..152,471] → 137,835 ops/sec [136,388..138,676] 🔴 -8.3%
Number.parseInt and parseFloat 118,689 ops/sec [118,478..119,160] → 113,962 ops/sec [112,039..115,460] 🔴 -4.0% 110,864 ops/sec [109,330..114,505] → 104,850 ops/sec [103,139..108,533] 🔴 -5.4%
objects.js — Interp: 🔴 4, 3 unch. · avg -1.9% · Bytecode: 🔴 7 · avg -9.1%
Benchmark Interpreted Δ Bytecode Δ
create simple object 269,544 ops/sec [265,170..270,705] → 262,157 ops/sec [255,730..264,060] 🔴 -2.7% 276,839 ops/sec [274,096..278,918] → 254,564 ops/sec [251,136..256,282] 🔴 -8.0%
create nested object 134,218 ops/sec [133,840..135,676] → 131,094 ops/sec [129,214..131,934] 🔴 -2.3% 125,801 ops/sec [119,687..127,225] → 112,359 ops/sec [111,624..112,559] 🔴 -10.7%
create 50 objects via Array.from 5,171 ops/sec [4,991..5,230] → 5,113 ops/sec [5,068..5,172] ~ overlap (-1.1%) 4,962 ops/sec [4,915..4,977] → 4,491 ops/sec [4,461..4,561] 🔴 -9.5%
property read 248,902 ops/sec [247,144..255,740] → 251,430 ops/sec [246,371..252,461] ~ overlap (+1.0%) 347,674 ops/sec [343,878..363,487] → 308,045 ops/sec [301,499..309,644] 🔴 -11.4%
Object.keys 140,635 ops/sec [137,436..144,457] → 141,759 ops/sec [139,523..142,842] ~ overlap (+0.8%) 152,061 ops/sec [151,935..153,414] → 138,587 ops/sec [133,692..140,430] 🔴 -8.9%
Object.entries 55,968 ops/sec [55,164..56,273] → 53,271 ops/sec [52,702..53,854] 🔴 -4.8% 57,429 ops/sec [56,524..58,123] → 52,193 ops/sec [51,211..53,149] 🔴 -9.1%
spread operator 105,842 ops/sec [105,288..106,283] → 101,164 ops/sec [100,445..101,908] 🔴 -4.4% 105,277 ops/sec [104,562..106,121] → 99,108 ops/sec [97,268..99,901] 🔴 -5.9%
promises.js — Interp: 🔴 10, 2 unch. · avg -4.8% · Bytecode: 🔴 12 · avg -7.7%
Benchmark Interpreted Δ Bytecode Δ
Promise.resolve(value) 262,366 ops/sec [256,798..268,895] → 253,379 ops/sec [249,933..254,903] 🔴 -3.4% 280,382 ops/sec [270,686..284,670] → 266,878 ops/sec [266,162..268,532] 🔴 -4.8%
new Promise(resolve => resolve(value)) 96,687 ops/sec [94,850..99,170] → 93,323 ops/sec [92,632..95,094] ~ overlap (-3.5%) 120,039 ops/sec [118,350..120,721] → 109,445 ops/sec [108,470..111,963] 🔴 -8.8%
Promise.reject(reason) 272,127 ops/sec [267,715..278,807] → 256,709 ops/sec [254,407..261,411] 🔴 -5.7% 264,934 ops/sec [263,057..270,248] → 238,924 ops/sec [237,910..241,513] 🔴 -9.8%
resolve + then (1 handler) 92,516 ops/sec [90,809..94,729] → 89,801 ops/sec [87,270..90,324] 🔴 -2.9% 109,253 ops/sec [107,730..110,836] → 101,392 ops/sec [100,877..101,605] 🔴 -7.2%
resolve + then chain (3 deep) 37,472 ops/sec [37,318..38,952] → 34,394 ops/sec [34,196..35,107] 🔴 -8.2% 44,351 ops/sec [43,641..45,293] → 41,019 ops/sec [40,574..42,239] 🔴 -7.5%
resolve + then chain (10 deep) 12,551 ops/sec [12,307..12,629] → 11,293 ops/sec [10,924..11,381] 🔴 -10.0% 14,635 ops/sec [14,483..14,861] → 13,290 ops/sec [13,040..13,574] 🔴 -9.2%
reject + catch + then 54,221 ops/sec [53,586..54,855] → 50,619 ops/sec [50,377..51,720] 🔴 -6.6% 58,954 ops/sec [58,078..60,763] → 55,075 ops/sec [53,662..55,471] 🔴 -6.6%
resolve + finally + then 45,485 ops/sec [44,411..46,173] → 42,848 ops/sec [42,604..42,960] 🔴 -5.8% 50,548 ops/sec [49,245..52,040] → 47,566 ops/sec [47,042..47,942] 🔴 -5.9%
Promise.all (5 resolved) 17,158 ops/sec [16,883..17,675] → 16,418 ops/sec [16,105..16,680] 🔴 -4.3% 17,587 ops/sec [17,422..17,948] → 16,000 ops/sec [15,260..16,284] 🔴 -9.0%
Promise.race (5 resolved) 18,560 ops/sec [18,429..18,791] → 17,644 ops/sec [17,414..17,689] 🔴 -4.9% 18,649 ops/sec [18,213..18,920] → 17,186 ops/sec [16,965..17,255] 🔴 -7.8%
Promise.allSettled (5 mixed) 14,541 ops/sec [14,131..14,901] → 14,459 ops/sec [14,293..14,586] ~ overlap (-0.6%) 14,907 ops/sec [14,647..15,065] → 13,619 ops/sec [13,488..13,840] 🔴 -8.6%
Promise.any (5 mixed) 17,190 ops/sec [16,983..17,389] → 16,831 ops/sec [16,580..16,930] 🔴 -2.1% 17,137 ops/sec [16,950..17,625] → 16,018 ops/sec [15,937..16,196] 🔴 -6.5%
regexp.js — Interp: 🟢 1, 🔴 2, 8 unch. · avg -1.6% · Bytecode: 🔴 8, 3 unch. · avg -4.7%
Benchmark Interpreted Δ Bytecode Δ
regex literal creation 76,803 ops/sec [76,164..77,727] → 75,958 ops/sec [75,292..76,420] ~ overlap (-1.1%) 69,632 ops/sec [69,181..69,829] → 64,870 ops/sec [64,395..65,635] 🔴 -6.8%
new RegExp(pattern, flags) 66,385 ops/sec [65,015..67,046] → 65,914 ops/sec [64,907..67,029] ~ overlap (-0.7%) 68,841 ops/sec [68,523..69,147] → 66,678 ops/sec [65,226..67,091] 🔴 -3.1%
RegExp(existingRegex) returns the same regex 327,027 ops/sec [322,521..331,650] → 321,460 ops/sec [317,676..330,054] ~ overlap (-1.7%) 460,809 ops/sec [453,305..465,869] → 455,087 ops/sec [437,608..456,471] ~ overlap (-1.2%)
test() on a global regex 74,415 ops/sec [72,677..74,768] → 73,546 ops/sec [72,702..74,831] ~ overlap (-1.2%) 83,883 ops/sec [81,376..84,470] → 80,171 ops/sec [80,033..81,148] 🔴 -4.4%
exec() with capture groups 64,841 ops/sec [62,155..65,689] → 61,697 ops/sec [61,010..63,103] ~ overlap (-4.8%) 72,150 ops/sec [70,595..73,045] → 67,929 ops/sec [67,217..68,561] 🔴 -5.9%
toString() 249,026 ops/sec [248,259..249,102] → 235,746 ops/sec [230,603..237,382] 🔴 -5.3% 304,357 ops/sec [303,053..307,062] → 305,294 ops/sec [300,450..314,433] ~ overlap (+0.3%)
match() with global regex 21,552 ops/sec [21,280..21,686] → 21,084 ops/sec [20,737..21,291] ~ overlap (-2.2%) 20,798 ops/sec [20,675..20,974] → 19,263 ops/sec [19,129..20,709] ~ overlap (-7.4%)
matchAll() with capture groups 11,195 ops/sec [11,057..11,285] → 11,003 ops/sec [10,870..11,090] ~ overlap (-1.7%) 13,220 ops/sec [13,065..13,272] → 12,218 ops/sec [12,113..12,271] 🔴 -7.6%
replace() with global regex 20,896 ops/sec [20,588..21,401] → 20,334 ops/sec [20,236..20,440] 🔴 -2.7% 20,149 ops/sec [19,905..20,381] → 18,900 ops/sec [18,731..19,000] 🔴 -6.2%
search() with regex 41,069 ops/sec [40,523..44,264] → 41,967 ops/sec [41,712..42,527] ~ overlap (+2.2%) 39,983 ops/sec [39,623..40,204] → 38,217 ops/sec [37,849..38,478] 🔴 -4.4%
split() with regex separator 20,626 ops/sec [20,324..20,767] → 21,000 ops/sec [20,808..21,418] 🟢 +1.8% 20,786 ops/sec [20,282..21,090] → 19,742 ops/sec [19,457..20,014] 🔴 -5.0%
strings.js — Interp: 🟢 6, 🔴 1, 12 unch. · avg +0.8% · Bytecode: 🟢 3, 🔴 13, 3 unch. · avg +4.5%
Benchmark Interpreted Δ Bytecode Δ
string concatenation 186,253 ops/sec [182,733..188,590] → 185,949 ops/sec [184,659..187,193] ~ overlap (-0.2%) 122,302 ops/sec [121,426..122,603] → 110,869 ops/sec [109,498..112,764] 🔴 -9.3%
template literal 380,991 ops/sec [377,533..384,832] → 380,208 ops/sec [376,331..386,684] ~ overlap (-0.2%) 224,961 ops/sec [223,307..225,995] → 199,533 ops/sec [196,913..200,399] 🔴 -11.3%
string repeat 203,666 ops/sec [203,496..205,537] → 207,835 ops/sec [207,290..210,118] 🟢 +2.0% 236,883 ops/sec [232,302..238,258] → 216,147 ops/sec [211,907..219,363] 🔴 -8.8%
split and join 70,810 ops/sec [70,232..70,829] → 70,647 ops/sec [69,789..72,025] ~ overlap (-0.2%) 78,652 ops/sec [78,231..78,935] → 73,152 ops/sec [72,514..73,810] 🔴 -7.0%
indexOf and includes 82,576 ops/sec [81,965..83,186] → 83,022 ops/sec [81,968..84,525] ~ overlap (+0.5%) 91,420 ops/sec [80,382..92,481] → 85,129 ops/sec [84,753..86,171] ~ overlap (-6.9%)
toUpperCase and toLowerCase 126,678 ops/sec [125,694..128,715] → 127,094 ops/sec [122,227..129,761] ~ overlap (+0.3%) 162,478 ops/sec [159,360..165,016] → 158,737 ops/sec [157,659..159,452] ~ overlap (-2.3%)
slice and substring 76,345 ops/sec [75,138..77,809] → 79,663 ops/sec [77,947..80,065] 🟢 +4.3% 97,388 ops/sec [96,825..97,983] → 90,758 ops/sec [89,435..91,594] 🔴 -6.8%
trim operations 92,306 ops/sec [90,635..93,894] → 99,034 ops/sec [98,841..99,104] 🟢 +7.3% 119,160 ops/sec [114,823..123,209] → 113,398 ops/sec [111,123..113,988] 🔴 -4.8%
replace and replaceAll 105,974 ops/sec [104,417..108,033] → 106,403 ops/sec [105,751..107,100] ~ overlap (+0.4%) 108,638 ops/sec [107,742..111,096] → 101,841 ops/sec [100,777..102,668] 🔴 -6.3%
startsWith and endsWith 69,679 ops/sec [68,869..70,891] → 66,877 ops/sec [66,492..68,813] 🔴 -4.0% 74,381 ops/sec [73,483..76,061] → 68,472 ops/sec [67,489..69,630] 🔴 -7.9%
padStart and padEnd 103,017 ops/sec [100,539..103,586] → 100,486 ops/sec [99,223..102,482] ~ overlap (-2.5%) 114,280 ops/sec [112,914..116,906] → 104,466 ops/sec [104,076..104,913] 🔴 -8.6%
identity tag, no substitutions 230,646 ops/sec [222,843..234,719] → 232,586 ops/sec [230,267..236,756] ~ overlap (+0.8%) 613,010 ops/sec [594,992..626,499] → 556,618 ops/sec [541,602..559,086] 🔴 -9.2%
tag with 1 substitution 45,599 ops/sec [45,375..46,228] → 45,343 ops/sec [45,016..46,563] ~ overlap (-0.6%) 58,485 ops/sec [57,901..59,723] → 54,147 ops/sec [53,229..54,995] 🔴 -7.4%
tag with 3 substitutions 25,398 ops/sec [24,995..25,453] → 25,150 ops/sec [24,808..25,262] ~ overlap (-1.0%) 33,111 ops/sec [32,714..33,782] → 31,038 ops/sec [30,042..31,355] 🔴 -6.3%
tag with 6 substitutions 15,339 ops/sec [15,132..15,628] → 15,857 ops/sec [15,808..15,938] 🟢 +3.4% 20,078 ops/sec [19,684..20,290] → 17,961 ops/sec [17,810..18,041] 🔴 -10.5%
String.raw, no substitutions 296,395 ops/sec [293,581..298,131] → 305,158 ops/sec [302,928..305,843] 🟢 +3.0% 276,374 ops/sec [267,930..280,025] → 436,702 ops/sec [434,915..438,828] 🟢 +58.0%
String.raw, 2 substitutions 209,544 ops/sec [208,166..211,854] → 208,422 ops/sec [206,820..209,820] ~ overlap (-0.5%) 206,364 ops/sec [199,353..207,292] → 307,062 ops/sec [304,657..308,407] 🟢 +48.8%
tag accessing .raw array 89,841 ops/sec [88,886..90,629] → 90,215 ops/sec [89,096..91,469] ~ overlap (+0.4%) 102,961 ops/sec [101,738..104,206] → 151,489 ops/sec [149,222..154,267] 🟢 +47.1%
method as tag (this binding) 33,623 ops/sec [33,421..33,736] → 34,408 ops/sec [34,009..34,680] 🟢 +2.3% 43,656 ops/sec [42,725..67,741] → 62,928 ops/sec [62,125..63,797] ~ overlap (+44.1%)
tsv.js — Interp: 🟢 1, 🔴 2, 6 unch. · avg -0.5% · Bytecode: 🔴 8, 1 unch. · avg -7.8%
Benchmark Interpreted Δ Bytecode Δ
parse simple 3-column TSV 49,570 ops/sec [48,948..49,798] → 51,040 ops/sec [49,681..51,554] ~ overlap (+3.0%) 53,112 ops/sec [52,557..53,557] → 50,480 ops/sec [49,792..50,759] 🔴 -5.0%
parse 10-row TSV 13,067 ops/sec [12,665..13,209] → 13,190 ops/sec [13,175..13,203] ~ overlap (+0.9%) 14,065 ops/sec [13,860..14,159] → 13,230 ops/sec [12,921..13,560] 🔴 -5.9%
parse 100-row TSV 2,121 ops/sec [2,110..2,126] → 2,214 ops/sec [2,166..2,242] 🟢 +4.4% 2,205 ops/sec [2,135..2,296] → 2,131 ops/sec [2,087..2,162] ~ overlap (-3.3%)
parse TSV with backslash-escaped fields 9,699 ops/sec [9,608..9,767] → 9,485 ops/sec [9,340..9,623] ~ overlap (-2.2%) 10,391 ops/sec [10,270..10,455] → 9,624 ops/sec [9,538..9,676] 🔴 -7.4%
parse without headers (array of arrays) 5,762 ops/sec [5,720..5,770] → 5,554 ops/sec [5,380..5,691] 🔴 -3.6% 6,238 ops/sec [6,156..6,303] → 5,692 ops/sec [5,610..5,823] 🔴 -8.7%
stringify array of objects 42,356 ops/sec [42,032..43,066] → 41,625 ops/sec [41,162..42,124] ~ overlap (-1.7%) 47,689 ops/sec [47,492..47,850] → 41,987 ops/sec [41,706..42,330] 🔴 -12.0%
stringify array of arrays 12,245 ops/sec [12,045..12,294] → 11,622 ops/sec [11,341..11,886] 🔴 -5.1% 13,489 ops/sec [13,371..13,586] → 11,724 ops/sec [11,573..11,975] 🔴 -13.1%
stringify with values needing escaping 32,892 ops/sec [32,507..33,715] → 32,699 ops/sec [32,080..32,845] ~ overlap (-0.6%) 37,073 ops/sec [36,734..37,865] → 33,476 ops/sec [33,173..34,452] 🔴 -9.7%
parse then stringify 7,268 ops/sec [7,213..7,411] → 7,276 ops/sec [7,199..7,365] ~ overlap (+0.1%) 7,962 ops/sec [7,860..8,025] → 7,551 ops/sec [7,376..7,645] 🔴 -5.2%
typed-arrays.js — Interp: 🟢 2, 🔴 10, 10 unch. · avg -0.7% · Bytecode: 🟢 9, 🔴 11, 2 unch. · avg -1.9%
Benchmark Interpreted Δ Bytecode Δ
new Int32Array(0) 278,049 ops/sec [277,477..279,477] → 273,608 ops/sec [273,244..275,451] 🔴 -1.6% 312,267 ops/sec [309,466..314,428] → 288,959 ops/sec [287,513..290,320] 🔴 -7.5%
new Int32Array(100) 259,289 ops/sec [257,603..260,485] → 251,751 ops/sec [251,170..253,513] 🔴 -2.9% 280,666 ops/sec [277,857..283,594] → 266,066 ops/sec [264,605..266,609] 🔴 -5.2%
new Int32Array(1000) 165,600 ops/sec [163,946..166,110] → 161,500 ops/sec [161,004..163,526] 🔴 -2.5% 160,377 ops/sec [158,160..162,424] → 165,896 ops/sec [164,741..166,787] 🟢 +3.4%
new Float64Array(100) 243,236 ops/sec [242,011..245,026] → 238,470 ops/sec [237,131..239,778] 🔴 -2.0% 253,216 ops/sec [251,350..254,603] → 243,554 ops/sec [242,061..245,006] 🔴 -3.8%
Int32Array.from([...]) 163,962 ops/sec [163,143..164,694] → 164,981 ops/sec [164,016..165,951] ~ overlap (+0.6%) 163,816 ops/sec [161,449..165,068] → 167,515 ops/sec [167,085..168,600] 🟢 +2.3%
Int32Array.of(1, 2, 3, 4, 5) 260,287 ops/sec [258,733..261,566] → 254,891 ops/sec [253,312..256,767] 🔴 -2.1% 279,396 ops/sec [278,842..280,278] → 265,335 ops/sec [263,203..265,580] 🔴 -5.0%
sequential write 100 elements 3,144 ops/sec [3,117..3,164] → 3,100 ops/sec [3,087..3,115] 🔴 -1.4% 9,366 ops/sec [9,311..9,546] → 7,721 ops/sec [7,683..7,835] 🔴 -17.6%
sequential read 100 elements 3,230 ops/sec [3,211..3,243] → 3,151 ops/sec [3,134..3,172] 🔴 -2.4% 9,703 ops/sec [9,610..9,746] → 9,870 ops/sec [9,808..9,893] 🟢 +1.7%
Float64Array write 100 elements 2,845 ops/sec [2,828..2,873] → 2,831 ops/sec [2,810..2,841] ~ overlap (-0.5%) 5,409 ops/sec [5,277..5,470] → 5,680 ops/sec [5,591..5,693] 🟢 +5.0%
fill(42) 44,693 ops/sec [44,504..44,763] → 46,375 ops/sec [46,299..46,424] 🟢 +3.8% 42,284 ops/sec [42,240..42,319] → 47,152 ops/sec [47,022..47,171] 🟢 +11.5%
slice() 182,859 ops/sec [181,526..184,228] → 179,108 ops/sec [178,718..180,457] 🔴 -2.1% 190,584 ops/sec [189,046..192,012] → 194,852 ops/sec [194,236..195,516] 🟢 +2.2%
map(x => x * 2) 6,035 ops/sec [6,013..6,057] → 6,033 ops/sec [6,012..6,070] ~ overlap (-0.0%) 7,881 ops/sec [7,786..7,913] → 7,367 ops/sec [7,355..7,383] 🔴 -6.5%
filter(x => x > 50) 6,398 ops/sec [6,351..6,420] → 6,549 ops/sec [6,533..6,563] 🟢 +2.4% 8,493 ops/sec [8,412..8,530] → 7,818 ops/sec [7,809..7,844] 🔴 -8.0%
reduce (sum) 6,188 ops/sec [6,169..6,202] → 6,170 ops/sec [6,145..6,241] ~ overlap (-0.3%) 7,445 ops/sec [7,366..7,463] → 6,949 ops/sec [6,942..6,977] 🔴 -6.7%
sort() 157,189 ops/sec [156,105..157,489] → 157,983 ops/sec [156,262..158,379] ~ overlap (+0.5%) 160,664 ops/sec [160,313..160,791] → 173,685 ops/sec [173,301..173,910] 🟢 +8.1%
indexOf() 363,464 ops/sec [363,438..363,684] → 358,367 ops/sec [355,478..359,910] 🔴 -1.4% 421,966 ops/sec [420,828..422,248] → 420,756 ops/sec [420,050..421,917] ~ overlap (-0.3%)
reverse() 289,753 ops/sec [288,977..292,239] → 290,595 ops/sec [289,361..291,607] ~ overlap (+0.3%) 322,342 ops/sec [321,842..322,508] → 330,819 ops/sec [330,327..331,063] 🟢 +2.6%
create view over existing buffer 329,332 ops/sec [325,899..330,251] → 325,319 ops/sec [323,789..326,120] ~ overlap (-1.2%) 378,120 ops/sec [366,251..383,690] → 351,784 ops/sec [350,691..353,140] 🔴 -7.0%
subarray() 349,470 ops/sec [348,561..351,095] → 347,310 ops/sec [343,728..348,272] 🔴 -0.6% 429,975 ops/sec [427,204..434,194] → 390,555 ops/sec [384,163..396,420] 🔴 -9.2%
set() from array 456,726 ops/sec [454,952..461,467] → 456,564 ops/sec [455,289..459,899] ~ overlap (-0.0%) 550,388 ops/sec [548,908..550,680] → 511,020 ops/sec [510,565..512,086] 🔴 -7.2%
for-of loop 4,370 ops/sec [4,340..4,378] → 4,342 ops/sec [4,334..4,349] ~ overlap (-0.6%) 14,464 ops/sec [14,383..14,532] → 15,260 ops/sec [15,122..15,273] 🟢 +5.5%
spread into array 15,954 ops/sec [15,907..16,141] → 15,805 ops/sec [15,697..15,937] ~ overlap (-0.9%) 73,885 ops/sec [73,008..75,108] → 74,212 ops/sec [73,747..75,492] ~ overlap (+0.4%)
uint8array-encoding.js — Interp: 🟢 7, 🔴 5, 6 unch. · avg +19.3% · Bytecode: 🟢 1, 🔴 11, 6 unch. · avg -10.6%
Benchmark Interpreted Δ Bytecode Δ
short (5 bytes) 372,451 ops/sec [369,843..375,742] → 367,838 ops/sec [362,652..374,057] ~ overlap (-1.2%) 544,732 ops/sec [530,884..554,352] → 509,487 ops/sec [502,670..511,036] 🔴 -6.5%
medium (450 bytes) 187,944 ops/sec [187,193..190,592] → 243,801 ops/sec [242,411..246,012] 🟢 +29.7% 221,239 ops/sec [214,287..225,373] → 214,274 ops/sec [211,956..214,925] ~ overlap (-3.1%)
large (4096 bytes) 37,186 ops/sec [35,681..37,857] → 42,291 ops/sec [41,676..42,441] 🟢 +13.7% 36,774 ops/sec [36,246..39,419] → 36,933 ops/sec [36,161..38,353] ~ overlap (+0.4%)
base64url alphabet 128,553 ops/sec [127,189..130,502] → 166,503 ops/sec [166,382..168,374] 🟢 +29.5% 135,700 ops/sec [134,616..138,690] → 129,583 ops/sec [128,560..129,822] 🔴 -4.5%
omitPadding 200,434 ops/sec [199,233..304,327] → 300,136 ops/sec [299,226..303,584] ~ overlap (+49.7%) 230,924 ops/sec [227,345..234,227] → 215,854 ops/sec [211,539..216,274] 🔴 -6.5%
short (8 chars) 270,791 ops/sec [267,896..275,648] → 268,856 ops/sec [265,892..270,508] ~ overlap (-0.7%) 194,285 ops/sec [189,746..198,769] → 182,247 ops/sec [180,576..185,682] 🔴 -6.2%
medium (600 chars) 77,472 ops/sec [76,849..78,023] → 129,771 ops/sec [129,667..130,852] 🟢 +67.5% 83,335 ops/sec [79,751..86,182] → 82,100 ops/sec [80,916..83,798] ~ overlap (-1.5%)
large (5464 chars) 14,415 ops/sec [14,116..14,592] → 25,121 ops/sec [24,944..25,308] 🟢 +74.3% 15,113 ops/sec [14,343..15,176] → 15,020 ops/sec [14,937..15,663] ~ overlap (-0.6%)
short (5 bytes) 380,622 ops/sec [379,497..381,772] → 606,427 ops/sec [602,828..608,435] 🟢 +59.3% 555,814 ops/sec [551,817..560,310] → 522,647 ops/sec [519,485..527,396] 🔴 -6.0%
medium (450 bytes) 170,154 ops/sec [167,063..171,790] → 249,237 ops/sec [247,761..251,709] 🟢 +46.5% 288,557 ops/sec [189,055..289,723] → 181,192 ops/sec [178,713..182,913] 🔴 -37.2%
large (4096 bytes) 48,289 ops/sec [47,923..48,812] → 44,439 ops/sec [43,777..44,898] 🔴 -8.0% 43,232 ops/sec [41,893..43,794] → 28,644 ops/sec [27,810..29,761] 🔴 -33.7%
short (10 chars) 308,642 ops/sec [306,510..309,498] → 300,321 ops/sec [296,362..301,576] 🔴 -2.7% 339,314 ops/sec [334,001..342,357] → 203,650 ops/sec [201,365..204,641] 🔴 -40.0%
medium (900 chars) 201,346 ops/sec [199,916..203,084] → 201,026 ops/sec [200,413..202,350] ~ overlap (-0.2%) 209,475 ops/sec [208,639..210,189] → 122,976 ops/sec [122,772..152,891] 🔴 -41.3%
large (8192 chars) 53,326 ops/sec [52,761..53,744] → 52,289 ops/sec [51,761..52,724] 🔴 -1.9% 50,523 ops/sec [49,289..52,040] → 54,371 ops/sec [54,205..54,400] 🟢 +7.6%
setFromBase64 (450 bytes) 124,039 ops/sec [122,952..125,182] → 122,804 ops/sec [122,487..123,049] ~ overlap (-1.0%) 140,292 ops/sec [140,186..140,326] → 134,116 ops/sec [133,843..134,704] 🔴 -4.4%
setFromHex (450 bytes) 179,444 ops/sec [176,719..181,185] → 178,058 ops/sec [177,699..180,464] ~ overlap (-0.8%) 202,199 ops/sec [199,128..203,938] → 198,209 ops/sec [197,220..199,967] ~ overlap (-2.0%)
toBase64 → fromBase64 (450 bytes) 92,974 ops/sec [92,223..93,396] → 91,010 ops/sec [90,483..92,051] 🔴 -2.1% 101,610 ops/sec [101,527..101,973] → 97,225 ops/sec [96,506..97,707] 🔴 -4.3%
toHex → fromHex (450 bytes) 125,441 ops/sec [123,105..126,287] → 119,496 ops/sec [118,351..119,715] 🔴 -4.7% 129,049 ops/sec [128,005..130,297] → 127,551 ops/sec [123,856..128,634] ~ overlap (-1.2%)

Measured on ubuntu-latest x64. Benchmark ranges compare cached main-branch min/max ops/sec with the PR run; overlapping ranges are treated as unchanged noise. Percentage deltas are secondary context.

@github-actions
Copy link
Copy Markdown
Contributor

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 5831 5831
Tests Passed 5790 ✅ 5831 ✅
Tests Skipped 41 0
Tests Workers 4 4
Tests Test Duration 1.31s 1.40s
Tests Lex (cumulative) 192.4ms 114.3ms
Tests Parse (cumulative) 277.4ms 246.8ms
Tests Compile (cumulative) 158.0ms
Tests Execute (cumulative) 1.19s 1.38s
Tests Engine Total (cumulative) 1.66s 1.90s
Tests Lex (avg/worker) 48.1ms 28.6ms
Tests Parse (avg/worker) 69.3ms 61.7ms
Tests Compile (avg/worker) 39.5ms
Tests Execute (avg/worker) 298.7ms 345.9ms
Tests Engine Total (avg/worker) 416.1ms 475.6ms
Benchmarks Total 386 386
Benchmarks Workers 4 4
Benchmarks Duration 2.99min 2.83min

Measured on ubuntu-latest x64.

@frostney frostney merged commit a855382 into main Apr 20, 2026
10 checks passed
@frostney frostney deleted the t3code/fix-bigint-test262-compliance branch April 20, 2026 09:58
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working internal Refactoring, CI, tooling, cleanup spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant