Skip to content

Implement Intl formatToParts decomposition#690

Merged
frostney merged 2 commits into
mainfrom
issue-597-intl-format-to-parts
May 30, 2026
Merged

Implement Intl formatToParts decomposition#690
frostney merged 2 commits into
mainfrom
issue-597-intl-format-to-parts

Conversation

@frostney
Copy link
Copy Markdown
Owner

Summary

Testing

  • Verified no regressions and confirmed the new feature or bugfix in end-to-end JavaScript/TypeScript tests
  • Updated documentation
  • Optional: Verified no regressions and confirmed the new feature or bugfix in native Pascal tests (if AST, scope, evaluator, or value types changed)
  • Optional: Verified no benchmark regressions or confirmed benchmark coverage for the change

Commands run:

  • ./build.pas clean testrunner && ./build.pas testrunner
  • ./build.pas loader
  • ./build.pas testrunner && ./build/GocciaTestRunner tests/built-ins/Intl/ListFormat/prototype/formatToParts.js tests/built-ins/Intl/RelativeTimeFormat/prototype/formatToParts.js tests/built-ins/Intl/NumberFormat/prototype/formatToParts.js tests/built-ins/Intl/DateTimeFormat/prototype/formatToParts.js
  • ./format.pas --check
  • ./fixtures/ffi/build.sh && ./build.pas testrunner && ./build/GocciaTestRunner tests

@vercel
Copy link
Copy Markdown

vercel Bot commented May 29, 2026

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment
Project Deployment Actions Updated (UTC)
gocciascript-homepage Ignored Ignored Preview May 30, 2026 7:56am

Request Review

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented May 29, 2026

Review Change Stack

📝 Walkthrough

Walkthrough

This PR extends Intl.ListFormat and Intl.RelativeTimeFormat to support formatToParts by adding ICU result-based field-to-parts conversion, CLDR fallback helpers, and auto-naming for relative time numeric: 'auto' mode. The implementation introduces new type fields, ICU constants and bindings, and updates both format implementations with proper part decomposition.

Changes

Intl formatToParts for List and Relative Time

Layer / File(s) Summary
Data type and property foundation
source/shared/IntlTypes.pas, source/units/Goccia.Constants.PropertyNames.pas, source/units/Goccia.Intl.Helpers.pas
TIntlFormatPart adds UnitIdentifier field; new PROP_UNIT constant; FormatPartsToArray conditionally emits unit property when UnitIdentifier is non-empty.
ICU field categories and mapping helpers
source/shared/IntlICU.pas
New ICU field category constants (ULISTFMT, UDAT_REL) and field identifiers; helpers to map list field IDs to type strings, normalize relative time units, and check field span containment.
ICU result-based API bindings and symbol loading
source/shared/IntlICU.pas
Public functions TryICUFormatListToParts and TryICUFormatRelativeTimeToParts; ICU function prototypes for result-based list and relative-time formatting; dynamic symbol resolution for new functions.
ICU field-to-parts conversion core
source/shared/IntlICU.pas
Field span iteration from ICU formatted values; relative-time-specific part construction with numeric detection, sign normalization, and unit identifier injection; UnitIdentifier initialization on format parts.
List format formatToParts with ICU and CLDR
source/units/Goccia.Values.IntlListFormat.pas
CLDR list-parts helpers parse templates into ordered literal and element parts; TryICUFormatListToParts implementation; formatToParts prefers ICU parts, falls back to CLDR-constructed parts via FormatPartsToArray.
Relative time format formatToParts with auto-naming
source/units/Goccia.Values.IntlRelativeTimeFormat.pas
Auto-name helper generates "today/yesterday/next week" for numeric: 'auto'; TryICUFormatRelativeTime branches on numeric mode; fallback parts construction locates number substrings and extracts via TryICUFormatNumberToParts; TryICUFormatRelativeTimeToParts implementation; integrated into format and formatToParts with ICU-first, fallback-second flow.
Conformance test coverage
tests/built-ins/Intl/ListFormat/prototype/formatToParts.js, tests/built-ins/Intl/RelativeTimeFormat/prototype/formatToParts.js
ListFormat tests verify part decomposition, separator literals, and non-misclassification of element text; RelativeTimeFormat tests verify integer/fractional decomposition, unit identifiers, numeric: 'auto' literal output, and alignment with format() results.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Possibly related issues

  • frostney/GocciaScript#597: Directly addresses formatToParts returning single literal instead of decomposed parts; this PR implements field-to-parts decomposition for ListFormat and RelativeTimeFormat using ICU field position iteration.

Possibly related PRs

  • frostney/GocciaScript#658: Both PRs extend IntlICU.pas with ICU "to parts" support using the same field-to-TIntlFormatPartArray conversion machinery; #658 adds NumberFormat and DateTimeFormat formatToParts, this PR adds ListFormat and RelativeTimeFormat.

Suggested labels

new feature, spec compliance

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title 'Implement Intl formatToParts decomposition' clearly and concisely summarizes the main objective of adding formatToParts decomposition support across Intl formatters.
Description check ✅ Passed The PR description addresses the template requirements with a clear summary of changes, linked issue reference, and detailed testing verification including multiple test runs and commands.
Linked Issues check ✅ Passed The changes fully implement the objectives from #597: ICU formatToParts paths added for ListFormat and RelativeTimeFormat with proper field decomposition, fallback logic preserved, and comprehensive test coverage included.
Out of Scope Changes check ✅ Passed All changes are directly aligned with issue #597 objectives: ICU integration for formatToParts, new helper functions, test coverage, and type updates are all within the documented scope.
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.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 29, 2026

Benchmark Results

407 benchmarks

Interpreted: 🟢 359 improved · 🔴 17 regressed · 31 unchanged · avg +13.2%
Bytecode: 🟢 73 improved · 🔴 54 regressed · 280 unchanged · avg +0.7%

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

Deterministic profile diff

Deterministic profile diff: no significant changes.

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 May 29, 2026

Suite Timing

Test Runner (interpreted: 9,841 passed; bytecode: 9,841 passed)
Metric Interpreted Bytecode
Total 9841 9841
Passed 9841 ✅ 9841 ✅
Workers 4 4
Test Duration 3.21s 3.21s
Lex (cumulative) 465.3ms 411.5ms
Parse (cumulative) 323.6ms 305.0ms
Compile (cumulative) 589.8ms
Execute (cumulative) 3.25s 3.27s
Engine Total (cumulative) 4.04s 4.58s
Lex (avg/worker) 116.3ms 102.9ms
Parse (avg/worker) 80.9ms 76.3ms
Compile (avg/worker) 147.4ms
Execute (avg/worker) 813.0ms 818.3ms
Engine Total (avg/worker) 1.01s 1.14s

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Test runner worker shutdown frees thread-local heaps in bulk; that shutdown reclamation is not counted as GC collections or collected objects.

Metric Interpreted Bytecode
GC Live 286.67 MiB 279.11 MiB
GC Peak Live 286.68 MiB 279.12 MiB
GC Allocated During Run 291.20 MiB 283.63 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1 1
GC Collected Objects 87 87
Heap Start Allocated 160.3 KiB 160.3 KiB
Heap End Allocated 1.54 MiB 1.54 MiB
Heap Delta Allocated 1.38 MiB 1.38 MiB
Heap Delta Free 890.6 KiB 890.6 KiB
Benchmarks (interpreted: 407; bytecode: 407)
Metric Interpreted Bytecode
Total 407 407
Workers 4 4
Duration 2.44min 2.40min

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Benchmark runner performs explicit between-file collections, so collection and collected-object counts can be much higher than the test runner.

Metric Interpreted Bytecode
GC Live 3.97 MiB 3.97 MiB
GC Peak Live 132.13 MiB 78.29 MiB
GC Allocated During Run 16.77 GiB 10.64 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 2,814 2,665
GC Collected Objects 266,327,809 238,406,805
Heap Start Allocated 1.27 MiB 1.27 MiB
Heap End Allocated 1.27 MiB 1.27 MiB
Heap Delta Allocated 128 B 128 B

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 29, 2026

test262 Conformance

Category Run Passed Δ Pass Failed Pass-rate Δ Rate
built-ins 23,449 16,070 +1 7,374 68.5% ±0pp
harness 116 72 ±0 44 62.1% ±0pp
intl402 3,324 959 +2 2,365 28.9% +0.1pp
language 23,635 14,631 ±0 9,004 61.9% ±0pp
staging 1,484 573 ±0 908 38.6% ±0pp
total 52,008 32,305 +3 19,695 62.1% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/WeakMap 99.3% ±0pp 140 / 141
language/asi 99.0% ±0pp 101 / 102
built-ins/WeakSet 98.8% ±0pp 84 / 85
Per-test deltas (+3 / -0)

Newly passing (3):

  • built-ins/Number/prototype/toExponential/undefined-fractiondigits.js
  • intl402/RelativeTimeFormat/prototype/formatToParts/result-type.js
  • intl402/RelativeTimeFormat/prototype/formatToParts/unit-plural.js

Steady-state failures are non-blocking; regressions vs the cached main baseline (lower total pass count, or any PASS → non-PASS transition) fail the conformance gate. Measured on ubuntu-latest x64, bytecode mode. Areas grouped by the first two test262 path components; minimum 25 attempted tests, areas already at 100% excluded. Δ vs main compares against the most recent cached main baseline.

@frostney frostney force-pushed the issue-597-intl-format-to-parts branch from 9b63d46 to 6a31094 Compare May 30, 2026 05:32
@frostney frostney marked this pull request as ready for review May 30, 2026 06:37
@coderabbitai coderabbitai Bot added new feature New feature or request spec compliance Mismatch against official JavaScript/TypeScript specification labels May 30, 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 current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@source/units/Goccia.Values.IntlListFormat.pas`:
- Around line 178-207: AppendListPart currently returns early when AValue = ''
which causes FormatListElementPart to omit element parts for empty-string list
items; modify AppendListPart (or alternatively modify FormatListElementPart) so
that element parts are always emitted: remove or guard the early Exit in
AppendListPart so that when AType = 'element' it still appends a part with Value
= '' (i.e., only skip appending for empty AValue when AType is not 'element'),
keeping the rest of the field assignments (PartType, Value, Source,
UnitIdentifier) intact.
🪄 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: 39886939-d162-4a9e-b949-6d219806daee

📥 Commits

Reviewing files that changed from the base of the PR and between 7d3896a and 6a31094.

📒 Files selected for processing (8)
  • source/shared/IntlICU.pas
  • source/shared/IntlTypes.pas
  • source/units/Goccia.Constants.PropertyNames.pas
  • source/units/Goccia.Intl.Helpers.pas
  • source/units/Goccia.Values.IntlListFormat.pas
  • source/units/Goccia.Values.IntlRelativeTimeFormat.pas
  • tests/built-ins/Intl/ListFormat/prototype/formatToParts.js
  • tests/built-ins/Intl/RelativeTimeFormat/prototype/formatToParts.js

Comment thread source/units/Goccia.Values.IntlListFormat.pas
@frostney frostney merged commit 0523969 into main May 30, 2026
14 checks passed
@frostney frostney deleted the issue-597-intl-format-to-parts branch May 30, 2026 09:07
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

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

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Intl: formatToParts returns single literal instead of decomposed parts

1 participant