Skip to content

Route Reflect.set receiver [[DefineOwnProperty]] through TryDefineProperty#247

Merged
frostney merged 1 commit into
mainfrom
fix/reflect-set-proxy-receiver-define-property
Apr 9, 2026
Merged

Route Reflect.set receiver [[DefineOwnProperty]] through TryDefineProperty#247
frostney merged 1 commit into
mainfrom
fix/reflect-set-proxy-receiver-define-property

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 9, 2026

Summary

  • Add virtual TryDefineProperty / TryDefineSymbolProperty boolean API to TGocciaObjectValue that returns false instead of throwing on non-configurable conflicts or non-extensible objects (ES2026 §10.1.6.1)
  • Override both in TGocciaProxyValue to dispatch through the proxy's defineProperty trap, returning the trap's boolean result
  • Replace in-place descriptor mutations and direct DefineProperty calls in AssignPropertyWithReceiver / AssignSymbolPropertyWithReceiver with TryDefineProperty / TryDefineSymbolProperty, fixing both string-keyed and symbol-keyed paths

Fixes #246.

Test plan

  • 7 new test cases in tests/built-ins/Reflect/set.js covering proxy receiver defineProperty trap dispatch (create, update, false return), symbol keys, and non-configurable writable value update
  • All 97 Reflect tests pass
  • Full test suite passes (3990/3990, 7 pre-existing ASI failures)
  • All 16 Pascal unit tests pass
  • Formatter check passes

🤖 Generated with Claude Code

…perty

Fixes #246. AssignPropertyWithReceiver and AssignSymbolPropertyWithReceiver
previously mutated receiver descriptors in-place and called DefineProperty
directly, bypassing the proxy defineProperty trap and throwing instead of
returning false on conflicts. Add virtual TryDefineProperty /
TryDefineSymbolProperty boolean API that returns false on non-configurable
conflicts or non-extensible objects, override both in TGocciaProxyValue to
dispatch through the defineProperty trap, and route all receiver-side
[[DefineOwnProperty]] calls through the new API.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 9, 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: 6b7c068c-fd42-4bae-86d8-6d821839b18d

📥 Commits

Reviewing files that changed from the base of the PR and between ad97ce9 and 579d5d0.

📒 Files selected for processing (3)
  • tests/built-ins/Reflect/set.js
  • units/Goccia.Values.ObjectValue.pas
  • units/Goccia.Values.ProxyValue.pas

📝 Walkthrough

Walkthrough

This PR implements a non-throwing property definition API (TryDefineProperty and TryDefineSymbolProperty) to correctly route Reflect.set operations through proxy defineProperty traps. It adds boolean-returning methods to ordinary and proxy objects, updates assignment paths to use the new API, and includes test coverage for proxy receiver behavior.

Changes

Cohort / File(s) Summary
Test Coverage
tests/built-ins/Reflect/set.js
Added 85 lines of test cases covering Reflect.set behavior with Proxy receivers, including trap invocation for property creation/update, descriptor propagation, trap result handling, and edge cases with non-configurable and non-extensible receivers.
Object Property Definition API
units/Goccia.Values.ObjectValue.pas
Introduced TryDefineProperty and TryDefineSymbolProperty boolean methods implementing non-throwing [[DefineOwnProperty]] semantics. Updated AssignPropertyWithReceiver and AssignSymbolPropertyWithReceiver to call these methods instead of in-place mutation or direct DefineProperty calls, with control flow for non-configurable and non-extensible object cases.
Proxy Trap Dispatch
units/Goccia.Values.ProxyValue.pas
Added override implementations of TryDefineProperty and TryDefineSymbolProperty that dispatch through the proxy's defineProperty trap, construct descriptor objects matching trap expectations, and return boolean results directly instead of throwing on falsy outcomes. Falls back to target's try-define methods when no trap exists.

Sequence Diagram

sequenceDiagram
    actor Test
    participant ReflectSet as Reflect.set
    participant Assignment as AssignPropertyWithReceiver
    participant Receiver as Receiver (Proxy)
    participant Trap as defineProperty Trap

    Test->>ReflectSet: set(target, prop, value, receiver)
    ReflectSet->>Assignment: AssignPropertyWithReceiver(...)
    Assignment->>Receiver: TryDefineProperty(prop, descriptor)
    Receiver->>Trap: InvokeTrap (descriptor as object)
    Trap-->>Receiver: returns boolean or truthy/falsy
    Receiver-->>Assignment: Boolean result
    Assignment-->>ReflectSet: Propagate boolean result
    ReflectSet-->>Test: return true/false
Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~50 minutes

Possibly related issues

Possibly related PRs

  • PR #243 — Related through shared modifications to AssignPropertyWithReceiver/AssignSymbolPropertyWithReceiver receiver paths and proxy defineProperty dispatch logic, building on the optional receiver foundation with correct trap error semantics.
🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title accurately describes the main change: routing Reflect.set receiver [[DefineOwnProperty]] through a new TryDefineProperty API.
Description check ✅ Passed The description covers the main changes, references issue #246, and includes comprehensive testing confirmation against the template requirements.
Linked Issues check ✅ Passed All core requirements from issue #246 are met: TryDefineProperty/TryDefineSymbolProperty APIs added to TGocciaObjectValue, overridden in TGocciaProxyValue with trap dispatch, and both AssignPropertyWithReceiver and AssignSymbolPropertyWithReceiver updated to use these APIs.
Out of Scope Changes check ✅ Passed All changes align with fixing issue #246: test additions (Reflect.set proxy receiver behavior), ObjectValue implementation (TryDefineProperty/TryDefineSymbolProperty), and ProxyValue override (defineProperty trap dispatch).
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 Apr 9, 2026

Benchmark Results

274 benchmarks

Interpreted: 🟢 235 improved · 🔴 4 regressed · 35 unchanged · avg +8.1%
Bytecode: 🟢 117 improved · 🔴 34 regressed · 123 unchanged · avg +1.2%

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

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

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 9, 2026

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 4068 4068
Tests Passed 4027 ✅ 4068 ✅
Tests Skipped 41 0
Tests Test Duration 296.7ms 277.2ms
Tests Lex 80.3ms 52.9ms
Tests Parse 98.8ms 100.2ms
Tests Compile 62.7ms
Tests Execute 312.0ms 305.9ms
Tests Engine Total 491.1ms 521.7ms
Benchmarks Total 274 274
Benchmarks Duration 7.73min 6.48min

Measured on ubuntu-latest x64.

@frostney frostney merged commit 4c528b2 into main Apr 9, 2026
9 checks passed
@frostney frostney deleted the fix/reflect-set-proxy-receiver-define-property branch April 9, 2026 12:52
@frostney frostney added the bug Something isn't working label Apr 9, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Reflect.set with proxy receiver: route [[DefineOwnProperty]] through TryDefineProperty boolean API

1 participant