Skip to content

Make CLI test substring matches CRLF-tolerant on Windows#512

Merged
frostney merged 3 commits into
mainfrom
t3code/windows-print-fix
May 4, 2026
Merged

Make CLI test substring matches CRLF-tolerant on Windows#512
frostney merged 3 commits into
mainfrom
t3code/windows-print-fix

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented May 4, 2026

Summary

The --print rollout in #510 anchored ~36 assertions on the bare-value line via out.includes(`\n${value}\n`), which fails on Windows because Pascal's WriteLn writes CRLF — so the captured stdout contains \r\n<value>\r\n and the substring is never present. The Windows CLI job in CI run 25309261679 failed on the very first such check (Stdin smoke (interpreted)).

Changes

  • Add a small containsLine(out, value) helper to each of the three scripts/test-cli*.ts files that strips \r before substring matching.
  • Route every out.includes("\n<value>\n") site through the helper (9 in test-cli.ts, 5 in test-cli-apps.ts, 22 in test-cli-config.ts).

The helper is a no-op on Linux/macOS (no \r to strip), so existing platforms remain unaffected.

Test plan

  • bun run scripts/test-cli.ts passes locally on macOS
  • bun run scripts/test-cli-apps.ts passes locally on macOS
  • bun run scripts/test-cli-config.ts passes locally on macOS
  • CI Windows cli (i386-win32) and cli (x86_64-win64) jobs go green

🤖 Generated with Claude Code

The --print rollout in #510 anchored ~36 assertions on the bare-value
line via `out.includes("\n<value>\n")`, which fails on Windows because
Pascal's WriteLn writes CRLF — so the captured stdout contains
`\r\n<value>\r\n` and the substring is never present.

Add a small `containsLine` helper to each test-cli script that strips
\r before matching, and route every \n<value>\n check through it.
The change is a no-op on Linux/macOS and unblocks the cli/windows-latest
job in CI (run 25309261679).

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

vercel Bot commented May 4, 2026

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 4, 2026 4:10pm

Request Review

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented May 4, 2026

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: 52963af4-7486-4445-aefd-0a40850115ff

📥 Commits

Reviewing files that changed from the base of the PR and between c53e45d and 0ff9b7e.

📒 Files selected for processing (8)
  • scripts/test-cli-apps.ts
  • scripts/test-cli-config.ts
  • scripts/test-cli-lexer.ts
  • scripts/test-cli-parser.ts
  • scripts/test-cli.ts
  • scripts/test-cli/assertions.ts
  • scripts/test-cli/binaries.ts
  • scripts/test-cli/tmpdir.ts
✅ Files skipped from review due to trivial changes (1)
  • scripts/test-cli/assertions.ts
🚧 Files skipped from review as they are similar to previous changes (2)
  • scripts/test-cli-apps.ts
  • scripts/test-cli.ts

📝 Walkthrough

Walkthrough

This PR consolidates CLI test utilities into shared modules and improves assertion robustness. It creates scripts/test-cli/assertions.ts, scripts/test-cli/binaries.ts, and scripts/test-cli/tmpdir.ts to centralize helper functions, then refactors five test scripts to import these utilities instead of defining them inline. Output assertions are converted to use containsLine() for platform-agnostic newline handling.

Changes

Test Infrastructure Centralization

Layer / File(s) Summary
Shared Assertion Utilities
scripts/test-cli/assertions.ts
New module exports containsLine(s, value) to strip carriage returns and check for value on a standalone line, plus normalizeLineEndings(output) to normalize CRLF/LF differences.
Shared Binary Paths
scripts/test-cli/binaries.ts
New module computes Windows .exe suffix and exports constants LOADER, BARE, REPL, TESTRUNNER, BUNDLER, BENCHRUNNER pointing to ./build/ artifacts.
Shared Temp Directory Utilities
scripts/test-cli/tmpdir.ts
New module exports mkdtemp(prefix) to create temp directories, makeTmpFactory(prefix) to return a factory function, and clean(dir) to recursively delete directories.
Test Script Refactoring
scripts/test-cli-lexer.ts, scripts/test-cli-parser.ts
Import LOADER from ./test-cli/binaries and normalizeLineEndings from ./test-cli/assertions instead of defining them locally. Remove platform-specific path construction.
Test Script Refactoring with Assertion Updates
scripts/test-cli-apps.ts, scripts/test-cli-config.ts, scripts/test-cli.ts
Import shared utilities (LOADER/BARE/REPL/TESTRUNNER/BUNDLER/BENCHRUNNER, containsLine, mkdtemp/clean, makeTmpFactory). Convert output assertions from newline-wrapped substring matching (out.includes("\n<value>\n")) to containsLine(out, <value>) for numeric and string results. Replace inline temp-directory creation/cleanup with shared functions.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~10 minutes

Possibly related PRs

🚥 Pre-merge checks | ✅ 3 | ❌ 2

❌ Failed checks (1 warning, 1 inconclusive)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 50.00% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
Description check ❓ Inconclusive The description comprehensively covers the problem, changes made, and test plan, but the actual PR has evolved beyond what was described (shared modules added), creating a mismatch between description and implementation. Update the description to reflect the extracted helper modules (binaries.ts, assertions.ts, tmpdir.ts) and clarify how the refactoring improves code organization beyond the original CRLF fix.
✅ Passed checks (3 passed)
Check name Status Explanation
Title check ✅ Passed The title directly addresses the main change—making CLI test assertions CRLF-tolerant on Windows—and accurately describes the primary objective of the PR.
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.

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


Review rate limit: 3/5 reviews remaining, refill in 19 minutes and 7 seconds.

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

@coderabbitai coderabbitai Bot added bug Something isn't working internal Refactoring, CI, tooling, cleanup labels May 4, 2026
@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 4, 2026

Suite Timing

Test Runner (interpreted: 8,599 passed; bytecode: 8,599 passed)
Metric Interpreted Bytecode
Total 8599 8599
Passed 8599 ✅ 8599 ✅
Workers 4 4
Test Duration 1.90s 1.90s
Lex (cumulative) 248.5ms 158.8ms
Parse (cumulative) 245.6ms 235.1ms
Compile (cumulative) 553.2ms
Execute (cumulative) 1.77s 1.62s
Engine Total (cumulative) 2.27s 2.57s
Lex (avg/worker) 62.1ms 39.7ms
Parse (avg/worker) 61.4ms 58.8ms
Compile (avg/worker) 138.3ms
Execute (avg/worker) 443.0ms 406.2ms
Engine Total (avg/worker) 566.6ms 642.9ms

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 175.98 MiB 170.80 MiB
GC Peak Live 175.98 MiB 170.80 MiB
GC Allocated During Run 180.24 MiB 174.99 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1 1
GC Collected Objects 74 74
Heap Start Allocated 143.2 KiB 143.2 KiB
Heap End Allocated 1.34 MiB 1.34 MiB
Heap Delta Allocated 1.20 MiB 1.20 MiB
Heap Delta Free 465.3 KiB 465.3 KiB
Benchmarks (interpreted: 407; bytecode: 407)
Metric Interpreted Bytecode
Total 407 407
Workers 4 4
Duration 2.43min 2.25min

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 2.75 MiB 2.74 MiB
GC Peak Live 98.55 MiB 59.89 MiB
GC Allocated During Run 15.23 GiB 9.14 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 2,831 2,645
GC Collected Objects 284,924,841 220,278,732
Heap Start Allocated 1.10 MiB 1.10 MiB
Heap End Allocated 1.11 MiB 1.11 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 4, 2026

Benchmark Results

407 benchmarks

Interpreted: 🟢 60 improved · 🔴 30 regressed · 317 unchanged · avg +1.0%
Bytecode: 🟢 82 improved · 🔴 51 regressed · 274 unchanged · avg +0.7%

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

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 4, 2026

test262 Conformance

Metric Value Δ vs main
Total tests 47,420 ±0
Eligible tests 38,704 (81.6%) ±0
Eligible tests passing 22,155 (57.2%) +1 (±0pp)
Total tests passing 22,155 (46.7%) +1 (±0pp)

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/Set 91.1% ±0pp 346 / 380
language/function-code 89.1% ±0pp 90 / 101
built-ins/Map 88.0% ±0pp 176 / 200

Compatibility roadmap skips

Target Skipped
excluded-syntax 6,315
modules 1,552
atomics-shared-memory 874
binary-data-dataview 854
realms 247

Non-blocking. 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.

Replace the three inline copies of the CRLF-tolerant `containsLine`
helper added in the previous commit with a single shared module so
future test-cli additions share the implementation instead of
hand-copying it.

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

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

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

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/test-cli-helpers.ts`:
- Around line 13-14: The containsLine helper currently uses s.replace(/\r/g,
"").includes(`\n${value}\n`) which misses first/last lines; change containsLine
to split the string on /\r?\n/ (preserves CRLF handling) and check exact
equality against value (e.g., const lines = s.split(/\r?\n/); return
lines.includes(value)); update the exported function name containsLine
accordingly so single-line outputs and edges are handled correctly.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

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

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: dbe19145-b03e-43b1-a968-e261f05cdc98

📥 Commits

Reviewing files that changed from the base of the PR and between c53e45d and 8d2c8f8.

📒 Files selected for processing (4)
  • scripts/test-cli-apps.ts
  • scripts/test-cli-config.ts
  • scripts/test-cli-helpers.ts
  • scripts/test-cli.ts
🚧 Files skipped from review as they are similar to previous changes (1)
  • scripts/test-cli.ts

Comment thread scripts/test-cli-helpers.ts Outdated
Comment on lines +13 to +14
export const containsLine = (s: string, value: string): boolean =>
s.replace(/\r/g, "").includes(`\n${value}\n`);
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Use a real line split here.

replace(/\r/g, "").includes(\\n${value}\n`)still misses values on the first or last line, so this helper is brittle for single-line outputs. Splitting on/\r?\n/` and checking exact line equality would keep the CRLF fix and make the helper behave like its name suggests.

♻️ Suggested fix
-export const containsLine = (s: string, value: string): boolean =>
-  s.replace(/\r/g, "").includes(`\n${value}\n`);
+export const containsLine = (s: string, value: string): boolean =>
+  s.split(/\r?\n/).some((line) => line === value);
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
export const containsLine = (s: string, value: string): boolean =>
s.replace(/\r/g, "").includes(`\n${value}\n`);
export const containsLine = (s: string, value: string): boolean =>
s.split(/\r?\n/).some((line) => line === value);
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.

In `@scripts/test-cli-helpers.ts` around lines 13 - 14, The containsLine helper
currently uses s.replace(/\r/g, "").includes(`\n${value}\n`) which misses
first/last lines; change containsLine to split the string on /\r?\n/ (preserves
CRLF handling) and check exact equality against value (e.g., const lines =
s.split(/\r?\n/); return lines.includes(value)); update the exported function
name containsLine accordingly so single-line outputs and edges are handled
correctly.

Consolidates the duplicated bits across all five scripts/test-cli*.ts
harnesses into a small role-split module:

  scripts/test-cli/
    binaries.ts    — LOADER, BARE, REPL, TESTRUNNER, BUNDLER, BENCHRUNNER
    assertions.ts  — containsLine, normalizeLineEndings
    tmpdir.ts      — mkdtemp, makeTmpFactory, clean

Each consumer now imports only what it needs. The test-cli-helpers.ts
single-file shim added in the previous commit is removed; tmpdir-prefix
binding stays close to each harness via either makeTmpFactory("...")
(when one prefix per file) or mkdtemp("...") inline (when prefixes
differ per block, like test-cli.ts).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
@frostney frostney merged commit 3d0f5bb into main May 4, 2026
61 checks passed
@frostney frostney deleted the t3code/windows-print-fix branch May 4, 2026 16:59
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working internal Refactoring, CI, tooling, cleanup

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant