Skip to content

Skip unsupported generator methods during parsing#388

Merged
frostney merged 2 commits into
mainfrom
t3code/unsupported-generators-parsing
Apr 23, 2026
Merged

Skip unsupported generator methods during parsing#388
frostney merged 2 commits into
mainfrom
t3code/unsupported-generators-parsing

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 23, 2026

Summary

  • Teach the parser to recognize and skip unsupported generator methods in object literals and classes, including async and static variants.
  • Add handling for unsupported function declarations so they are skipped consistently during parsing.
  • Expand language tests to cover generator function expressions and generator methods across objects and classes.

- Add parser warnings and recovery for generator methods and function expressions
- Expand unsupported-feature tests for object and class generators
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 23, 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: 41ae8e20-d443-48ae-814b-7986ac6d4fd9

📥 Commits

Reviewing files that changed from the base of the PR and between 8f771c0 and 4b26caf.

📒 Files selected for processing (2)
  • source/units/Goccia.Parser.pas
  • tests/language/statements/unsupported-features.js
🚧 Files skipped from review as they are similar to previous changes (1)
  • tests/language/statements/unsupported-features.js

📝 Walkthrough

Walkthrough

Parser now recognizes and skips generator methods (*name() and async *name()) in object literals and class bodies, emitting unsupported-feature warnings. export function declarations are also treated as unsupported: the parser consumes the function signature to avoid downstream errors and emits a warning.

Changes

Cohort / File(s) Summary
Parser — generator & export handling
source/units/Goccia.Parser.pas
Detects generator methods in object literals and class bodies (regular and async forms). Emits unsupported warnings, skips name/generics/params/return-type and body. Treats export function declarations as unsupported and consumes the function signature to continue parsing.
Tests — unsupported features
tests/language/statements/unsupported-features.js
Adds tests asserting generator function expressions and generator/async-generator methods (object literals, class instance/static, reserved-word names) are skipped/produce undefined while surrounding non-generator code still executes as expected.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

🚥 Pre-merge checks | ✅ 3 | ❌ 2

❌ Failed checks (2 warnings)

Check name Status Explanation Resolution
Description check ⚠️ Warning The PR description covers the main changes but is missing the required Testing section with checkboxes as specified in the template. Add the Testing section with checkboxes to confirm testing was performed, documentation updates, and any applicable benchmark verification.
Docstring Coverage ⚠️ Warning Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (3 passed)
Check name Status Explanation
Title check ✅ Passed The title accurately reflects the main change: adding parser support to skip unsupported generator methods during parsing, which is the primary objective of the PR.
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.

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

Warning

Review ran into problems

🔥 Problems

Git: Failed to clone repository. Please run the @coderabbitai full review command to re-trigger a full review. If the issue persists, set path_filters to include or exclude specific files.


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 23, 2026
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

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

🧹 Nitpick comments (1)
source/units/Goccia.Parser.pas (1)

1803-1834: Generator method skip logic in object literals looks good overall.

The implementation correctly detects and skips generator methods (*methodName() { ... } and async *methodName() { ... }) in object literals by consuming the method name, generic parameters, parameter list, return type annotation, and body block.

One minor edge case: "object properties allow reserved words" as method names (e.g., { *if() { yield 1; } }). The current check at line 1818 handles gttIdentifier, gttString, and gttNumber, but reserved words may be tokenized differently (e.g., gttIf). This mirrors the pattern at lines 1880-1883 for regular properties, which includes an explicit list of reserved word tokens.

Since this is an obscure edge case for already-unsupported syntax, and the parser will likely produce a syntax error (which is acceptable behavior for unsupported constructs), this can be addressed in a follow-up if needed.

♻️ Optional: Handle reserved words as generator method names
       else if Check(gttIdentifier) or Check(gttString) or Check(gttNumber) then
-        Advance;
+        Advance
+      else if Match([gttIf, gttElse, gttConst, gttLet, gttClass, gttEnum, gttExtends, gttNew, gttThis, gttSuper, gttStatic,
+                     gttReturn, gttFor, gttWhile, gttDo, gttSwitch, gttCase, gttDefault, gttBreak,
+                     gttThrow, gttTry, gttCatch, gttFinally, gttImport, gttExport, gttFrom, gttAs,
+                     gttTrue, gttFalse, gttNull, gttTypeof, gttInstanceof, gttIn, gttDelete, gttVar, gttWith]) then
+        ; // Reserved word method name consumed by Match
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.

In `@source/units/Goccia.Parser.pas` around lines 1803 - 1834, The
generator-method branch (triggered by Check(gttStar) in the object-literal
parsing logic) currently accepts only Check(gttIdentifier), Check(gttString) or
Check(gttNumber) for the method name; extend that condition to also accept
reserved-word tokens (e.g., gttIf, gttFor, gttReturn, etc.) the same way regular
property parsing does (see the pattern used around the other property-handling
code), so reserved words used as generator method names are skipped
consistently; update the Check(...) list after the Advance that skips the star
to include the same reserved token set as the non-generator property handling.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@source/units/Goccia.Parser.pas`:
- Around line 1803-1834: The generator-method branch (triggered by
Check(gttStar) in the object-literal parsing logic) currently accepts only
Check(gttIdentifier), Check(gttString) or Check(gttNumber) for the method name;
extend that condition to also accept reserved-word tokens (e.g., gttIf, gttFor,
gttReturn, etc.) the same way regular property parsing does (see the pattern
used around the other property-handling code), so reserved words used as
generator method names are skipped consistently; update the Check(...) list
after the Advance that skips the star to include the same reserved token set as
the non-generator property handling.

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: a6d53383-cc5a-4461-b9e4-9fea6e2af00d

📥 Commits

Reviewing files that changed from the base of the PR and between a4afe7a and 8f771c0.

📒 Files selected for processing (2)
  • source/units/Goccia.Parser.pas
  • tests/language/statements/unsupported-features.js

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 23, 2026

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 7634 7634
Tests Passed 7593 ✅ 7634 ✅
Tests Skipped 41 0
Tests Workers 4 4
Tests Test Duration 1.71s 1.50s
Tests Lex (cumulative) 231.6ms 121.1ms
Tests Parse (cumulative) 328.3ms 280.7ms
Tests Compile (cumulative) 167.4ms
Tests Execute (cumulative) 1.77s 1.54s
Tests Engine Total (cumulative) 2.33s 2.11s
Tests Lex (avg/worker) 57.9ms 30.3ms
Tests Parse (avg/worker) 82.1ms 70.2ms
Tests Compile (avg/worker) 41.8ms
Tests Execute (avg/worker) 443.5ms 384.3ms
Tests Engine Total (avg/worker) 583.5ms 526.6ms
Benchmarks Total 386 386
Benchmarks Workers 4 4
Benchmarks Duration 2.93min 2.82min

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 23, 2026

Benchmark Results

386 benchmarks

Interpreted: 🟢 20 improved · 🔴 289 regressed · 77 unchanged · avg -3.8%
Bytecode: 🟢 90 improved · 🔴 68 regressed · 228 unchanged · avg +0.4%

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

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.

- Skip generator method names that use reserved words
- Add regression coverage for object literal generator methods
@frostney frostney merged commit 5968bb0 into main Apr 23, 2026
10 checks passed
@frostney frostney deleted the t3code/unsupported-generators-parsing branch April 23, 2026 11:41
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

new feature New feature or request

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant