Skip to content

Add RegExp.escape static method#252

Merged
frostney merged 1 commit into
mainfrom
t3code/regexp-escape
Apr 10, 2026
Merged

Add RegExp.escape static method#252
frostney merged 1 commit into
mainfrom
t3code/regexp-escape

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 10, 2026

Summary

  • Adds RegExp.escape(string) as a static RegExp method, following the TC39 RegExp Escaping proposal.
  • Escapes regex syntax characters, class-set reserved punctuators, whitespace, and line terminators with the correct backslash or hex encodings.
  • Hex-encodes a leading ASCII letter or digit to avoid ambiguity with backreferences.
  • Updates the built-ins and language-restrictions docs to document the new API.
  • Adds end-to-end coverage for escaping behavior, mixed inputs, and regex usability.

Testing

  • Not run: ./build.pas testrunner && ./build/TestRunner tests
  • Not run: targeted inspection of the new tests/built-ins/RegExp/escape.js coverage for syntax characters, whitespace, class-set punctuators, and first-character rules
  • Not run: native Pascal test suite (./build.pas clean tests && for t in build/Goccia.*.Test; do "$t"; done)

@frostney
Add RegExp.escape support
6c3c4f7 
- Implement the TC39 RegExp Escaping proposal on RegExp
- Add end-to-end coverage and document the new static method
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 10, 2026 •
edited
Loading

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: a5d23ad8-2c0d-4053-a439-354474b00364

📥 Commits

Reviewing files that changed from the base of the PR and between 0a19834 and 6c3c4f7.

📒 Files selected for processing (4)
  • docs/built-ins.md
  • docs/language-restrictions.md
  • tests/built-ins/RegExp/escape.js
  • units/Goccia.Builtins.GlobalRegExp.pas
📝 Walkthrough

Walkthrough

This pull request adds the RegExp.escape() static method to the Goccia language. The implementation includes escape logic for regex syntax characters, helper routines for UTF-8 processing and hex encoding, comprehensive test coverage, and documentation of the new API and its escaping rules.

Changes

Cohort / File(s) Summary
Documentation
docs/built-ins.md, docs/language-restrictions.md		 Added documentation for RegExp.escape(string) static method, detailing escaping rules for regex-significant characters, hex-encoding for class-set punctuators and whitespace/line terminators, and avoidance of backreference ambiguity with leading digits or letters.
Implementation
units/Goccia.Builtins.GlobalRegExp.pas		 Introduced RegExpEscape method to the TGocciaGlobalRegExp builtin class. Added static member storage for RegExp constructor and helper routines for ECMAScript whitespace/line-terminator classification, UTF-8 code point decoding, and hex-encoding (\xHH, \uHHHH, surrogate pairs).
Tests
tests/built-ins/RegExp/escape.js		 Added comprehensive test suite validating RegExp.escape functionality: arity check, syntax character escaping, hex-encoding rules for first characters and class-set punctuators, whitespace/line-terminator handling, non-special character passthrough, mixed string patterns, type validation, and integration with RegExp object construction.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Suggested labels

new feature

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Description check ⚠️ Warning The description covers the summary and implementation details; however, it explicitly states that testing was not run and provides no test verification checkboxes marked as completed. Mark the testing checkboxes to indicate which tests were actually run or provide evidence that testing was performed before merge.
✅ Passed checks (2 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly and concisely describes the main change: adding a RegExp.escape static method, which matches the primary implementation, documentation, and test additions in the changeset.
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.

@coderabbitai coderabbitai Bot added the new feature New feature or request label Apr 10, 2026
@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 10, 2026

Benchmark Results

274 benchmarks

Interpreted: 🟢 220 improved · 🔴 7 regressed · 47 unchanged · avg +7.0%
Bytecode: 🟢 77 improved · 🔴 72 regressed · 125 unchanged · avg +0.3%

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

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

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 10, 2026

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 4153 4153
Tests Passed 4112 ✅ 4153 ✅
Tests Skipped 41 0
Tests Test Duration 322.7ms 284.7ms
Tests Lex 82.2ms 54.1ms
Tests Parse 106.3ms 101.6ms
Tests Compile — 64.2ms
Tests Execute 338.6ms 314.8ms
Tests Engine Total 527.1ms 534.8ms
Benchmarks Total 274 274
Benchmarks Duration 7.68min 6.49min

Measured on ubuntu-latest x64.

@frostney frostney merged commit c3d76f9 into main Apr 10, 2026
9 checks passed
@frostney frostney deleted the t3code/regexp-escape branch April 10, 2026 10:23
@frostney frostney added the spec compliance Mismatch against official JavaScript/TypeScript specification label Apr 10, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

new feature New feature or request spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@frostney