Skip to content

Validate Temporal.Duration field magnitudes#328

Merged
frostney merged 2 commits into
mainfrom
t3code/issue-326
Apr 17, 2026
Merged

Validate Temporal.Duration field magnitudes#328
frostney merged 2 commits into
mainfrom
t3code/issue-326

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 17, 2026

Summary

  • Add Temporal.Duration magnitude checks for calendar fields so years, months, and weeks reject absolute values at or above 2^32.
  • Add normalized time validation so the combined day/time portion rejects values whose normalized seconds reach 2^53 or more.
  • Introduce matching range error messages and suggestions for the new Temporal validation failures.
  • Add coverage for constructor and Temporal.Duration.from() object-form validation, including boundary cases just below and at the limits.

Fixes #326

- Enforce 2^32 calendar-unit limits and 2^53 normalized time limits
- Add Temporal.Duration magnitude validation coverage
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 17, 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: b4346b00-1c8e-44e4-b1d5-88d5258ac01b

📥 Commits

Reviewing files that changed from the base of the PR and between 9cc0689 and f161385.

📒 Files selected for processing (1)
  • tests/built-ins/Temporal/Duration/magnitude-validation.js
🚧 Files skipped from review as they are similar to previous changes (1)
  • tests/built-ins/Temporal/Duration/magnitude-validation.js

📝 Walkthrough

Walkthrough

Adds TC39 Temporal.Duration magnitude validation: constructor and Duration.from() now enforce calendar-unit absolute value < 2^32 and normalized time seconds absolute value < 2^53; includes new test coverage and two new error/suggestion resource strings.

Changes

Cohort / File(s) Summary
Tests
tests/built-ins/Temporal/Duration/magnitude-validation.js
New conditional test suite asserting RangeError for calendar fields at ±2^32, valid behavior just below that threshold, and normalized-time checks hitting ±2^53; also tests Temporal.Duration.from() object-form behavior.
Error messages & suggestions
units/Goccia.Error.Messages.pas, units/Goccia.Error.Suggestions.pas
Added SErrorDurationCalendarOutOfRange and SErrorDurationTimeOutOfRange messages and SSuggestTemporalDurationRange suggestion string describing the numeric constraints.
Implementation
units/Goccia.Values.TemporalDuration.pas
Added magnitude validation in TGocciaTemporalDurationValue.Create: reject years/months/weeks with

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 clearly summarizes the main change: adding validation for Temporal.Duration field magnitudes, which aligns with the core objective of the PR.
Description check ✅ Passed The description covers the main objectives (magnitude checks for calendar fields and normalized time validation), mentions related messages/suggestions, and references the linked issue #326, though it lacks explicit testing confirmation checkboxes.
Linked Issues check ✅ Passed The PR implements all coding requirements from issue #326: validates calendar units (years/months/weeks) against 2^32 threshold in TGocciaTemporalDurationValue.Create, validates normalized time against 2^53 threshold, and provides test coverage for both constructor and Temporal.Duration.from() with boundary cases.
Out of Scope Changes check ✅ Passed All changes are scoped to implementing TC39 Temporal Duration magnitude validation: error messages, validation logic in constructor, and comprehensive test coverage directly support the linked issue #326 requirements without unrelated modifications.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

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


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

@coderabbitai coderabbitai Bot added the spec compliance Mismatch against official JavaScript/TypeScript specification label Apr 17, 2026
@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 17, 2026

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 5438 5438
Tests Passed 5397 ✅ 5438 ✅
Tests Skipped 41 0
Tests Workers 4 4
Tests Test Duration 802.1ms 902.9ms
Tests Lex (cumulative) 224.2ms 155.8ms
Tests Parse (cumulative) 249.2ms 259.3ms
Tests Compile (cumulative) 155.2ms
Tests Execute (cumulative) 931.3ms 944.0ms
Tests Engine Total (cumulative) 1.40s 1.51s
Tests Lex (avg/worker) 56.1ms 39.0ms
Tests Parse (avg/worker) 62.3ms 64.8ms
Tests Compile (avg/worker) 38.8ms
Tests Execute (avg/worker) 232.8ms 236.0ms
Tests Engine Total (avg/worker) 351.2ms 378.6ms
Benchmarks Total 364 364
Benchmarks Workers 4 4
Benchmarks Duration 3.04min 2.73min

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 17, 2026

Benchmark Results

364 benchmarks

Interpreted: 🟢 284 improved · 🔴 16 regressed · 64 unchanged · avg +6.9%
Bytecode: 🟢 74 improved · 🔴 76 regressed · 214 unchanged · avg -0.6%

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

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.

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)
tests/built-ins/Temporal/Duration/magnitude-validation.js (1)

47-67: Consider adding a negative time overflow test.

The calendar unit tests cover both positive and negative boundaries (lines 11-45), but the normalized time overflow tests only cover positive cases. For symmetry and completeness, consider adding a negative time overflow test.

🧪 Optional: Add negative time overflow test
   test("moderate day count is valid", () => {
     // 1000 days = 86,400,000 normalized seconds, well under 2^53
     const d = new Temporal.Duration(0, 0, 0, 1000);
     expect(d.days).toBe(1000);
   });
+
+  test("negative days producing normalized seconds <= -(2^53) throws RangeError", () => {
+    expect(() => new Temporal.Duration(0, 0, 0, -104251000000)).toThrow(RangeError);
+  });
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.

In `@tests/built-ins/Temporal/Duration/magnitude-validation.js` around lines 47 -
67, Add a symmetric negative overflow test to the Temporal.Duration
magnitude-validation suite: mirror one of the positive overflow cases (e.g., the
"days producing normalized seconds >= 2^53 throws RangeError" test) by creating
a Duration with a large negative field (for example, days: -104251000000) and
assert it throws RangeError; reference the Temporal.Duration constructor and the
existing positive tests in this file so the new test follows the same pattern
and message style (you can also add analogous negative checks for hours and
seconds using -2502000000000 and -9007199254740992 respectively if you want full
parity).
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@tests/built-ins/Temporal/Duration/magnitude-validation.js`:
- Around line 47-67: Add a symmetric negative overflow test to the
Temporal.Duration magnitude-validation suite: mirror one of the positive
overflow cases (e.g., the "days producing normalized seconds >= 2^53 throws
RangeError" test) by creating a Duration with a large negative field (for
example, days: -104251000000) and assert it throws RangeError; reference the
Temporal.Duration constructor and the existing positive tests in this file so
the new test follows the same pattern and message style (you can also add
analogous negative checks for hours and seconds using -2502000000000 and
-9007199254740992 respectively if you want full parity).

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: e6825ee7-e8ba-4376-8f39-0abf48e55fd6

📥 Commits

Reviewing files that changed from the base of the PR and between 54369e3 and 9cc0689.

📒 Files selected for processing (4)
  • tests/built-ins/Temporal/Duration/magnitude-validation.js
  • units/Goccia.Error.Messages.pas
  • units/Goccia.Error.Suggestions.pas
  • units/Goccia.Values.TemporalDuration.pas

- Cover day and hour normalization paths
- Assert RangeError at the negative 2^53 boundary
@frostney frostney merged commit 3b3d750 into main Apr 17, 2026
10 checks passed
@frostney frostney deleted the t3code/issue-326 branch April 17, 2026 20:31
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.

Add TC39 Temporal Duration magnitude validation in constructor and DurationFromObject

1 participant