Skip to content

Make import.meta tests account for Windows drive letters#274

Merged
frostney merged 1 commit intomainfrom
t3code/fix-import-meta
Apr 11, 2026
Merged

Make import.meta tests account for Windows drive letters#274
frostney merged 1 commit intomainfrom
t3code/fix-import-meta

Conversation

@frostney
Copy link
Copy Markdown
Owner

  • Detect the current file URL drive letter in the module test
  • Expect import.meta.resolve() to include the drive prefix on Windows

- Detect the current file URL drive letter in the module test
- Expect `import.meta.resolve()` to include the drive prefix on Windows
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 11, 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: c2fe72ed-439b-454e-aba2-c7f1e3800fb2

📥 Commits

Reviewing files that changed from the base of the PR and between e4e09c5 and bea06b4.

📒 Files selected for processing (1)
  • tests/language/modules/import-meta.js

📝 Walkthrough

Walkthrough

This change modifies a test file to add Windows-specific handling for import.meta.resolve assertions. The code extracts the drive letter from import.meta.url on Windows and adjusts expected test values to account for the platform-specific file:///[DriveLetter]:/... URL format on Windows versus the standard file:///... format on other platforms.

Changes

Cohort / File(s) Summary
Test Platform Handling
tests/language/modules/import-meta.js
Added Windows-specific drive letter extraction from import.meta.url and updated import.meta.resolve test assertions for absolute paths and percent-encoded special characters to expect platform-dependent file URL prefixes.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~12 minutes

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 inconclusive)

Check name Status Explanation Resolution
Description check ❓ Inconclusive The description is incomplete. It addresses what was changed (drive letter detection and resolve expectations) but omits required template sections like Testing verification, documentation updates, and benchmark checks. Complete the description by adding the Testing section with checkboxes for regression testing, documentation updates, and optional Pascal test verification as specified in the repository template.
✅ Passed checks (2 passed)
Check name Status Explanation
Title check ✅ Passed The title accurately describes the main change: adding Windows drive letter handling to import.meta tests, which directly matches the file modifications.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

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


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

@frostney frostney added the bug Something isn't working label Apr 11, 2026
@github-actions
Copy link
Copy Markdown
Contributor

Benchmark Results

364 benchmarks

Interpreted: 🟢 267 improved · 🔴 19 regressed · 78 unchanged · avg +2.8%
Bytecode: 🟢 329 improved · 🔴 8 regressed · 27 unchanged · avg +8.9%

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

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

@github-actions
Copy link
Copy Markdown
Contributor

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 4618 4618
Tests Passed 4577 ✅ 4618 ✅
Tests Skipped 41 0
Tests Test Duration 325.4ms 303.0ms
Tests Lex 87.8ms 59.3ms
Tests Parse 115.2ms 112.9ms
Tests Compile 71.9ms
Tests Execute 340.8ms 334.1ms
Tests Engine Total 543.9ms 578.3ms
Benchmarks Total 364 364
Benchmarks Duration 10.03min 8.39min

Measured on ubuntu-latest x64.

@frostney frostney merged commit 452a318 into main Apr 11, 2026
9 checks passed
@frostney frostney deleted the t3code/fix-import-meta branch April 11, 2026 17:42
frostney added a commit that referenced this pull request Apr 11, 2026
Incorporates 5 commits from main:
- TextEncoder and TextDecoder built-ins (#272)
- Make import.meta tests account for Windows drive letters (#274)
- Fixes tagged template object identity (#275)
- Add Goccia.build platform metadata (#276)
- Add ToObject coercion for primitives across all Object.* static methods (#271)

Conflict resolution in 3 files (all "both sides added" — keep both):

Goccia.Engine.pas / Goccia.Runtime.Bootstrap.pas:
  - Added ggTextEncoder and ggTextDecoder to TGocciaGlobalBuiltin enum
  - Added both to DefaultGlobals alongside ggURL
  - Added FBuiltinTextEncoder/FBuiltinTextDecoder fields, Free calls,
    registration blocks, Expose* helpers, and constructor TypeDef blocks
    alongside the existing URL equivalents

Goccia.Values.ClassValue.pas:
  - Added TGocciaTextEncoderClassValue and TGocciaTextDecoderClassValue
    declarations, impl uses, and CreateNativeInstance implementations
    alongside the existing URL equivalents

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant