Skip to content

Recompute ZonedDateTime UTC offset after rounding (#358)#362

Merged
frostney merged 2 commits into
mainfrom
t3code/issue-358-fix
Apr 20, 2026
Merged

Recompute ZonedDateTime UTC offset after rounding (#358)#362
frostney merged 2 commits into
mainfrom
t3code/issue-358-fix

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 20, 2026

Summary

  • Fixes ZonedDateTimeToString: recompute UTC offset after rounding (DST boundary correctness) #358: ZonedDateTimeToString now recomputes the UTC offset after RoundTimeForToString (and any day carry), ensuring the formatted string reflects the correct offset for the rounded instant rather than the pre-rounding one.
  • Uses LocalToEpochMs to derive the rounded epoch, then calls GetUtcOffsetSeconds on it.
  • Adds two tests verifying correct offset after rounding-induced day carry (UTC and fixed-offset +05:30).

🤖 Generated with Claude Code

- Fix `toString()` when rounding carries into a new day
- Add regression tests for UTC and fixed-offset zones
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 20, 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: 3595212b-9eea-4853-8324-f0475de790d8

📥 Commits

Reviewing files that changed from the base of the PR and between 299cd6b and 2dd0bff.

📒 Files selected for processing (2)
  • source/units/Goccia.Values.TemporalZonedDateTime.pas
  • tests/built-ins/Temporal/ZonedDateTime/prototype/toString.js
🚧 Files skipped from review as they are similar to previous changes (2)
  • source/units/Goccia.Values.TemporalZonedDateTime.pas
  • tests/built-ins/Temporal/ZonedDateTime/prototype/toString.js

📝 Walkthrough

Walkthrough

Defers UTC offset recomputation in ZonedDateTimeToString until after rounding that may change the local date/time; recomputes epoch-ms and offset only when rounding alters wall-clock fields. Adds tests validating offset behavior for UTC and fixed-offset zones when rounding causes day carry and when it does not.

Changes

Cohort / File(s) Summary
ZonedDateTime offset recomputation
source/units/Goccia.Values.TemporalZonedDateTime.pas
ZonedDateTimeToString now saves pre-round local components, calls RoundTimeForToString, and only recomputes RoundedEpochMs via LocalToEpochMs and OffsetSeconds when rounding changed local fields; otherwise reuses original epoch-derived offset.
toString rounding boundary tests
tests/built-ins/Temporal/ZonedDateTime/prototype/toString.js
Added three tests: two asserting { fractionalSecondDigits: 0, roundingMode: "halfExpand" } recomputes the displayed offset when day-carry rounding occurs (UTC and +05:30), and one asserting no-offset-change when no rounding occurs (fractionalSecondDigits: 9).

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title accurately describes the main change: recomputing the ZonedDateTime UTC offset after rounding, directly addressing the core problem in linked issue #358.
Description check ✅ Passed The description covers the key aspects: fix summary with issue reference, implementation approach using LocalToEpochMs and GetUtcOffsetSeconds, and test additions for offset correctness.
Linked Issues check ✅ Passed The pull request fully addresses the requirements from issue #358: recomputing OffsetSeconds after RoundTimeForToString completes, handling ExtraDays carry, and using LocalToEpochMs with GetUtcOffsetSeconds to derive the correct offset for the rounded instant.
Out of Scope Changes check ✅ Passed All changes are directly scoped to resolving issue #358: modifications to ZonedDateTimeToString offset computation logic and addition of related tests for rounding-induced day carry scenarios.
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 spec compliance Mismatch against official JavaScript/TypeScript specification label Apr 20, 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.

Actionable comments posted: 1

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

Inline comments:
In `@source/units/Goccia.Values.TemporalZonedDateTime.pas`:
- Around line 1149-1153: The code recomputes the UTC offset unconditionally by
calling LocalToEpochMs and GetUtcOffsetSeconds even when RoundTimeForToString
produced no change; this can flip the DST fold for ambiguous times. Add a guard
that computes a RoundedChanged boolean by comparing the pre-round local fields
(DateRec.Year/Month/Day, LHour/LMinute/LSecond/LMs) plus ExtraDays against the
post-round values, and only call LocalToEpochMs to set RoundedEpochMs and
recompute OffsetSeconds via GetUtcOffsetSeconds when RoundedChanged is true;
otherwise preserve the original offset from the input epoch. Ensure you
reference RoundTimeForToString, LocalToEpochMs, RoundedEpochMs, OffsetSeconds,
GetUtcOffsetSeconds and ExtraDays when implementing the guard.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

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

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: d468eaea-5756-4808-9298-8efacbab4475

📥 Commits

Reviewing files that changed from the base of the PR and between d916c80 and 299cd6b.

📒 Files selected for processing (2)
  • source/units/Goccia.Values.TemporalZonedDateTime.pas
  • tests/built-ins/Temporal/ZonedDateTime/prototype/toString.js

Comment thread source/units/Goccia.Values.TemporalZonedDateTime.pas Outdated
@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 20, 2026

Benchmark Results

386 benchmarks

Interpreted: 🟢 30 improved · 🔴 111 regressed · 245 unchanged · avg -1.5%
Bytecode: 🟢 311 improved · 🔴 12 regressed · 63 unchanged · avg +9.7%

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

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

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 5834 5834
Tests Passed 5793 ✅ 5834 ✅
Tests Skipped 41 0
Tests Workers 4 4
Tests Test Duration 1.30s 1.00s
Tests Lex (cumulative) 176.4ms 88.0ms
Tests Parse (cumulative) 235.4ms 178.7ms
Tests Compile (cumulative) 122.9ms
Tests Execute (cumulative) 1.16s 874.1ms
Tests Engine Total (cumulative) 1.57s 1.26s
Tests Lex (avg/worker) 44.1ms 22.0ms
Tests Parse (avg/worker) 58.9ms 44.7ms
Tests Compile (avg/worker) 30.7ms
Tests Execute (avg/worker) 289.6ms 218.5ms
Tests Engine Total (avg/worker) 392.5ms 316.0ms
Benchmarks Total 386 386
Benchmarks Workers 4 4
Benchmarks Duration 3.04min 2.91min

Measured on ubuntu-latest x64.

Only recompute the UTC offset via LocalToEpochMs when rounding actually
changed the local time components. Unconditional re-resolution through
LocalToEpochMs uses first-match disambiguation, which can flip the fold
for ambiguous wall-clock times during DST fall-back.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@frostney frostney merged commit 4817f78 into main Apr 20, 2026
10 checks passed
@frostney frostney deleted the t3code/issue-358-fix branch April 20, 2026 10:39
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

ZonedDateTimeToString: recompute UTC offset after rounding (DST boundary correctness)

1 participant