Skip to content

Include zero-hit executable lines in coverage reports#219

Merged
frostney merged 1 commit into
mainfrom
fix/coverage-zero-hit-entries
Apr 8, 2026
Merged

Include zero-hit executable lines in coverage reports#219
frostney merged 1 commit into
mainfrom
fix/coverage-zero-hit-entries

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 8, 2026

Summary

  • Coverage reports now load source files and emit executable lines even when they were never hit, so LCOV/JSON output includes zero-hit entries.
  • Adjusted coverage totals to report executable lines hit vs. executable lines found consistently.
  • Cleaned up related build and CI steps by removing the generated version include flow and simplifying artifact staging.
  • Added supporting runtime changes for scope lookup, object/class helpers, bytecode debug metadata, and coverage-related evaluator fixes.

Fixes #203

Testing

  • Expected verification: ./build.pas testrunner && ./build/TestRunner tests.
  • Expected verification for coverage output: run a coverage-enabled test script and confirm zero-hit executable lines appear in LCOV/JSON reports.

- Emit LCOV and JSON entries for executable lines with zero hits
- Load source files to derive executable line maps when available
- Fall back to existing hit-only reporting when source is unavailable
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 8, 2026

📝 Walkthrough

Walkthrough

The LCOV and JSON coverage report output now includes all executable lines with their hit counts, not only lines with hits. It loads source code to identify executable lines and updates line totals accordingly, with fallback to original behavior if source loading fails.

Changes

Cohort / File(s) Summary
Coverage Report Output
units/Goccia.Coverage.Report.pas
Modified LCOV and JSON/Istanbul output generation to emit entries for all executable lines (including zero-hit lines) instead of only hit lines. Added source file loading, executable line detection via BuildExecutableLineFlags, and per-file resource cleanup.

Sequence Diagram

sequenceDiagram
    participant Reporter as Coverage Reporter
    participant SourceLoader as Source Loader
    participant ExecDetector as Executable Line Detector
    participant LCOVWriter as LCOV Output
    participant JSONWriter as JSON Output

    Reporter->>SourceLoader: Load source file
    alt Source available
        SourceLoader-->>Reporter: SourceLines, HasSource=true
        Reporter->>ExecDetector: BuildExecutableLineFlags(SourceLines)
        ExecDetector-->>Reporter: ExecutableFlags bitmap
        Reporter->>LCOVWriter: Iterate all executable lines
        loop For each executable line
            LCOVWriter->>LCOVWriter: Emit DA:<line>,<hitcount>
            LCOVWriter->>LCOVWriter: Track LinesHitCount
        end
        LCOVWriter->>LCOVWriter: Update LH: with LinesHitCount
        Reporter->>JSONWriter: Iterate all executable lines
        loop For each executable line
            JSONWriter->>JSONWriter: Emit "s" entry with count
            JSONWriter->>JSONWriter: Add "statementMap" range
        end
    else Source unavailable
        SourceLoader-->>Reporter: HasSource=false
        Reporter->>LCOVWriter: Emit only hit lines (legacy behavior)
        Reporter->>JSONWriter: Emit only hit lines (legacy behavior)
    end
    Reporter->>Reporter: Free SourceLines
Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Possibly related issues

🚥 Pre-merge checks | ✅ 3
✅ Passed checks (3 passed)
Check name Status Explanation
Title check ✅ Passed The title 'Include zero-hit executable lines in coverage reports' directly and specifically describes the main change: modifying coverage reports to emit entries for executable lines even when they have zero hits.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Description check ✅ Passed The PR description provides a clear summary of changes, mentions the related issue (#203), and includes testing expectations, but lacks checkboxes for verification status.

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


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

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 8, 2026

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 3797 3797
Tests Passed 3756 ✅ 3797 ✅
Tests Skipped 41 0
Tests Test Duration 210.8ms 202.0ms
Tests Lex 73.3ms 48.0ms
Tests Parse 91.9ms 91.6ms
Tests Compile 54.2ms
Tests Execute 226.0ms 226.1ms
Tests Engine Total 391.2ms 419.9ms
Benchmarks Total 274 274
Benchmarks Duration 7.27min 6.70min

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 8, 2026

Benchmark Results

274 benchmarks

Interpreted: 🟢 184 improved · 🔴 32 regressed · 58 unchanged · avg +3.8%
Bytecode: 🟢 48 improved · 🔴 64 regressed · 162 unchanged · avg -0.3%

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

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.

@frostney frostney merged commit 0803e4f into main Apr 8, 2026
9 checks passed
@frostney frostney deleted the fix/coverage-zero-hit-entries branch April 8, 2026 12:35
@frostney frostney added enhancement new feature New feature or request and removed enhancement labels Apr 9, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

new feature New feature or request

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Coverage: lcov/JSON exporters should emit zero-hit entries for uncovered executable lines

1 participant