Skip to content

Support destructuring into member expression targets#413

Merged
frostney merged 2 commits into
mainfrom
t3code/issue-399-verify-implement
Apr 27, 2026
Merged

Support destructuring into member expression targets#413
frostney merged 2 commits into
mainfrom
t3code/issue-399-verify-implement

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 26, 2026

Summary

  • Added parsing, AST support, evaluation, and compilation for destructuring assignments that target member expressions like obj.prop, this.x, and obj[key].
  • Extended destructuring handling to support default values on member-expression targets.
  • Added coverage for array and object destructuring, computed properties, nested patterns, rest elements, and evaluation order.

Fixes #399

- Allow destructuring assignments into member expressions
- Handle object, computed, and default-value targets
@vercel
Copy link
Copy Markdown

vercel Bot commented Apr 26, 2026

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

Project Deployment Actions Updated (UTC)
gocciascript-homepage Ready Ready Preview, Comment Apr 27, 2026 10:35am

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 26, 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: 52af505c-200f-4d59-bfad-02921fd38eab

📥 Commits

Reviewing files that changed from the base of the PR and between 284a57f and 6de500c.

📒 Files selected for processing (1)
  • tests/language/expressions/destructuring/member-expression-targets.js
🚧 Files skipped from review as they are similar to previous changes (1)
  • tests/language/expressions/destructuring/member-expression-targets.js

📝 Walkthrough

Walkthrough

Adds support for using member expressions as destructuring assignment targets (e.g., obj.prop, arr[i], this.x) by introducing an AST pattern, updating parser pattern conversion, emitting bytecode for member-target assignments, and extending the evaluator; includes comprehensive tests for the new behavior.

Changes

Cohort / File(s) Summary
AST Pattern Definition
source/units/Goccia.AST.Expressions.pas
Adds TGocciaMemberExpressionDestructuringPattern class with constructor, public Expression property, and an overridden Evaluate (placeholder).
Parser
source/units/Goccia.Parser.pas
ConvertToPattern now accepts member expressions as destructuring targets and supports member targets with default values by wrapping them into assignment-pattern nodes.
Compiler
source/units/Goccia.Compiler.Expressions.pas
CollectDestructuringBindings skips member-expression targets; EmitDestructuring emits bytecode to assign into member targets (computed via OP_ARRAY_SET or constant via OP_SET_PROP_CONST) with temporary register management and constant-index checks.
Evaluator
source/units/Goccia.Evaluator.pas
Adds runtime destructuring-assignment handling for TGocciaMemberExpressionDestructuringPattern: evaluates receiver and key (if computed), performs symbol-aware fast-path assignments for object/class receivers, and falls back to AssignProperty otherwise.
Tests
tests/language/expressions/destructuring/member-expression-targets.js
Adds extensive tests covering array/object destructuring into member expressions, computed keys, nested patterns, rest targets, default values, evaluation order, and mixed identifier/member targets.

Sequence Diagram

sequenceDiagram
    participant Parser
    participant AST as "AST Pattern"
    participant Compiler
    participant Evaluator
    participant Runtime

    Parser->>Parser: Parse destructuring statement
    Parser->>AST: ConvertToPattern(memberExpression) -> TGocciaMemberExpressionDestructuringPattern
    Parser->>Compiler: Emit bytecode for assignment (pattern)
    Compiler->>Runtime: Evaluate RHS -> produce sourceValue
    Compiler->>Runtime: Prepare temporaries/registers for member targets
    Compiler->>Runtime: Evaluate target receiver (object) and key (if computed)
    Compiler->>Runtime: Emit op to write sourceValue to target (OP_ARRAY_SET / OP_SET_PROP_CONST)
    Runtime-->>Evaluator: Execute assignment opcode(s)
    Evaluator->>Runtime: For runtime path, evaluate receiver/key and call AssignProperty or symbol fast-path
    Runtime-->>Evaluator: Return assigned value
Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Suggested labels

spec compliance

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 inconclusive)

Check name Status Explanation Resolution
Description check ❓ Inconclusive The description covers the main changes (parsing, AST, evaluation, compilation support) and references issue #399, but is missing explicit confirmation of testing performed against the description template checklist items. Expand the description to explicitly verify the testing checklist items: end-to-end test verification, documentation updates, native Pascal test verification (if applicable), and benchmark verification.
✅ Passed checks (4 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly and concisely describes the main change: adding support for destructuring assignments targeting member expressions, which is the primary objective of this PR.
Linked Issues check ✅ Passed The code changes comprehensively address all requirements from issue #399: parser accepts member-expression targets, AST support added, evaluation/compilation implemented, and comprehensive tests cover all specified scenarios (this.x, obj.x, arr[i], computed properties, nested patterns, rest elements, default values, and evaluation order).
Out of Scope Changes check ✅ Passed All changes are directly scoped to implementing member-expression destructuring targets as specified in issue #399. No unrelated modifications detected across parser, AST, evaluator, compiler, and test files.
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.

Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

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

🧹 Nitpick comments (1)
tests/language/expressions/destructuring/member-expression-targets.js (1)

131-136: Add object-pattern coverage for the new default-member branches.

The default-value check here only covers the array case. The parser change added separate obj.prop = default and obj[key] = default conversion paths for object destructuring, but this file never exercises them, so that part of the feature can regress silently.

Based on learnings: JavaScript tests should cover happy paths, edge cases, and error cases. Keep tests isolated and grouped by feature/filename.

🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.

In `@tests/language/expressions/destructuring/member-expression-targets.js` around
lines 131 - 136, Add two tests to the same file alongside "member expression
targets with default values" covering the object-pattern branches: one named
like "object member expression target with default values (static key)" that
destructures an object into properties using obj.prop = default and asserts
obj.prop receives the source value when present and the default when undefined
(e.g., expect(obj.a).toBe(1); expect(obj.b).toBe(20)); and another named like
"object member expression target with default values (computed key)" that does
the same but uses a computed key path (obj[key] = default) and asserts the same
outcomes; place them grouped near the existing array-case test so object
default-member conversion paths are exercised.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@tests/language/expressions/destructuring/member-expression-targets.js`:
- Around line 131-136: Add two tests to the same file alongside "member
expression targets with default values" covering the object-pattern branches:
one named like "object member expression target with default values (static
key)" that destructures an object into properties using obj.prop = default and
asserts obj.prop receives the source value when present and the default when
undefined (e.g., expect(obj.a).toBe(1); expect(obj.b).toBe(20)); and another
named like "object member expression target with default values (computed key)"
that does the same but uses a computed key path (obj[key] = default) and asserts
the same outcomes; place them grouped near the existing array-case test so
object default-member conversion paths are exercised.

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: a27c839f-7335-420a-a04b-7464e0036a73

📥 Commits

Reviewing files that changed from the base of the PR and between 7e90fd0 and 284a57f.

📒 Files selected for processing (5)
  • source/units/Goccia.AST.Expressions.pas
  • source/units/Goccia.Compiler.Expressions.pas
  • source/units/Goccia.Evaluator.pas
  • source/units/Goccia.Parser.pas
  • tests/language/expressions/destructuring/member-expression-targets.js

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 26, 2026

Benchmark Results

386 benchmarks

Interpreted: 🟢 120 improved · 🔴 21 regressed · 245 unchanged · avg +2.0%
Bytecode: 🟢 48 improved · 🔴 96 regressed · 242 unchanged · avg -0.7%

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

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

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 7865 7865
Tests Passed 7824 ✅ 7865 ✅
Tests Skipped 41 0
Tests Workers 4 4
Tests Test Duration 1.91s 1.81s
Tests Lex (cumulative) 205.8ms 125.5ms
Tests Parse (cumulative) 298.8ms 295.7ms
Tests Compile (cumulative) 195.4ms
Tests Execute (cumulative) 1.81s 1.41s
Tests Engine Total (cumulative) 2.32s 2.02s
Tests Lex (avg/worker) 51.5ms 31.4ms
Tests Parse (avg/worker) 74.7ms 73.9ms
Tests Compile (avg/worker) 48.8ms
Tests Execute (avg/worker) 453.1ms 352.0ms
Tests Engine Total (avg/worker) 579.2ms 506.1ms
Benchmarks Total 386 386
Benchmarks Workers 4 4
Benchmarks Duration 3.08min 2.80min

Measured on ubuntu-latest x64.

- Cover static and computed member targets
- Verify default values apply when source values are undefined
@coderabbitai coderabbitai Bot added the spec compliance Mismatch against official JavaScript/TypeScript specification label Apr 27, 2026
@frostney frostney merged commit fbd1116 into main Apr 27, 2026
12 checks passed
@frostney frostney deleted the t3code/issue-399-verify-implement branch April 27, 2026 10:52
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Support destructuring assignment into member expressions ([this.a, this.b] = ...)

1 participant