Skip to content

Make TGocciaLexerError inherit from TGocciaSyntaxError#627

Merged
frostney merged 3 commits into
mainfrom
t3code/fix-626
May 10, 2026
Merged

Make TGocciaLexerError inherit from TGocciaSyntaxError#627
frostney merged 3 commits into
mainfrom
t3code/fix-626

Conversation

@frostney
Copy link
Copy Markdown
Owner

Summary

  • Reparent TGocciaLexerError from TGocciaError to TGocciaSyntaxError, aligning the internal exception hierarchy with the ES spec which treats all early errors (lexer and parser) uniformly as SyntaxError.
  • Remove the 3 compensating or (E is TGocciaLexerError) clauses added in String literals should reject unescaped line terminators per ES spec #619 (evaluator, VM, testing library) — now redundant since E is TGocciaSyntaxError covers lexer errors via inheritance.
  • Remove the dead TGocciaLexerError branch in ErrorDisplayName.
  • Add a Pascal unit test asserting the inheritance relationship and JS tests confirming lexer errors surface as SyntaxError at the language level.

Closes #626

Testing

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

@vercel
Copy link
Copy Markdown

vercel Bot commented May 10, 2026

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

1 Skipped Deployment
Project Deployment Actions Updated (UTC)
gocciascript-homepage Ignored Ignored Preview May 10, 2026 9:04pm

Request Review

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented May 10, 2026

Review Change Stack
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: e09a86b5-fb6b-4819-af6b-c448e342577d

📥 Commits

Reviewing files that changed from the base of the PR and between 89a7a23 and 12d99cb.

📒 Files selected for processing (1)
  • docs/value-system.md
✅ Files skipped from review due to trivial changes (1)
  • docs/value-system.md

📝 Walkthrough

Walkthrough

TGocciaLexerError now inherits from TGocciaSyntaxError. Exception-to-error mapping and matcher logic were narrowed to rely on the parent type; unit and CLI tests were added/updated; documentation and example catch ordering were revised to reflect the new hierarchy.

Changes

Error Hierarchy Restructuring

Layer / File(s) Summary
Core Error Class Hierarchy
source/units/Goccia.Error.pas
TGocciaLexerError now inherits from TGocciaSyntaxError; ErrorDisplayName no longer checks TGocciaLexerError explicitly.
Exception-to-Error-Object Mapping
source/units/Goccia.Evaluator.pas, source/units/Goccia.VM.pas
PascalExceptionToErrorObject and OP_USING_DISPOSE now match only TGocciaSyntaxError for SYNTAX_ERROR_NAME conversion; lexer errors rely on inheritance or fall through to generic wrapping.
Test Expectation Matching
source/units/Goccia.Builtins.TestingLibrary.pas
TGocciaExpectationValue.ToThrow narrows SYNTAX_ERROR_NAME matching to TGocciaSyntaxError only.
Hierarchy Verification Tests
source/units/Goccia.Error.Test.pas, scripts/test-cli-lexer.ts
Added TestLexerErrorInheritFromSyntaxError to assert TGocciaLexerError is TGocciaSyntaxError; CLI test asserts lexer failures are reported as SyntaxError in JSON.
Documentation
docs/embedding.md, docs/errors.md, docs/interpreter.md, docs/value-system.md
Examples, exception tables, and embedding/interpreter/value-system docs updated to state TGocciaLexerError is a subclass of TGocciaSyntaxError and adjust example catch ordering.

Sequence Diagram(s)

sequenceDiagram
  participant Client
  participant Loader
  participant Lexer
  participant VM
  Client->>Loader: request load (invalid input)
  Loader->>Lexer: tokenize/parse
  Lexer-->>Loader: raises TGocciaLexerError
  Loader->>VM: propagate exception during OP_USING_DISPOSE
  VM->>VM: check E is TGocciaSyntaxError?
  alt yes
    VM-->>Client: CreateErrorObject(SYNTAX_ERROR_NAME) -> JSON { error.type: "SyntaxError" }
  else no
    VM-->>Client: CreateErrorObject(ERROR_NAME) -> JSON { error.type: "Error" }
  end
Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly and concisely summarizes the main structural change: reparenting TGocciaLexerError to inherit from TGocciaSyntaxError instead of TGocciaError.
Description check ✅ Passed The description comprehensively covers the change rationale, lists specific files modified and compensating clauses removed, and documents testing performed. Most template sections are addressed.
Linked Issues check ✅ Passed The PR directly implements all coding objectives from #626: reparents TGocciaLexerError to TGocciaSyntaxError, removes three or (E is TGocciaLexerError) compensating clauses, removes the dead ErrorDisplayName branch, and adds validation tests.
Out of Scope Changes check ✅ Passed All changes are strictly scoped to the inheritance refactoring and its consequences: hierarchy redefinition, removal of compensating clauses, dead-code elimination, and targeted test additions. No unrelated changes detected.
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.

The ES spec treats all early errors (lexer and parser) as SyntaxError.
Reparenting TGocciaLexerError under TGocciaSyntaxError aligns the
internal hierarchy with the spec and eliminates the compensating
`or (E is TGocciaLexerError)` checks added in #619.

Closes #626

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

github-actions Bot commented May 10, 2026

Suite Timing

Test Runner (interpreted: 9,243 passed; bytecode: 9,243 passed)
Metric Interpreted Bytecode
Total 9243 9243
Passed 9243 ✅ 9243 ✅
Workers 4 4
Test Duration 2.10s 2.10s
Lex (cumulative) 231.7ms 158.1ms
Parse (cumulative) 248.1ms 252.8ms
Compile (cumulative) 541.1ms
Execute (cumulative) 2.62s 1.98s
Engine Total (cumulative) 3.10s 2.93s
Lex (avg/worker) 57.9ms 39.5ms
Parse (avg/worker) 62.0ms 63.2ms
Compile (avg/worker) 135.3ms
Execute (avg/worker) 655.7ms 493.8ms
Engine Total (avg/worker) 775.6ms 731.8ms

Memory

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

Metric Interpreted Bytecode
GC Live 244.46 MiB 238.89 MiB
GC Peak Live 244.47 MiB 238.90 MiB
GC Allocated During Run 248.37 MiB 242.78 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1 1
GC Collected Objects 88 88
Heap Start Allocated 149.3 KiB 149.3 KiB
Heap End Allocated 2.54 MiB 2.54 MiB
Heap Delta Allocated 2.39 MiB 2.39 MiB
Heap Delta Free 140.1 KiB 140.1 KiB
Benchmarks (interpreted: 407; bytecode: 407)
Metric Interpreted Bytecode
Total 407 407
Workers 4 4
Duration 2.56min 2.35min

Memory

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

Metric Interpreted Bytecode
GC Live 3.65 MiB 3.64 MiB
GC Peak Live 124.97 MiB 85.81 MiB
GC Allocated During Run 15.57 GiB 9.88 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 2,830 2,634
GC Collected Objects 287,477,676 235,387,550
Heap Start Allocated 2.29 MiB 2.29 MiB
Heap End Allocated 2.29 MiB 2.29 MiB
Heap Delta Allocated 128 B 128 B

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 10, 2026

Benchmark Results

407 benchmarks

Interpreted: 🟢 350 improved · 🔴 27 regressed · 30 unchanged · avg +10.3%
Bytecode: 🟢 114 improved · 🔴 98 regressed · 195 unchanged · avg +1.5%

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

Deterministic profile diff

Deterministic profile diff: no significant changes.

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

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 10, 2026

test262 Conformance

Category Run Passed Δ Pass Failed Pass-rate Δ Rate
built-ins 23,449 14,627 +1 8,818 62.4% ±0pp
harness 116 71 ±0 45 61.2% ±0pp
intl402 3,324 691 ±0 2,633 20.8% ±0pp
language 23,635 12,575 ±0 11,060 53.2% ±0pp
staging 1,484 488 +3 994 32.9% +0.2pp
total 52,008 28,452 +4 23,550 54.7% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/WeakSet 98.8% ±0pp 84 / 85
built-ins/WeakMap 98.6% ±0pp 139 / 141
language/asi 97.1% ±0pp 99 / 102
Per-test deltas (+4 / -0)

Newly passing (4):

  • built-ins/Number/prototype/toExponential/undefined-fractiondigits.js
  • staging/sm/extensions/keyword-unescaped-requirement.js
  • staging/sm/misc/syntax-error-end-of-for-head-part.js
  • staging/sm/syntax/keyword-unescaped-requirement.js

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

@frostney frostney marked this pull request as ready for review May 10, 2026 20:55
@coderabbitai coderabbitai Bot added documentation Improvements or additions to documentation spec compliance Mismatch against official JavaScript/TypeScript specification internal Refactoring, CI, tooling, cleanup labels May 10, 2026
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

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

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@docs/value-system.md`:
- Line 752: Revise the sentence so it distinguishes early (parser/lexer) errors
from runtime errors: state that TGocciaError is a Pascal Exception superclass
(not a TGocciaValue and not a JavaScript Error), that TGocciaSyntaxError and
TGocciaLexerError represent early parser/lexer errors (mirroring ES
SyntaxError), and separately state that TGocciaRuntimeError represents runtime
engine errors; keep the note that these are internal Pascal exceptions and not
JS error objects and mirror the ES spec's subclassing where appropriate.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

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

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: efb72ff0-8005-4f1e-baaf-bb7fb6dc98c8

📥 Commits

Reviewing files that changed from the base of the PR and between e9de1f5 and 89a7a23.

📒 Files selected for processing (10)
  • docs/embedding.md
  • docs/errors.md
  • docs/interpreter.md
  • docs/value-system.md
  • scripts/test-cli-lexer.ts
  • source/units/Goccia.Builtins.TestingLibrary.pas
  • source/units/Goccia.Error.Test.pas
  • source/units/Goccia.Error.pas
  • source/units/Goccia.Evaluator.pas
  • source/units/Goccia.VM.pas

Comment thread docs/value-system.md Outdated
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@frostney frostney merged commit 12cea65 into main May 10, 2026
14 checks passed
@frostney frostney deleted the t3code/fix-626 branch May 10, 2026 21:17
frostney added a commit that referenced this pull request May 10, 2026
PascalExceptionToErrorObject had an `or (E is TGocciaLexerError)` clause
that was not part of #538 and is redundant after #627 made
TGocciaLexerError inherit from TGocciaSyntaxError. Revert to match main.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
frostney added a commit that referenced this pull request May 11, 2026
* Persist for-loop iteration state across generator resumes (#538)

The interpreter's EvaluateFor had no resume state, so a yield inside the
init, test, body, or update of a traditional for(;;) loop caused every
subsequent g.next() to re-enter the function from the top: Init re-ran,
HeaderScope/IterScope were re-created, and the loop counter never
advanced. The bytecode VM already preserved equivalent state in its
frame machinery; this brings the interpreter to parity.

Adds TGocciaGeneratorForLoopState (Phase + HeaderScope + IterScope)
keyed by the for statement AST node, mirroring the existing
TGocciaGeneratorLoopState used for for-of. On resume EvaluateFor
restores the saved scopes and jumps to gflpIterStart / gflpBody /
gflpUpdate. Sub-expression-level partial resume continues to use the
existing EvaluateExpression save/take cache, so a yield mid-condition
or mid-update round-trips correctly.

Closes #538

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Move for-loop generator yield tests into existing for-loop dirs

Tests previously lived in tests/language/for-loop-generator/ which
needed a separate goccia.json with compat-function so function*
declarations could be parsed. Rewrite each test to use object-method
generators ({ *gen() {} }), which need no compat-function flag, and
fold them into the existing for-loop/ directory (and for-loop-var/
for the new var-init yield test) so they ride the parent goccia.json.
Adds generator-yield.js under for-loop-var/ covering yield with var
init, init-runs-once across resumes, post-loop var visibility, and
update-yield with var.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Drop decision-log entry for #538

A bug fix that brings the interpreter into spec compliance (and into
parity with the bytecode VM) doesn't warrant a decision-log entry —
that's reserved for architectural and implementation decisions. The
commit history and PR description already document the change.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Remove unrelated TGocciaLexerError check that leaked into the diff

PascalExceptionToErrorObject had an `or (E is TGocciaLexerError)` clause
that was not part of #538 and is redundant after #627 made
TGocciaLexerError inherit from TGocciaSyntaxError. Revert to match main.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

documentation Improvements or additions to documentation internal Refactoring, CI, tooling, cleanup spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Make TGocciaLexerError inherit from TGocciaSyntaxError

1 participant