Skip to content

fix(engine): map ShadowRealm.evaluate declaration early errors to SyntaxError#817

Merged
frostney merged 4 commits into
mainfrom
claude/agitated-elion-2917b0
Jun 27, 2026
Merged

fix(engine): map ShadowRealm.evaluate declaration early errors to SyntaxError#817
frostney merged 4 commits into
mainfrom
claude/agitated-elion-2917b0

Conversation

@frostney

@frostney frostney commented Jun 25, 2026

Copy link
Copy Markdown
Owner

Summary

  • ShadowRealm.prototype.evaluate treats its source as a Script, so a top-level name that is both lexically- and var-declared (let y; var y; / var y; let y;) is a static Script early error (ECMA-262 §16.1.1) and must surface as a caller-realm SyntaxError — not the TypeError reserved for runtime abrupt completions (proposal-shadowrealm PerformShadowRealmEval §3.1.3 step 2 vs step 15). It was reporting TypeError. This is the declaration-conflict follow-up fix(engine): map ShadowRealm eval instantiation errors to SyntaxError #816 flagged as out of scope.
  • Root cause: fix(engine): map ShadowRealm eval instantiation errors to SyntaxError #816's phase-1 (PrepareEvalProgram) classifies an early error by catching a Pascal TGocciaSyntaxError, mapping it to a caller-realm SyntaxError; anything else (incl. TGocciaThrowValue) becomes a TypeError. The lexical/var early-error checks in EvalDeclarationInstantiation raised via ThrowSyntaxError, which (through RaiseNativeError) raises a throwable TGocciaThrowValue — so phase-1 classified them as runtime throws → TypeError. Duplicate-lexical (Scope.pas) and illegal control-flow (RejectEvalControlFlow, fix(engine): map ShadowRealm eval instantiation errors to SyntaxError #816) already raise TGocciaSyntaxError directly, which is why those were already SyntaxError.
  • Fix: make EvalDeclarationInstantiation's declaration early-error checks raise TGocciaSyntaxError (via a small RaiseAlreadyDeclared helper), matching RejectEvalControlFlow and Scope.pas. fix(engine): map ShadowRealm eval instantiation errors to SyntaxError #816's phase-1 catch then routes them to a caller-realm SyntaxError automatically — no ShadowRealm-boundary or parallel-check code needed.
  • Scope / non-goals:
    • The exception-type swap only changes classification when a check already fires; it does not change whether any check fires. The two adjacent CanDeclareGlobal* TypeErrors are left untouched (they are genuine runtime errors).
    • Direct (non-ShadowRealm) eval is unaffected: a Pascal TGocciaSyntaxError from EvalDeclarationInstantiation is still converted to a catchable JS SyntaxError (interpreter PascalExceptionToErrorObject; bytecode VM TGocciaSyntaxError unwind arm) — verified in both modes.
    • A nested eval whose body has the conflict is a runtime abrupt completion inside the outer eval, so ShadowRealm still wraps it as a TypeError (step 15) — verified.
    • var is processed only in ShadowRealm child realms; plain GocciaScript (which excludes var) is unaffected, and distinct lexical/var names still bind normally.

Testing

  • Verified no regressions and confirmed the new feature or bugfix in end-to-end JavaScript/TypeScript tests
  • Updated documentation
  • Optional: Verified no regressions and confirmed the new feature or bugfix in native Pascal tests (if AST, scope, evaluator, or value types changed)
  • Optional: Verified no benchmark regressions or confirmed benchmark coverage for the change

Details:

  • built-ins/ShadowRealm/** test262: 64/64, both interpreter and bytecode modes.
  • Full JS suite: 10948/10948, both modes (./build/GocciaTestRunner tests and --mode=bytecode).
  • New JS coverage in tests/built-ins/ShadowRealm/evaluate.js: the lexical/var collision (both orderings) and a distinct-name guard (duplicate-lexical is already covered by fix(engine): map ShadowRealm eval instantiation errors to SyntaxError #816's test).
  • ./format.pas --check: clean.
  • No documentation change needed — spec-conformance bugfix for an existing built-in (no new surface).

…taxError

ShadowRealm.prototype.evaluate treats its source as a Script, so Script-level
static early errors must surface as caller-realm SyntaxErrors
(proposal-shadowrealm PerformShadowRealmEval §3.1.3 step 2). #814 added the
ValidateEvalEarlyErrors pre-evaluation pass for reference/assignment early
errors but left EvalDeclarationInstantiation conflicts as a tracked follow-up,
where they surfaced as the step-15 caller-realm TypeError instead.

Add CheckEvalScriptLexicalEarlyError (ECMA-262 §16.1.1) covering the two
top-level declaration rules — a duplicate lexically-declared name, and a
lexically-declared name that is also var-declared — and run it on the same
seam before evaluation so both map to a caller-realm SyntaxError:

  new ShadowRealm().evaluate("let y; var y;")  // SyntaxError (was TypeError)
  new ShadowRealm().evaluate("var y; let y;")  // SyntaxError (was TypeError)
  new ShadowRealm().evaluate("let x; let x;")  // SyntaxError (was TypeError)

var is processed only in ShadowRealm child realms, so plain GocciaScript (which
excludes var) is unaffected, and distinct lexical/var names still bind normally.
built-ins/ShadowRealm test262 stays 64/64 and the full JS suite stays green in
both interpreter and bytecode modes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
@vercel

vercel Bot commented Jun 25, 2026

Copy link
Copy Markdown

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment
Project Deployment Actions Updated (UTC)
gocciascript-homepage Ignored Ignored Preview Jun 27, 2026 12:43pm

Request Review

@coderabbitai

coderabbitai Bot commented Jun 25, 2026

Copy link
Copy Markdown
Contributor

Review Change Stack

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: addd15a3-f5b0-42b5-badc-4b7ca3061f47

📥 Commits

Reviewing files that changed from the base of the PR and between f0428b5 and 1e79091.

📒 Files selected for processing (2)
  • source/units/Goccia.Evaluator.pas
  • tests/built-ins/ShadowRealm/evaluate.js

📝 Walkthrough

Walkthrough

Eval declaration instantiation now raises SyntaxError directly for duplicate lexical and var bindings. ShadowRealm evaluate tests were added for conflicting declaration orders and for distinct names.

Changes

Eval redeclaration handling

Layer / File(s) Summary
Syntax error helper and conflict checks
source/units/Goccia.Evaluator.pas
A local helper raises TGocciaSyntaxError for already-declared names, and eval instantiation uses it across lexical/var conflict checks and rejected declaration-name paths.
ShadowRealm evaluate coverage
tests/built-ins/ShadowRealm/evaluate.js
New tests assert SyntaxError for top-level lexical/var name conflicts in both orders and success for distinct names.

Sequence Diagram(s)

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~10 minutes

Possibly related PRs

  • frostney/GocciaScript#816: Also changes EvalDeclarationInstantiation and ShadowRealm.prototype.evaluate name-conflict behavior to surface early errors as SyntaxError.

Suggested labels

bug, spec compliance

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly and concisely summarizes the main change: mapping ShadowRealm.evaluate declaration early errors to SyntaxError.
Description check ✅ Passed The description follows the template with a clear Summary and Testing section, plus relevant scope and implementation notes.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.

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

@github-actions

github-actions Bot commented Jun 25, 2026

Copy link
Copy Markdown
Contributor

Suite Timing

Test Runner (interpreted: 10,948 passed; bytecode: 10,948 passed)
Metric Interpreted Bytecode
Total 10948 10948
Passed 10948 ✅ 10948 ✅
Workers 4 4
Test Duration 20.14s 19.44s
Lex (cumulative) 531.8ms 550.7ms
Parse (cumulative) 376.6ms 395.2ms
Compile (cumulative) 799.6ms
Execute (cumulative) 58.2ms 45.41s
Engine Total (cumulative) 966.6ms 47.15s
Lex (avg/worker) 133.0ms 137.7ms
Parse (avg/worker) 94.1ms 98.8ms
Compile (avg/worker) 199.9ms
Execute (avg/worker) 14.5ms 11.35s
Engine Total (avg/worker) 241.6ms 11.79s

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Test runner worker shutdown frees thread-local heaps in bulk; that shutdown reclamation is not counted as GC collections or collected objects.

Metric Interpreted Bytecode
GC Live 282.87 MiB 280.29 MiB
GC Peak Live 335.35 MiB 307.71 MiB
GC Allocated During Run 528.33 MiB 472.64 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 195 195
GC Collected Objects 2,591,362 2,162,595
Heap Start Allocated 181.0 KiB 181.0 KiB
Heap End Allocated 3.65 MiB 3.65 MiB
Heap Delta Allocated 3.48 MiB 3.48 MiB
Heap Delta Free 1.68 MiB 1.68 MiB
Benchmarks (interpreted: 430; bytecode: 430)
Metric Interpreted Bytecode
Total 430 430
Workers 4 4
Duration 2.78min 2.68min

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Benchmark runner performs explicit between-file collections, so collection and collected-object counts can be much higher than the test runner.

Metric Interpreted Bytecode
GC Live 6.09 MiB 6.09 MiB
GC Peak Live 93.39 MiB 71.30 MiB
GC Allocated During Run 15.12 GiB 10.25 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 3,824 3,403
GC Collected Objects 236,208,043 224,140,415
Heap Start Allocated 3.36 MiB 3.36 MiB
Heap End Allocated 3.36 MiB 3.36 MiB
Heap Delta Allocated 128 B 128 B

Measured on ubuntu-latest x64.

@github-actions

github-actions Bot commented Jun 25, 2026

Copy link
Copy Markdown
Contributor

Benchmark Results

430 benchmarks

Interpreted: 🟢 65 improved · 🔴 20 regressed · 345 unchanged · avg +2.5%
Bytecode: 🟢 43 improved · 🔴 48 regressed · 339 unchanged · avg -0.8%

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

Deterministic profile diff

Deterministic profile diff: no significant changes.

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

github-actions Bot commented Jun 25, 2026

Copy link
Copy Markdown
Contributor

test262 Conformance

Category Run Passed Δ Pass Failed Pass-rate Δ Rate
built-ins 23,643 22,609 +1 1,034 95.6% ±0pp
harness 116 116 ±0 0 100.0% ±0pp
intl402 3,341 3,334 ±0 7 99.8% ±0pp
language 23,711 23,711 ±0 0 100.0% ±0pp
staging 1,482 1,109 ±0 373 74.8% ±0pp
total 52,293 50,879 +1 1,414 97.3% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/TypedArray 99.9% ±0pp 1,445 / 1,446
intl402/Temporal 99.9% ±0pp 2,026 / 2,029
built-ins/Object 99.7% ±0pp 3,401 / 3,411
Per-test deltas (+1 / -0)

Newly passing (1):

  • built-ins/Number/prototype/toExponential/undefined-fractiondigits.js

Steady-state failures are non-blocking; regressions vs the cached main baseline (lower total pass count, or any PASS → non-PASS transition) fail the conformance gate. Measured on ubuntu-latest x64, bytecode mode. Areas grouped by the first two test262 path components; minimum 25 attempted tests, areas already at 100% excluded. Δ vs main compares against the most recent cached main baseline.

frostney added 2 commits June 27, 2026 13:41
…-2917b0

# Conflicts:
#	source/units/Goccia.Builtins.GlobalShadowRealm.pas
@frostney frostney marked this pull request as ready for review June 27, 2026 13:11
@coderabbitai coderabbitai Bot added bug Something isn't working spec compliance Mismatch against official JavaScript/TypeScript specification labels Jun 27, 2026
@frostney frostney merged commit dedffc6 into main Jun 27, 2026
14 checks passed
@frostney frostney deleted the claude/agitated-elion-2917b0 branch June 27, 2026 13:39
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant