Skip to content

Preserve flatMap TypeError when source iterator Close throws#628

Merged
frostney merged 2 commits into
mainfrom
issue-592-flatmap-preserve-typeerror
May 10, 2026
Merged

Preserve flatMap TypeError when source iterator Close throws#628
frostney merged 2 commits into
mainfrom
issue-592-flatmap-preserve-typeerror

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented May 10, 2026

Summary

  • Preserve the TypeError thrown by Iterator.prototype.flatMap when the mapper returns a non-iterable value, even when the source iterator's .return() also throws during cleanup.
  • Both DoAdvanceNext and DoDirectNext in TGocciaLazyFlatMapIteratorValue now use the CloseIteratorPreservingError pattern (already used elsewhere in the same class) instead of calling FSourceIterator.Close directly before ThrowTypeError.
  • Closes Iterator.prototype.flatMap must preserve TypeError when source Close also throws #592

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

@frostney @claude
Preserve flatMap TypeError when source iterator Close throws (#592)
8219db7 
Use CloseIteratorPreservingError pattern in both DoAdvanceNext and
DoDirectNext so a throwing .return() cannot swallow the non-iterable
TypeError.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@vercel
Copy link
Copy Markdown

vercel Bot commented May 10, 2026 •
edited
Loading

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 May 10, 2026 8:54pm

Request Review

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented May 10, 2026 •
edited
Loading

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

Run ID: 0c90d98a-2ed8-4ce8-9eaa-4a85508d09ad

📥 Commits

Reviewing files that changed from the base of the PR and between e9de1f5 and 9fd4241.

📒 Files selected for processing (2)
  • source/units/Goccia.Values.Iterator.Lazy.pas
  • tests/built-ins/Iterator/prototype/flatMap.js
📝 Walkthrough

Walkthrough

The PR fixes error-handling behavior in Iterator.prototype.flatMap to preserve the original TypeError when the source iterator's cleanup also throws. Changes are made in both the DoAdvanceNext and DoDirectNext paths of TGocciaLazyFlatMapIteratorValue, wrapping the error throw in try/except to ensure cleanup failures do not replace the protocol error. A test case validates this behavior.

Changes

flatMap TypeError preservation on cleanup failure

Layer / File(s) Summary
Error handling logic
source/units/Goccia.Values.Iterator.Lazy.pas		 Both DoAdvanceNext (lines 511–518) and DoDirectNext (lines 570–577) now wrap ThrowTypeError in try/except that calls CloseIteratorPreservingError before re-raising, replacing direct close-then-throw.
Test case
tests/built-ins/Iterator/prototype/flatMap.js		 New test (lines 82–96) verifies flatMap preserves TypeError when source iterator's .return() throws, and confirms cleanup was invoked exactly once.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~12 minutes

Possibly related PRs

  • frostney/GocciaScript#589: Refactored flatMap into a new helper iterator value that standardized exception and cleanup handling patterns.
  • frostney/GocciaScript#579: Directly addresses iterator error/cleanup handling for flatMap using the same CloseIteratorPreservingError pattern.

Suggested labels

bug, spec compliance, internal

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title accurately describes the main change: preserving a TypeError in flatMap when the source iterator's Close method throws.
Description check ✅ Passed The description covers the summary, links the related issue (#592), and documents testing status with checkboxes mostly completed.
Linked Issues check ✅ Passed The PR fully implements the requirements from #592: uses CloseIteratorPreservingError pattern in both DoAdvanceNext and DoDirectNext, adds a JS test verifying TypeError preservation when source .return() throws, and properly preserves the original protocol error.
Out of Scope Changes check ✅ Passed All changes are directly related to the linked issue #592: modifications to TGocciaLazyFlatMapIteratorValue error handling in flatMap and a corresponding test case, with no unrelated changes.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

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

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

@frostney @claude
Assert source iterator is closed in flatMap TypeError test
9fd4241 
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 10, 2026 •
edited
Loading

Suite Timing

Test Runner (interpreted: 9,244 passed; bytecode: 9,244 passed)
Metric Interpreted Bytecode
Total 9244 9244
Passed 9244 ✅ 9244 ✅
Workers 4 4
Test Duration 2.01s 1.70s
Lex (cumulative) 238.5ms 118.3ms
Parse (cumulative) 251.4ms 197.5ms
Compile (cumulative) — 393.8ms
Execute (cumulative) 2.29s 2.12s
Engine Total (cumulative) 2.78s 2.83s
Lex (avg/worker) 59.6ms 29.6ms
Parse (avg/worker) 62.9ms 49.4ms
Compile (avg/worker) — 98.4ms
Execute (avg/worker) 572.5ms 530.0ms
Engine Total (avg/worker) 695.0ms 707.4ms

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 244.47 MiB 238.90 MiB
GC Peak Live 244.48 MiB 238.91 MiB
GC Allocated During Run 248.38 MiB 242.79 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1 1
GC Collected Objects 88 88
Heap Start Allocated 149.3 KiB 149.3 KiB
Heap End Allocated 2.54 MiB 2.54 MiB
Heap Delta Allocated 2.39 MiB 2.39 MiB
Heap Delta Free 140.1 KiB 140.1 KiB
Benchmarks (interpreted: 407; bytecode: 407)
Metric Interpreted Bytecode
Total 407 407
Workers 4 4
Duration 2.46min 2.40min

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 3.65 MiB 3.64 MiB
GC Peak Live 110.30 MiB 69.73 MiB
GC Allocated During Run 13.95 GiB 10.25 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 2,810 2,644
GC Collected Objects 256,455,361 244,999,745
Heap Start Allocated 2.29 MiB 2.29 MiB
Heap End Allocated 2.29 MiB 2.29 MiB
Heap Delta Allocated 128 B 128 B

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 10, 2026 •
edited
Loading

Benchmark Results

407 benchmarks

Interpreted: 🟢 117 improved · 🔴 32 regressed · 258 unchanged · avg +1.9%
Bytecode: 🟢 294 improved · 🔴 32 regressed · 81 unchanged · avg +6.4%

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

github-actions Bot commented May 10, 2026 •
edited
Loading

test262 Conformance

Category Run Passed Δ Pass Failed Pass-rate Δ Rate
built-ins 23,449 14,627 +1 8,818 62.4% ±0pp
harness 116 71 ±0 45 61.2% ±0pp
intl402 3,324 691 ±0 2,633 20.8% ±0pp
language 23,635 12,575 ±0 11,060 53.2% ±0pp
staging 1,484 485 ±0 997 32.7% ±0pp
total 52,008 28,449 +1 23,553 54.7% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/WeakSet 98.8% ±0pp 84 / 85
built-ins/WeakMap 98.6% ±0pp 139 / 141
language/asi 97.1% ±0pp 99 / 102
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 frostney marked this pull request as ready for review May 10, 2026 21:08
@coderabbitai coderabbitai Bot added bug Something isn't working spec compliance Mismatch against official JavaScript/TypeScript specification internal Refactoring, CI, tooling, cleanup labels May 10, 2026
@frostney frostney merged commit 217c541 into main May 10, 2026
14 checks passed
@frostney frostney deleted the issue-592-flatmap-preserve-typeerror branch May 10, 2026 21:10
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

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

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

Iterator.prototype.flatMap must preserve TypeError when source Close also throws

1 participant

@frostney